AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

CloudFrontArquitetura

Nível de dificuldade: Avançado (4 de 5)

CloudFront Functions passa a suportar chamadas de rede com cf.fetch() e cf.beacon()

Por AWS Hub7 min de leitura

O que muda na borda

Até agora, uma função rodando em CloudFront Functions só tomava decisão com o que já tinha em mãos: cabeçalhos da requisição, cookies, ou dados pré-carregados na CloudFront KeyValueStore. Era suficiente para redirecionamento, reescrita de URL e feature flag, mas não para perguntar a um serviço vivo se um token ainda é válido ou qual conteúdo aquele viewer específico deve receber.

No blog da AWS Networking & Content Delivery, a equipe de CloudFront descreve os novos métodos cf.fetch() e cf.beacon(), que abrem uma chamada de rede dentro do próprio runtime do CloudFront Functions. A função continua rodando em todas as localizações de borda, incluindo as do Brasil, mas agora pode consultar uma origem configurada na mesma distribuição antes de decidir o que fazer com a requisição.

Antes dessa mudança, esse tipo de lógica tinha duas rotas possíveis: subir para Lambda@Edge, que roda em menos localizações e custa mais por invocação, ou mandar a decisão para a origem, pagando o preço da ida e volta completa. Com a chamada de rede acontecendo na própria borda, a lógica dinâmica fica onde a requisição já está, sem esse salto.

Como funciona o cf.fetch()

O cf.fetch() funciona dentro de uma função associada ao evento Viewer Request (ou outro evento suportado), e só pode chamar uma origem que esteja cadastrada na mesma distribuição CloudFront, seja um ALB, um VPC origin ou um serviço de terceiros atrás de uma origem customizada. Isso é uma restrição deliberada: a AWS não deixa a função sair fazendo chamada para qualquer endpoint da internet, o que teria implicações sérias de segurança e de controle de custo.

O exemplo de código publicado no anúncio mostra uma função que intercepta um token Bearer, extrai método e recurso da requisição e manda tudo para um endpoint de autorização:

javascript
import cf from 'cloudfront';

async function handler(event) {
  const request = event.request;
  const token = request.headers['authorization']
    ? request.headers['authorization'].value
    : null;

  if (!token) {
    return { statusCode: 401, statusDescription: 'Unauthorized' };
  }

  try {
    const decision = await cf.fetch('/v1/check', {
      originId: 'auth-origin',
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        authorization: token,
      },
      body: JSON.stringify({
        action: request.method === 'GET' ? 'read' : 'write',
        resource: request.uri,
      }),
      includeBody: true,
    });

    if (!decision.ok) {
      return { statusCode: 403, statusDescription: 'Forbidden' };
    }

    const result = await decision.json();
    if (!result.allowed) {
      return { statusCode: 403, statusDescription: 'Forbidden' };
    }

    return request;
  } catch (e) {
    return { statusCode: 503, statusDescription: 'Service Unavailable' };
  }
}

Repare no try/catch: a chamada de rede pode falhar ou dar timeout, e a função precisa decidir o que fazer com a requisição nesse cenário. Isso é um trade-off de confiabilidade que não existia quando a função só lia dados locais: agora o comportamento da borda depende da saúde de uma origem externa.

cf.beacon(): telemetria sem bloquear a resposta

O segundo método, cf.beacon(), resolve um problema diferente: coletar sinal de uso sem adicionar latência à resposta. A função dispara o evento em segundo plano e a página é servida sem esperar confirmação, o que o anúncio chama de padrão fire-and-forget.

O caso de uso descrito pela AWS é uma agência de marketing que distribui links de campanha com um ID de rastreio único em cada URL. Em vez de montar um pipeline que varre access logs do CloudFront atrás desse ID, a função lê o parâmetro na própria requisição e manda um evento pequeno (ID, localização de borda, timestamp) direto para um coletor de métricas configurado como origem.

Um detalhe relevante para quem desenha cache: como a função roda no evento Viewer Request, ela executa antes da consulta ao cache. Isso significa que visualizações de conteúdo em cache HIT também são contabilizadas, algo que normalmente escapa de métricas baseadas só em log de origem.

O exemplo real: DataDome trocou Lambda@Edge por CloudFront Functions

O caso mais concreto do anúncio é o da DataDome, empresa de detecção de bot e fraude que já integrava sua inspeção de requisições com CloudFront via Lambda@Edge. Trabalhando com a AWS antes do lançamento dos métodos de rede, a DataDome reconstruiu a integração em cima de CloudFront Functions.

O resultado, segundo a AWS, foi 60% de redução de custo para os clientes da DataDome em comparação com a implementação anterior em Lambda@Edge. A arquitetura descrita funciona assim:

  1. O viewer faz a requisição à distribuição CloudFront.
  2. Uma função Viewer Request monta um cf.fetch() com URI, método, user agent e cabeçalhos selecionados, e envia para a API de detecção configurada como origem.
  3. A API da DataDome devolve um veredito.
  4. A função deixa a requisição seguir, bloqueia com 403, ou redireciona o viewer para uma página de desafio.

