CloudFront: Fundamentos da CDN
CloudFront é o serviço de Content Delivery Network (CDN) da AWS que distribui seu conteúdo para usuários finais com baixa latência, independentemente de sua localização geográfica. Ele funciona através de uma rede global de edge locations que armazenam cópias em cache do seu conteúdo, reduzindo a necessidade de requisições ao servidor de origem.
A arquitetura do CloudFront é composta por edge locations (pontos de presença distribuídos globalmente), regional caches e servidores de origem. Quando um usuário solicita um recurso, o CloudFront verifica se ele está em cache na edge location mais próxima. Se estiver, entrega instantaneamente. Caso contrário, busca do cache regional ou do servidor de origem, armazena em cache e entrega ao usuário. Isso reduz significativamente a latência e diminui a carga no seu servidor de origem.
// Exemplo: Criando uma distribuição CloudFront com Terraform
resource "aws_cloudfront_distribution" "exemplo" {
origin {
domain_name = "meusite.com.br"
origin_id = "minhaOrigemPrincipal"
}
enabled = true
default_root_object = "index.html"
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "minhaOrigemPrincipal"
forwarded_values {
query_string = false
cookies {
forward = "none"
}
}
viewer_protocol_policy = "redirect-to-https"
min_ttl = 0
default_ttl = 3600
max_ttl = 86400
}
restrictions {
geo_restriction {
restriction_type = "none"
}
}
viewer_certificate {
cloudfront_default_certificate = true
}
}
Behaviors: Roteamento Inteligente de Requisições
Behaviors (comportamentos) permitem aplicar diferentes estratégias de cache e processamento para diferentes padrões de URL. Você pode ter múltiplos behaviors em uma única distribuição, cada um com suas próprias políticas de cache, métodos HTTP permitidos e configurações de origem.
Um behavior é definido por um path pattern (por exemplo, /api/*, /images/*). O CloudFront processa behaviors em ordem: o primeiro match aplica suas regras. Isso permite cenários avançados como servir HTML dinâmico diferentemente de assets estáticos, ou rotear requisições a diferentes origens baseado na URL.
// Exemplo: Múltiplos Behaviors em uma distribuição
resource "aws_cloudfront_distribution" "avancada" {
origin {
domain_name = "api.meusite.com"
origin_id = "api"
}
origin {
domain_name = "cdn.meusite.com"
origin_id = "assets"
}
enabled = true
# Behavior 1: Requisições API - sem cache
ordered_cache_behavior {
path_pattern = "/api/*"
allowed_methods = ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "api"
cache_policy_id = "4135ea3d-c35d-46eb-81d7-reintje9aafd" # Managed-CachingDisabled
viewer_protocol_policy = "https-only"
}
# Behavior 2: Imagens - cache agressivo
ordered_cache_behavior {
path_pattern = "/images/*"
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "assets"
cache_policy_id = "658327ea-f89d-4fab-a63d-7e88639e58f6" # Managed-CachingOptimized
viewer_protocol_policy = "https-only"
}
# Behavior padrão - fallback
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "api"
cache_policy_id = "658327ea-f89d-4fab-a63d-7e88639e58f6"
viewer_protocol_policy = "redirect-to-https"
}
restrictions {
geo_restriction {
restriction_type = "none"
}
}
viewer_certificate {
cloudfront_default_certificate = true
}
}
Cache Policies: Controle Granular de Armazenamento
Cache Policies são conjuntos de configurações que determinam o tempo de vida (TTL) do cache, quais headers devem ser considerados para variar a resposta em cache e como o CloudFront deve se comportar. Você pode usar políticas gerenciadas pela AWS ou criar personalizadas.
As políticas gerenciadas mais importantes são: Caching Optimized (máximo de cache, sem headers customizados), CachingDisabled (sem cache para APIs dinâmicas) e Custom policies para casos específicos. A política define TTL mínimo, máximo e padrão. É crucial entender que se sua origem envia cache-control headers, o CloudFront respeita o valor mais restritivo entre a política e o header da origem.
// Exemplo: Cache Policy personalizada para REST API com validação
resource "aws_cloudfront_cache_policy" "api_policy" {
name = "api-cache-policy"
comment = "Política para APIs com cache seletivo"
default_ttl = 300
max_ttl = 600
min_ttl = 0
parameters_in_cache_key_and_forwarded_to_origin {
enable_accept_encoding_gzip = true
enable_accept_encoding_brotli = true
headers_config {
header_behavior = "whitelist"
headers {
items = ["Authorization", "CloudFront-Viewer-Country"]
}
}
query_strings_config {
query_string_behavior = "whitelist"
query_strings {
items = ["version", "format"]
}
}
cookies_config {
cookie_behavior = "whitelist"
cookies {
items = ["session-id"]
}
}
}
}
# Usando a política
resource "aws_cloudfront_distribution" "api_dist" {
# ... configurações anteriores ...
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "minha_origem"
cache_policy_id = aws_cloudfront_cache_policy.api_policy.id
viewer_protocol_policy = "https-only"
}
}
Lambda@Edge: Processamento Dinâmico na Borda
Lambda@Edge permite executar código Lambda nos edge locations do CloudFront, antes ou depois do cache hit/miss. Isso habilita transformações dinâmicas, autenticação, redirects e customizações sem latência do round-trip ao servidor de origem.
Existem quatro pontos de execução: viewer request (antes de verificar cache), origin request (se não estiver em cache), origin response (após receber da origem) e viewer response (antes de enviar ao cliente). Cada função Lambda deve estar na região us-east-1 e precisa assumir a role lambda.amazonaws.com com permissão edgelambda.amazonaws.com.
// Exemplo: Lambda@Edge para adicionar headers de segurança e rewrite URL
const lambda = require('aws-lambda');
exports.handler = async (event, context) => {
const request = event.Records[0].cf.request;
const headers = request.headers;
// Viewer Request: Validar token
if (request.uri === '/admin' && !headers['authorization']) {
return {
status: '401',
statusDescription: 'Unauthorized',
body: 'Token obrigatório'
};
}
// Origin Response: Adicionar headers de segurança
if (event.Records[0].cf.config.distributionDomainName) {
const response = event.Records[0].cf.response;
response.headers['strict-transport-security'] = [{
key: 'Strict-Transport-Security',
value: 'max-age=31536000; includeSubdomains'
}];
response.headers['x-content-type-options'] = [{
key: 'X-Content-Type-Options',
value: 'nosniff'
}];
return response;
}
// Rewrite de URL para versão mobile
const userAgent = headers['cloudfront-is-mobile-viewer'];
if (userAgent && userAgent[0].value === 'true') {
request.uri = '/mobile' + request.uri;
}
return request;
};
Para associar a função Lambda@Edge a um behavior, você precisa publicar uma versão (não pode usar $LATEST) e associá-la via Terraform ou Console:
resource "aws_lambda_function" "edge" {
filename = "lambda_edge.zip"
function_name = "cloudfront-security"
role = aws_iam_role.lambda_edge_role.arn
handler = "index.handler"
runtime = "nodejs18.x"
publish = true
}
resource "aws_cloudfront_distribution" "com_lambda_edge" {
# ... configurações anteriores ...
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "minha_origem"
cache_policy_id = "658327ea-f89d-4fab-a63d-7e88639e58f6"
lambda_function_association {
event_type = "viewer-request"
lambda_arn = aws_lambda_function.edge.qualified_arn
include_body = false
}
}
}
Conclusão
Dominando CloudFront, você consegue entregar conteúdo com latência mínima globalmente. Os três pilares são: Behaviors para direcionar requisições inteligentemente, Cache Policies para controlar TTL e headers de variação, e Lambda@Edge para processamento dinâmico na borda sem perda de performance. Comece com políticas gerenciadas, evolua para policies customizadas e use Lambda@Edge apenas quando necessário, pois adiciona complexidade e custo.