Para quem administra distribuições CloudFront e hoje mantém uma função Lambda@Edge só para plugar um serviço de terceiro de segurança ou autorização, esse é o tipo de caso que justifica avaliar a migração: menos componentes de computação, cobrança por chamada de rede em vez de por tempo de execução completo de uma função Lambda, e processamento acontecendo em mais pontos de presença.

Configuração: origem, VPC origin e cache behavior

A chamada de rede exige que a origem alvo esteja cadastrada na distribuição. No console do CloudFront, isso significa abrir a distribuição, ir até a aba Origins, e adicionar a origem que a função vai chamar, seja um VPC origin apontando para um ALB interno em sa-east-1, seja um endpoint HTTP externo com origin access control configurado.

Um ponto que vale registrar para quem pensa em Well-Architected: a AWS recomenda não criar uma cache behavior que roteie tráfego normal de viewer para essa origem de autorização, a menos que seja necessário. A origem existe só para receber a chamada de rede da função, não para servir conteúdo cacheável, e misturar os dois papéis complica o desenho e o troubleshooting depois.

Como o alvo é uma origem já conhecida da distribuição, as chamadas de rede reutilizam conexão e usam connection pooling, evitando abrir uma conexão TCP nova a cada requisição. Isso ajuda a manter a vantagem de latência que é a razão de existir do CloudFront Functions frente a alternativas rodando em menos localizações.

O trade-off: Performance Efficiency contra Reliability

O ganho principal aqui é de Performance Efficiency: lógica que antes precisava subir para Lambda@Edge (menos localizações, cold start maior, custo por GB-segundo) ou ir até a origem agora roda inteira na borda mais próxima do usuário. Para autenticação de API e MCP, bot detection e qualquer decisão de roteamento que dependa de estado externo, isso reduz latência de ponta a ponta de forma mensurável.

O custo desse ganho é em Reliability: a função agora depende da disponibilidade da origem chamada. Um cf.fetch() que trava ou retorna erro muda o comportamento de toda a distribuição, então o catch do exemplo de código não é só boa prática, é parte obrigatória do desenho. Quem for adotar isso em produção precisa decidir o fallback: bloquear a requisição (fail closed, mais seguro) ou deixar passar (fail open, mais disponível), e essa decisão é de negócio, não técnica.

Outro ponto de atenção é Cost Optimization. As chamadas de rede são cobradas a $0.10 por milhão de chamadas, além da cobrança padrão de invocação do CloudFront Functions, e exigem o plano flat-rate Pro tier ou superior para quem usa os planos com tarifa fixa da CloudFront. É barato por chamada, mas em uma distribuição com volume alto e uma função que chama rede em todo request de um cache behavior inteiro, o custo soma rápido, principalmente comparado a manter decisões que puderem ficar só na KeyValueStore.

Quando não vale a pena

Se a lógica pode ser resolvida com um lookup em KeyValueStore (mapa de redirecionamento, feature flag estático, rewrite de URL conhecido), os métodos de rede não trazem benefício e só adicionam uma dependência externa desnecessária. Chamada de rede serve para o caso em que a resposta depende de um sistema vivo que muda entre uma requisição e outra, como budget de uso de uma API, validade de um token ou veredito de um serviço de bot detection.

Vale também medir a latência real da origem chamada antes de colocar isso em um cache behavior de alto tráfego. A chamada de rede não some, ela só migra para dentro da própria borda, e uma origem lenta ainda vai lentificar cada requisição que passar por essa função.

Network calls em CloudFront Functions já está disponível em todas as localizações de borda da CloudFront. Os detalhes de limites e cotas estão na documentação de CloudFront Functions, e o anúncio original traz o exemplo completo de autorização usado neste texto.

Fonte: AWS Networking & Content Delivery Blog

Serviços neste textoCloudFront

Leve para a sua IA

Decida com o seu assistente, com o contexto deste texto já montado.

1. O que você quer saber

Ver o prompt
Li no AWS Hub: "CloudFront Functions passa a suportar chamadas de rede com cf.fetch() e cf.beacon()" (https://awshub.com.br/arquitetura/cloudfront-functions-passa-a-suportar-chamadas-de-rede-com-cf-fetch-e-cf-beacon).
Resumo: Com os métodos cf.fetch() e cf.beacon(), uma função roda no runtime leve do CloudFront Functions e chama uma origem da própria distribuição em tempo real, cobrindo casos que antes exigiam Lambda@Edge ou uma volta até a origem.
Fonte oficial: https://aws.amazon.com/blogs/networking-and-content-delivery/introducing-network-calls-in-amazon-cloudfront-functions/
Serviços: CloudFront

Minha stack: [descreva em uma linha: serviços, linguagem, volume, região]

Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.