Lab 05 — Domínio, TLS e o estático na borda

# Rode ANTES de mudar nada, e de fora da regiao da aplicacao.
# `curl` de um host em Lisboa, ou de uma instancia em eu-west-3, serve.
ALVO="http://ffv-lab-alb-1234567890.sa-east-1.elb.amazonaws.com"

# 1. Tempo ate o primeiro byte de UM arquivo. Isto mede distancia.
for i in $(seq 1 10); do
  curl -s -o /dev/null -w "%{time_connect} %{time_starttransfer} %{time_total}\n" \
    "$ALVO/assets/app.js"
done

# 2. A pagina inteira: os 42 arquivos, em sequencia de dependencia.
#    Sem navegador nao ha como reproduzir a cascata fielmente; o que este
#    laco mede e o piso, e o piso ja basta para a decisao.
curl -s "$ALVO/" -o /tmp/index.html
grep -o -E '(src|href)="[^"]+"' /tmp/index.html | cut -d\" -f2 | sort -u \
  | while read -r caminho; do
      curl -s -o /dev/null -w "%{time_total} $caminho\n" "$ALVO$caminho"
    done | sort -rn | head -10

# Na Cadencia, de Lisboa: conexao 0,19 s · primeiro byte 0,21 s · total da
# pagina 4,8 s. De Sao Paulo: 0,02 / 0,03 / 0,9 s. A conta fecha: a diferenca
# de 3,9 s e aproximadamente 0,19 s de ida e volta multiplicado pelas idas que
# a cascata de dependencia nao consegue paralelizar.
# Estes numeros sao da aplicacao de exemplo. Meca os seus: a sua cascata tem
# outra forma, e e a forma dela que decide o multiplicador.

// O que a API do CloudFront devolve, resumido nos campos que decidem.
// `aws cloudfront get-distribution-config --id E1PDQ2EXAMPLE`
//
// Este e o payload em que o defeito mais grave deste laboratorio e VISIVEL: a
// ordem dentro de CacheBehaviors.Items.
{
  "DistributionConfig": {
    "Aliases": { "Quantity": 2, "Items": ["cadencia.com.br", "www.cadencia.com.br"] },
    "DefaultRootObject": "index.html",

    "Origins": { "Quantity": 2, "Items": [
      {
        "Id": "estatico",
        "DomainName": "ffv-lab-front-111122223333.s3.sa-east-1.amazonaws.com",
        // OAC presente e OAI vazio: e assim que se confirma que a assinatura
        // esta ativa. Os dois preenchidos ao mesmo tempo e migracao pela metade.
        "OriginAccessControlId": "E2ABCDEXAMPLE",
        "S3OriginConfig": { "OriginAccessIdentity": "" }
      },
      {
        "Id": "api",
        // NAO e o nome *.elb.amazonaws.com: o certificado do ALB nao o cobre, e
        // o resultado seria 502 em toda chamada de API.
        "DomainName": "origem.cadencia.com.br",
        "CustomOriginConfig": {
          "OriginProtocolPolicy": "https-only",
          "OriginSslProtocols": { "Quantity": 1, "Items": ["TLSv1.2"] }
        },
        "CustomHeaders": { "Quantity": 1, "Items": [
          { "HeaderName": "X-Origem-Autorizada", "HeaderValue": "<vem do Secrets Manager>" }
        ]}
      }
    ]},

    // O coringa. Ele e sempre o ULTIMO a ser avaliado, e nao aparece na lista
    // ordenada abaixo — tem campo proprio.
    "DefaultCacheBehavior": {
      "TargetOriginId": "estatico",
      "ViewerProtocolPolicy": "redirect-to-https",
      "CachePolicyId": "8a1b2c3d-0000-4444-8888-ffv-lab-estatico",
      "Compress": true
    },

    // A ORDEM desta lista e a regra de roteamento. O primeiro padrao que casa
    // vence. Mover /api/* para depois de um padrao mais amplo faria a API ser
    // armazenada na borda — e resposta de um usuario chegaria a outro.
    "CacheBehaviors": { "Quantity": 1, "Items": [
      {
        "PathPattern": "/api/*",
        "TargetOriginId": "api",
        // Managed-CachingDisabled: TTL minimo, maximo e padrao em zero.
        "CachePolicyId": "4135ea2d-6df8-44a3-9df3-4b5a84be39ad",
        // Managed-AllViewer: encaminha tudo do visitante, inclusive o Host.
        "OriginRequestPolicyId": "216adef6-5c7f-47e4-b989-5492eafa07d3",
        "AllowedMethods": { "Quantity": 7, "Items": [
          "GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"
        ]}
      }
    ]},

    "ViewerCertificate": {
      // Regiao embutida no ARN. Qualquer coisa diferente de us-east-1 aqui
      // significa que o apply falhou e alguem editou no console.
      "ACMCertificateArn": "arn:aws:acm:us-east-1:111122223333:certificate/abcd-1234",
      "SSLSupportMethod": "sni-only",
      "MinimumProtocolVersion": "TLSv1.2_2021"
    },

    // Ausente de proposito: pagina de erro customizada e configuracao da
    // DISTRIBUICAO, nao do comportamento. Mapear 404 para /index.html faria o
    // 404 legitimo da API responder HTML com status 200.
    "CustomErrorResponses": { "Quantity": 0 }
  }
}

# dns-tls.tf — o nome, e os DOIS certificados que esta arquitetura exige

# Duas regioes no mesmo modulo, de proposito. A distribuicao do CloudFront so
# aceita certificado de us-east-1; o ALB so aceita certificado da regiao dele.
# Nao e redundancia: sao dois pontos de terminacao de TLS diferentes.
provider "aws" {
  region = var.regiao # sa-east-1 neste laboratorio
}

provider "aws" {
  alias  = "borda"
  region = "us-east-1"
}

variable "dominio" {
  type        = string
  description = "Dominio registrado, ja delegado a uma zona do Route 53. Ex.: cadencia.com.br"
}

variable "regiao" {
  type    = string
  default = "sa-east-1"
}

locals {
  tags = {
    Projeto   = var.projeto
    Ambiente  = var.ambiente
    Modulo    = "L05-borda"
    CentroDeCusto = var.centro_de_custo # o rateio do L09 depende desta tag
  }
}

# A zona ja existe: quem registra o dominio delega o NS para ela. Se o
# registrador aponta para outro provedor de DNS, nada abaixo funciona — e o
# sintoma e "o site nao resolve", sem erro em log nenhum.
data "aws_route53_zone" "raiz" {
  name         = var.dominio
  private_zone = false
}

# ── Certificado da BORDA: us-east-1, sempre ─────────────────────────────────
resource "aws_acm_certificate" "borda" {
  provider          = aws.borda
  domain_name       = var.dominio
  validation_method = "DNS"

  # O "www" entra como nome alternativo para o redirecionamento funcionar no
  # mesmo certificado. Cada nome alternativo tem de estar no certificado: a
  # distribuicao recusa nome alternativo que o certificado nao cobre.
  subject_alternative_names = ["www.${var.dominio}"]

  # Certificado em uso nao pode ser destruido. Sem isto, qualquer mudanca de
  # nome vira um apply que tenta apagar antes de criar, e falha na metade.
  lifecycle {
    create_before_destroy = true
  }

  tags = local.tags
}

# Validacao por DNS: o ACM entrega um par nome/valor de CNAME e observa a zona.
#
# O `for_each` e indexado por `domain_name` por um motivo documentado: para um
# dominio curinga e sua base, o ACM gera o MESMO par nome/valor. Indexar pela
# lista produziria duas entradas identicas e o Terraform reclamaria de recurso
# duplicado.
resource "aws_route53_record" "validacao_borda" {
  for_each = {
    for o in aws_acm_certificate.borda.domain_validation_options : o.domain_name => {
      nome  = o.resource_record_name
      tipo  = o.resource_record_type
      valor = o.resource_record_value
    }
  }

  zone_id = data.aws_route53_zone.raiz.zone_id
  name    = each.value.nome
  type    = each.value.tipo
  records = [each.value.valor]
  ttl     = 60

  # Reexecutar depois de recriar o certificado sobrescreve o registro antigo em
  # vez de falhar. Sem isto, o segundo apply para em "registro ja existe".
  allow_overwrite = true
}

# Este recurso nao cria nada: ele ESPERA a emissao. Sem ele, a distribuicao
# tenta usar um ARN de certificado ainda pendente e o apply falha.
resource "aws_acm_certificate_validation" "borda" {
  provider                = aws.borda
  certificate_arn         = aws_acm_certificate.borda.arn
  validation_record_fqdns = [for r in aws_route53_record.validacao_borda : r.fqdn]

  timeouts {
    # O ACM desiste em 72 h e marca o certificado como "Validation timed out".
    # 15 min e paciencia suficiente para erro de zona errada aparecer aqui, em
    # vez de tres dias depois.
    create = "15m"
  }
}

# ── Certificado da ORIGEM: regiao da aplicacao ──────────────────────────────
#
# Por que um nome proprio para a origem, em vez de apontar a distribuicao para
# o nome *.elb.amazonaws.com do balanceador: com HTTPS entre borda e origem, um
# dos nomes do certificado do ALB tem de casar com o nome de dominio
# configurado como origem. O nome da AWS nao esta no seu certificado — e o
# visitante recebe 502.
resource "aws_acm_certificate" "origem" {
  domain_name       = "origem.${var.dominio}"
  validation_method = "DNS"
  lifecycle {
    create_before_destroy = true
  }
  tags = local.tags
}

resource "aws_route53_record" "validacao_origem" {
  for_each = {
    for o in aws_acm_certificate.origem.domain_validation_options : o.domain_name => {
      nome  = o.resource_record_name
      tipo  = o.resource_record_type
      valor = o.resource_record_value
    }
  }
  zone_id         = data.aws_route53_zone.raiz.zone_id
  name            = each.value.nome
  type            = each.value.tipo
  records         = [each.value.valor]
  ttl             = 60
  allow_overwrite = true
}

resource "aws_acm_certificate_validation" "origem" {
  certificate_arn         = aws_acm_certificate.origem.arn
  validation_record_fqdns = [for r in aws_route53_record.validacao_origem : r.fqdn]
}

# O nome da origem tambem e ALIAS: aponta para o ALB do L01 e nao cobra
# consulta. Ele e publico de proposito — o que impede acesso direto nao e
# esconder o nome (seguranca por obscuridade), e sim o grupo de seguranca mais
# o cabecalho secreto que a aplicacao exige.
resource "aws_route53_record" "origem" {
  zone_id = data.aws_route53_zone.raiz.zone_id
  name    = "origem.${var.dominio}"
  type    = "A"

  alias {
    name                   = aws_lb.publico.dns_name
    zone_id                = aws_lb.publico.zone_id
    evaluate_target_health = false
  }
}

# O listener 443 do ALB, agora com certificado de verdade. A politica de
# seguranca fecha em TLS 1.2 para cima.
resource "aws_lb_listener" "https" {
  load_balancer_arn = aws_lb.publico.arn
  port              = 443
  protocol          = "HTTPS"
  ssl_policy        = "ELBSecurityPolicy-TLS13-1-2-2021-06"
  certificate_arn   = aws_acm_certificate_validation.origem.certificate_arn

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.api.arn
  }
}

# borda.tf — o bucket privado, as duas politicas de cache e a distribuicao
#
# `aws_vpc.principal`, `aws_lb.publico` e `aws_lb_target_group.api` vem do L01 e
# do L02: este modulo nao os recria, referencia. Se o seu L01 usa outro nome,
# ajuste as referencias ou exponha-os por `terraform_remote_state`.

data "aws_caller_identity" "atual" {}

# ── Origem do estatico ──────────────────────────────────────────────────────
resource "aws_s3_bucket" "estatico" {
  bucket = "${var.projeto}-front-${data.aws_caller_identity.atual.account_id}"

  # Sem isto, `terraform destroy` falha com o bucket cheio e voce descobre no
  # fim da aula. Em producao, deixe FALSE: apagar bucket com objeto e
  # exatamente o acidente que a flag protege.
  force_destroy = var.ambiente != "prod"

  tags = local.tags
}

# O bucket nunca e publico. Quem serve e a borda; o bucket so responde a ela.
resource "aws_s3_bucket_public_access_block" "estatico" {
  bucket                  = aws_s3_bucket.estatico.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

# O OAC exige propriedade imposta pelo dono do bucket — e desligar ACL e o
# padrao de bucket novo desde 2023.
resource "aws_s3_bucket_ownership_controls" "estatico" {
  bucket = aws_s3_bucket.estatico.id
  rule {
    object_ownership = "BucketOwnerEnforced"
  }
}

resource "aws_s3_bucket_versioning" "estatico" {
  bucket = aws_s3_bucket.estatico.id
  versioning_configuration {
    status = "Enabled"
  }
}

# Versionamento sem expiracao cresce sem teto: cada publicacao deixa a versao
# anterior de todo arquivo trocado.
resource "aws_s3_bucket_lifecycle_configuration" "estatico" {
  bucket = aws_s3_bucket.estatico.id
  rule {
    id     = "expira-versoes-antigas"
    status = "Enabled"
    filter {}
    noncurrent_version_expiration {
      noncurrent_days = 30
    }
  }
}

# ── Bucket do registro de acesso ────────────────────────────────────────────
#
# ATENCAO, e esta e uma incerteza declarada: a entrega do registro padrao ao S3
# tem exigencia propria de permissao no bucket, e ela mudou entre as versoes de
# registro padrao do CloudFront. Confira a pagina de registro padrao antes de
# assumir que criar o bucket basta — se o log nao aparecer em algumas horas, e
# aqui que a causa esta, nao na distribuicao.
resource "aws_s3_bucket" "logs" {
  bucket        = "${var.projeto}-logs-${data.aws_caller_identity.atual.account_id}"
  force_destroy = var.ambiente != "prod"
  tags          = local.tags
}

resource "aws_s3_bucket_public_access_block" "logs" {
  bucket                  = aws_s3_bucket.logs.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

# Registro de acesso guarda endereco IP e caminho: e dado pessoal com prazo, nao
# arquivo eterno. Sem esta regra, e a linha de custo que ninguem ve crescer.
resource "aws_s3_bucket_lifecycle_configuration" "logs" {
  bucket = aws_s3_bucket.logs.id
  rule {
    id     = "retencao-de-log"
    status = "Enabled"
    filter {}
    expiration {
      days = 90
    }
  }
}

# ── Controle de acesso de origem: a borda ASSINA cada leitura ───────────────
resource "aws_cloudfront_origin_access_control" "estatico" {
  name                              = "${var.projeto}-front"
  origin_access_control_origin_type  = "s3"
  signing_behavior                  = "always"
  signing_protocol                  = "sigv4"
}

# A politica do bucket nao autoriza "o CloudFront": autoriza ESTA distribuicao.
# Sem a condicao de ARN de origem, qualquer distribuicao de qualquer conta
# poderia usar seu bucket como origem.
data "aws_iam_policy_document" "estatico" {
  statement {
    sid    = "LeituraSomenteDestaDistribuicao"
    effect = "Allow"

    principals {
      type        = "Service"
      identifiers = ["cloudfront.amazonaws.com"]
    }

    actions = ["s3:GetObject"]

    # Objeto, nao bucket: `s3:GetObject` opera sobre chave. Nao ha `ListBucket`
    # aqui de proposito — a borda nao precisa listar, e sem listagem um caminho
    # inexistente devolve 403 em vez de revelar o que existe.
    resources = ["${aws_s3_bucket.estatico.arn}/*"]

    condition {
      test     = "StringEquals"
      variable = "AWS:SourceArn"
      values   = [aws_cloudfront_distribution.site.arn]
    }
  }
}

resource "aws_s3_bucket_policy" "estatico" {
  bucket = aws_s3_bucket.estatico.id
  policy = data.aws_iam_policy_document.estatico.json
}

# ── Politica de cache do ESTATICO: a chave mais estreita possivel ───────────
resource "aws_cloudfront_cache_policy" "estatico" {
  name    = "${var.projeto}-estatico"
  comment = "Chave so com o caminho. Cookie ou consulta aqui multiplicaria o cache."

  # min_ttl = 0 e decisao, nao descuido. Com min_ttl > 0 o CloudFront guarda o
  # objeto por aquele tempo MESMO que a origem responda no-cache, no-store ou
  # private — a documentacao avisa isso em letras miudas, e e a causa da falha
  # mais dificil de diagnosticar deste laboratorio.
  min_ttl = 0

  # Vale apenas quando a origem NAO manda Cache-Control nem Expires.
  default_ttl = 3600

  # Teto do que o Cache-Control da origem pode pedir. Um ano cobre o arquivo
  # com hash no nome, que e o unico que pede tanto.
  max_ttl = 31536000

  parameters_in_cache_key_and_forwarded_to_origin {
    # Habilitar as duas compressoes normaliza o Accept-Encoding do visitante
    # para uma forma canonica antes de entrar na chave. Sem isso, a variedade
    # de Accept-Encoding dos navegadores fragmentaria o cache.
    enable_accept_encoding_gzip   = true
    enable_accept_encoding_brotli = true

    cookies_config {
      cookie_behavior = "none"
    }
    headers_config {
      header_behavior = "none"
    }
    query_strings_config {
      query_string_behavior = "none"
    }
  }
}

# Politicas gerenciadas, por ID, para a rota dinamica. Nao ha por que manter
# copia local de politica que a AWS mantem.
data "aws_cloudfront_cache_policy" "desligado" {
  name = "Managed-CachingDisabled"
}

# AllViewer encaminha TUDO do visitante, inclusive o cabecalho Host. Para uma
# origem ALB isso e o que se quer: a aplicacao ve o nome publico e monta
# redirecionamento e link absoluto com ele. Origem de API Gateway ou URL de
# funcao Lambda exigiria AllViewerExceptHostHeader, porque essas esperam o Host
# da propria origem.
data "aws_cloudfront_origin_request_policy" "todo_visitante" {
  name = "Managed-AllViewer"
}

resource "aws_cloudfront_response_headers_policy" "seguranca" {
  name = "${var.projeto}-seguranca"

  security_headers_config {
    strict_transport_security {
      access_control_max_age_sec = 31536000
      include_subdomains         = true
      preload                    = false # so ligue depois de ter certeza de TODO subdominio em HTTPS
      override                   = true
    }
    content_type_options {
      override = true
    }
    frame_options {
      frame_option = "DENY"
      override     = true
    }
    referrer_policy {
      referrer_policy = "strict-origin-when-cross-origin"
      override        = true
    }
  }

  # Server-Timing e o instrumento de medicao deste laboratorio: ele diz se a
  # resposta veio do cache e de qual camada. Amostragem baixa em producao; a
  # prova usa o cabecalho `Pragma: server-timing`, que forca a inclusao em
  # qualquer taxa.
  server_timing_headers_config {
    enabled       = true
    sampling_rate = 1
  }
}

# ── A distribuicao ──────────────────────────────────────────────────────────
resource "aws_cloudfront_distribution" "site" {
  enabled         = true
  is_ipv6_enabled = true
  comment         = "${var.projeto} — front e API no mesmo dominio"
  aliases         = [var.dominio, "www.${var.dominio}"]

  # Sem isto, a raiz do site responde 403: o CloudFront pediria o objeto de
  # chave vazia ao bucket.
  default_root_object = "index.html"

  # A classe de preco restringe de quais pontos de presenca o conteudo e
  # servido. Restringir reduz o custo de transferencia e AUMENTA a latencia de
  # quem esta fora das regioes mantidas — e o publico de Lisboa e Luanda e
  # justamente o motivo deste laboratorio.
  price_class = "PriceClass_All"

  origin {
    origin_id                = "estatico"
    domain_name              = aws_s3_bucket.estatico.bucket_regional_domain_name
    origin_access_control_id = aws_cloudfront_origin_access_control.estatico.id
  }

  origin {
    origin_id   = "api"
    domain_name = "origem.${var.dominio}" # NAO o nome *.elb.amazonaws.com: veja dns-tls.tf

    custom_origin_config {
      http_port              = 80
      https_port             = 443
      origin_protocol_policy = "https-only"
      origin_ssl_protocols   = ["TLSv1.2"]
    }

    # Prova de que a requisicao veio DESTA distribuicao. A lista de prefixo
    # gerenciada do CloudFront no grupo de seguranca do ALB barra o que nao e
    # CloudFront; ela nao distingue a sua borda da borda de outra pessoa. Este
    # cabecalho distingue.
    custom_header {
      name  = "X-Origem-Autorizada"
      value = data.aws_secretsmanager_secret_version.origem.secret_string
    }
  }

  # Comportamento CORINGA: o estatico. Ele e sempre o ultimo a ser avaliado,
  # independentemente da ordem no arquivo.
  default_cache_behavior {
    target_origin_id       = "estatico"
    viewer_protocol_policy = "redirect-to-https"
    allowed_methods        = ["GET", "HEAD", "OPTIONS"]
    cached_methods         = ["GET", "HEAD"]
    compress               = true

    cache_policy_id            = aws_cloudfront_cache_policy.estatico.id
    response_headers_policy_id = aws_cloudfront_response_headers_policy.seguranca.id
  }

  # Comportamento ORDENADO: o primeiro padrao que casa vence, e este e avaliado
  # antes do coringa. Inverter a ordem faria a API ser armazenada na borda —
  # que e como resposta de um usuario chega a outro.
  ordered_cache_behavior {
    path_pattern           = "/api/*"
    target_origin_id       = "api"
    viewer_protocol_policy = "https-only"
    allowed_methods        = ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"]
    cached_methods         = ["GET", "HEAD"]
    compress               = true

    cache_policy_id            = data.aws_cloudfront_cache_policy.desligado.id
    origin_request_policy_id   = data.aws_cloudfront_origin_request_policy.todo_visitante.id
    response_headers_policy_id = aws_cloudfront_response_headers_policy.seguranca.id
  }

  viewer_certificate {
    acm_certificate_arn = aws_acm_certificate_validation.borda.certificate_arn
    ssl_support_method  = "sni-only"

    # Corta TLS 1.0 e 1.1. O padrao historico e mais permissivo, e nao ha
    # motivo para aceita-lo num site novo.
    minimum_protocol_version = "TLSv1.2_2021"
  }

  restrictions {
    geo_restriction {
      restriction_type = "none"
    }
  }

  # NAO ha custom_error_response aqui, e isso e decisao com motivo: pagina de
  # erro customizada e configuracao da DISTRIBUICAO, nao do comportamento.
  # Mapear 404 para /index.html com 200 — a receita comum de SPA — faria o 404
  # legitimo de /api/pedidos/999 virar HTML com status 200. O roteamento de SPA
  # na borda e o L20, e la o assunto ganha secao propria.

  logging_config {
    bucket          = aws_s3_bucket.logs.bucket_domain_name
    prefix          = "cloudfront/"
    include_cookies = false # cookie em log de acesso e dado pessoal a mais para guardar
  }

  tags = local.tags
}

# Metricas de taxa de acerto e latencia de origem NAO vem de graca: e uma
# assinatura por distribuicao, cobrada por metrica-mes. Sem ela, a pergunta
# "qual e minha taxa de acerto?" so tem resposta pelo registro de acesso.
resource "aws_cloudfront_monitoring_subscription" "site" {
  distribution_id = aws_cloudfront_distribution.site.id
  monitoring_subscription {
    realtime_metrics_subscription_config {
      realtime_metrics_subscription_status = "Enabled"
    }
  }
}

# ── O nome no apice, e o www ────────────────────────────────────────────────
#
# ALIAS, nao CNAME: nao existe CNAME no apice de uma zona. E consulta por ALIAS
# a recurso da AWS nao e cobrada, enquanto a de CNAME e.
resource "aws_route53_record" "apice" {
  for_each = toset(["A", "AAAA"])

  zone_id = data.aws_route53_zone.raiz.zone_id
  name    = var.dominio
  type    = each.value

  alias {
    name                   = aws_cloudfront_distribution.site.domain_name
    zone_id                = aws_cloudfront_distribution.site.hosted_zone_id
    evaluate_target_health = false
  }
}

resource "aws_route53_record" "www" {
  for_each = toset(["A", "AAAA"])

  zone_id = data.aws_route53_zone.raiz.zone_id
  name    = "www.${var.dominio}"
  type    = each.value

  alias {
    name                   = aws_cloudfront_distribution.site.domain_name
    zone_id                = aws_cloudfront_distribution.site.hosted_zone_id
    evaluate_target_health = false
  }
}

output "dominio_publico" {
  value = "https://${var.dominio}"
}

output "distribuicao_id" {
  value = aws_cloudfront_distribution.site.id
}

output "bucket_estatico" {
  value = aws_s3_bucket.estatico.id
}

output "regiao" {
  value = var.regiao
}

# origem-fechada.tf — a origem so aceita quem veio da borda

# O segredo do cabecalho vem do Secrets Manager, nunca do codigo nem de
# `variable` com default. Sinceridade necessaria: o valor lido aqui FICA no
# estado do Terraform. Estado em S3 com criptografia e acesso restrito nao e
# opcional a partir do momento em que voce le segredo em `data`.
data "aws_secretsmanager_secret" "origem" {
  name = "${var.projeto}/borda/cabecalho-de-origem"
}

data "aws_secretsmanager_secret_version" "origem" {
  secret_id = data.aws_secretsmanager_secret.origem.id
}

# A lista de prefixo gerenciada do CloudFront contem os enderecos dos
# servidores da borda que falam com origem. Ela e mantida pela AWS: nao ha
# lista de IP para atualizar a mao.
data "aws_ec2_managed_prefix_list" "cloudfront" {
  name = "com.amazonaws.global.cloudfront.origin-facing"
}

data "aws_ec2_managed_prefix_list" "cloudfront_ipv6" {
  name = "com.amazonaws.global.ipv6.cloudfront.origin-facing"
}

resource "aws_security_group" "alb" {
  name        = "${var.projeto}-alb"
  description = "Entrada apenas da borda do CloudFront"
  vpc_id      = aws_vpc.principal.id
  tags        = local.tags
}

resource "aws_vpc_security_group_ingress_rule" "https_da_borda" {
  security_group_id = aws_security_group.alb.id
  from_port         = 443
  to_port           = 443
  ip_protocol       = "tcp"
  prefix_list_id    = data.aws_ec2_managed_prefix_list.cloudfront.id
  description       = "HTTPS somente dos servidores de origem do CloudFront (IPv4)"
}

resource "aws_vpc_security_group_ingress_rule" "https_da_borda_v6" {
  security_group_id = aws_security_group.alb.id
  from_port         = 443
  to_port           = 443
  ip_protocol       = "tcp"
  prefix_list_id    = data.aws_ec2_managed_prefix_list.cloudfront_ipv6.id
  description       = "HTTPS somente dos servidores de origem do CloudFront (IPv6)"
}

# Nao ha regra para a porta 80: o redirecionamento acontece na borda, e o ALB
# nao precisa ouvir HTTP. Uma porta que ninguem escuta e uma porta que ninguem
# testa por engano.

// Program.cs — o que muda na aplicacao quando o estatico sai dela

using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddHealthChecks();

// Dois saltos de proxy na frente: o CloudFront acrescenta o endereco do
// visitante em X-Forwarded-For, e o ALB acrescenta o do proprio ponto de
// presenca. Sem ForwardLimit = 2, o ASP.NET Core para no primeiro salto e
// registra a borda como se fosse o cliente.
//
// Este numero e derivado da topologia, nao lido em documentacao: confira uma
// vez, registrando o valor bruto do cabecalho, antes de confiar nele.
builder.Services.Configure<ForwardedHeadersOptions>(o =>
{
    o.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
    o.ForwardLimit = 2;
    // A rede da VPC e o ALB nao tem endereco fixo conhecido; limpar as listas e
    // aceitar o cabecalho e seguro AQUI porque o grupo de seguranca so aceita
    // trafego da borda. Numa origem exposta a internet, isto seria falsificavel.
    o.KnownNetworks.Clear();
    o.KnownProxies.Clear();
});

var app = builder.Build();

app.UseForwardedHeaders();

// ATENCAO ao que NAO esta aqui: nao ha `app.UseStaticFiles()` e nao existe
// mais pasta wwwroot na imagem. O estatico e publicado no S3 por copia de
// arquivo, sem construir imagem e sem rollout. Foi este apagamento que
// separou o ciclo de vida do front do ciclo de vida da API.

// O cabecalho secreto e conferido antes de qualquer rota de negocio. Ele nao
// substitui o grupo de seguranca: a lista de prefixo prova que a requisicao
// veio do CloudFront, e este cabecalho prova que veio da NOSSA distribuicao.
var segredoEsperado = builder.Configuration["Borda:CabecalhoDeOrigem"]
    ?? throw new InvalidOperationException(
        "Borda:CabecalhoDeOrigem ausente. Ele vem do Secrets Manager pela chave "
        + "`secrets` da definicao de container, nunca por `environment`.");

app.Use(async (ctx, next) =>
{
    // A verificacao de saude vem do ALB, nao da borda — e o ALB nao manda o
    // cabecalho. Exigi-lo aqui derrubaria todas as tasks saudaveis, que e o
    // jeito mais rapido de transformar um controle de seguranca num incidente.
    var caminho = ctx.Request.Path.Value ?? string.Empty;
    if (caminho.StartsWith("/health", StringComparison.Ordinal))
    {
        await next();
        return;
    }

    var recebido = ctx.Request.Headers["X-Origem-Autorizada"].ToString();
    // Comparacao em tempo fixo: comparar segredo com == vaza o tamanho do
    // prefixo correto pelo tempo de resposta.
    var iguais = CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(recebido),
        Encoding.UTF8.GetBytes(segredoEsperado));

    if (!iguais)
    {
        ctx.Response.StatusCode = StatusCodes.Status403Forbidden;
        return; // sem corpo: nao ha o que informar a quem nao deveria estar aqui
    }

    await next();
});

// Toda resposta de /api sai marcada como nao armazenavel. Isto e cinto duplo:
// o comportamento de /api/* ja usa a politica Managed-CachingDisabled. O
// cabecalho protege o dia em que alguem trocar a politica sem ler este arquivo
// — e protege tambem o cache do NAVEGADOR e o de qualquer proxy no caminho,
// que a politica do CloudFront nao alcanca.
app.Use(async (ctx, next) =>
{
    if (ctx.Request.Path.StartsWithSegments("/api"))
    {
        ctx.Response.OnStarting(() =>
        {
            ctx.Response.Headers.CacheControl = "no-store, private";
            return Task.CompletedTask;
        });
    }
    await next();
});

// Vivacidade sem dependencia; prontidao com dependencia. Vem do L03 e continua
// valendo: sao perguntas diferentes.
app.MapHealthChecks("/health/live");
app.MapHealthChecks("/health/ready");

app.MapControllers();
app.Run();

// PedidosController.cs — a resposta que a borda pode reutilizar, e a que nao pode

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public sealed class PedidosController : ControllerBase
{
    private readonly IPedidoRepositorio _repo;

    public PedidosController(IPedidoRepositorio repo) => _repo = repo;

    // Resposta por usuario: NUNCA armazenavel em cache compartilhado. O
    // middleware ja marca no-store; a anotacao deixa a intencao visivel a quem
    // le so o controlador.
    [HttpGet("{id:guid}")]
    [ResponseCache(NoStore = true, Location = ResponseCacheLocation.None)]
    public async Task<IActionResult> Obter(Guid id, CancellationToken ct)
    {
        var pedido = await _repo.ObterAsync(id, ct);
        return pedido is null ? NotFound() : Ok(pedido);
    }

    // Contraexemplo deliberado: catalogo publico e igual para todo mundo. Esta
    // e a unica rota de API deste laboratorio que MERECERIA um comportamento
    // com cache — e ela mostra que "API nao se cacheia" e regra preguicosa.
    //
    // Para aproveitar de fato, seria preciso um terceiro comportamento em
    // /api/catalogo* com politica propria. Nao foi criado aqui porque o
    // requisito declarado nao pede: acrescentar seria adorno, e a secao de
    // evolucao registra isso como o passo do nivel 4.
    [HttpGet("/api/catalogo")]
    public async Task<IActionResult> Catalogo(CancellationToken ct)
    {
        var itens = await _repo.CatalogoAsync(ct);

        // s-maxage fala com o cache COMPARTILHADO (a borda); max-age fala com o
        // navegador. Poder dar tempos diferentes aos dois e o motivo de a
        // diretiva existir. stale-while-revalidate deixa a borda servir o valor
        // vencido enquanto busca o novo, o que remove o pico de latencia da
        // expiracao.
        Response.Headers.CacheControl = "public, max-age=60, s-maxage=300, stale-while-revalidate=60";
        return Ok(itens);
    }
}

#!/usr/bin/env bash
# publicar-front.sh — a publicacao que dispensa invalidacao
set -euo pipefail

PROJETO="${PROJETO:-ffv-lab}"
BUCKET=$(terraform output -raw bucket_estatico)
DIST=$(terraform output -raw distribuicao_id)

# 1. O build grava o hash do conteudo no nome de cada arquivo:
#      dist/assets/app.4f2a91c8.js
#      dist/assets/estilo.9b17ee02.css
#    Vite, webpack e esbuild fazem isso por padrao. Se o seu build nao faz,
#    ligar essa opcao e o pre-requisito de todo o resto deste roteiro.
npm run build

# 2. Primeiro os ARQUIVOS COM HASH, com um ano de validade e `immutable`.
#    A ordem importa: se o index.html subisse primeiro, ele apontaria por
#    alguns segundos para arquivos que ainda nao existem — e quem visitasse
#    nesse intervalo veria a pagina quebrada.
aws s3 sync dist/assets/ "s3://${BUCKET}/assets/" \
  --cache-control "public, max-age=31536000, immutable" \
  --delete=false

# 3. Depois o index.html, com validade curta. Ele e o unico arquivo cujo NOME
#    nao muda, entao e o unico que precisa expirar rapido.
aws s3 cp dist/index.html "s3://${BUCKET}/index.html" \
  --cache-control "public, max-age=60, s-maxage=60" \
  --content-type "text/html; charset=utf-8"

# 4. Invalidacao de UM caminho, nao de `/*`. O `/*` apaga tudo, inclusive os
#    arquivos com hash que jamais mudarao, e obriga a borda a rebuscar o build
#    inteiro em todos os pontos de presenca. Ha franquia mensal de caminhos e
#    cobranca acima dela; e o desperdicio maior nao esta na fatura, esta no
#    pico de latencia que todo visitante paga depois.
aws cloudfront create-invalidation \
  --distribution-id "$DIST" \
  --paths "/index.html" "/" \
  --query "Invalidation.{Id:Id,Status:Status}" --output table

# 5. Nao remova o build anterior no mesmo instante: quem carregou o index.html
#    antigo nos ultimos 60 s ainda vai pedir os arquivos antigos. Expire por
#    ciclo de vida, com folga, em vez de apagar na publicacao.
echo "Publicado. Os arquivos da versao anterior expiram pela regra de 30 dias."

# provas.sh — cinco medicoes. Nenhuma conclusao vem de "abriu no navegador"
set -euo pipefail
DOMINIO="cadencia.com.br"
DIST=$(terraform output -raw distribuicao_id)

echo "== Prova 1 — o certificado da borda esta em us-east-1 e foi emitido =="
# A distribuicao recusa ARN de certificado de outra regiao no proprio apply.
# Se este comando nao encontra nada, o certificado foi pedido na regiao errada.
aws acm list-certificates --region us-east-1 \
  --query "CertificateSummaryList[?DomainName=='${DOMINIO}'].[DomainName,Status]" \
  --output table
# APROVA: uma linha com ISSUED.
# REPROVA com PENDING_VALIDATION: o CNAME de validacao nao esta na zona. O ACM
# desiste em 72 h e o certificado vira VALIDATION_TIMED_OUT — a partir dai nao
# ha o que consertar, e sim um certificado novo a pedir.

echo "== Prova 2 — o apice resolve para a borda, e o registro e ALIAS =="
dig +short "${DOMINIO}" A | head -3
# APROVA: enderecos IP. Se aparecesse um nome, seria CNAME — e CNAME no apice
# nao existe.
ZONA=$(aws route53 list-hosted-zones-by-name --dns-name "${DOMINIO}" \
  --query "HostedZones[0].Id" --output text)
aws route53 list-resource-record-sets --hosted-zone-id "$ZONA" \
  --query "ResourceRecordSets[?Name=='${DOMINIO}.'].[Type,AliasTarget.DNSName]" \
  --output table
# APROVA: A e AAAA com AliasTarget apontando para *.cloudfront.net.
# REPROVA com AliasTarget nulo: e registro comum, e voce esta pagando consulta
# que o ALIAS nao cobraria.

echo "== Prova 3 — o mesmo arquivo, duas vezes: miss e depois hit =="
ARQ=$(curl -s "https://${DOMINIO}/" | grep -o '/assets/[a-z]*\.[a-z0-9]*\.js' | head -1)
for i in 1 2; do
  curl -s -o /dev/null -D - -H "Pragma: server-timing" "https://${DOMINIO}${ARQ}" \
    | grep -i -E "^(server-timing|x-cache|age):"
done
# APROVA: a primeira execucao traz `cdn-cache-miss`; a segunda, `cdn-cache-hit`
# com `cdn-hit-layer;desc="EDGE"` e um cabecalho Age crescente.
# O `Pragma: server-timing` forca o cabecalho mesmo com amostragem em 1%.
# REPROVA se as duas derem miss: ou a origem esta mandando no-store no
# estatico, ou a chave de cache inclui algo que muda entre as duas chamadas.

echo "== Prova 4 — a rota de API NUNCA e reutilizada entre usuarios =="
for cookie in "sessao=aaa" "sessao=bbb"; do
  curl -s -o /dev/null -D - -H "Pragma: server-timing" -H "Cookie: ${cookie}" \
    "https://${DOMINIO}/api/pedidos/00000000-0000-0000-0000-000000000000" \
    | grep -i -E "^(HTTP|server-timing|cache-control):"
done
# APROVA: as duas com `cdn-cache-miss` e `cache-control: no-store, private`.
# Dois cookies diferentes, de proposito: repetir a MESMA chamada nao provaria
# nada, porque o que se quer descartar e reuso ENTRE usuarios.
# REPROVA com um `cdn-cache-hit`: a ordem dos comportamentos esta invertida e
# resposta de um usuario pode chegar a outro. Pare tudo e corrija.
#
# Repare no que este teste NAO consegue fazer: forjar o cabecalho de origem.
# Se voce mandar `-H "X-Origem-Autorizada: qualquer-coisa"`, a distribuicao
# SOBRESCREVE o valor antes de encaminhar — a documentacao diz que, quando o
# cabecalho ja esta na requisicao do visitante, o CloudFront reescreve o valor.
# E justamente essa sobrescrita que torna o cabecalho um controle util.

echo "== Prova 5 — nem o bucket nem a origem sao alcancaveis por fora =="
BUCKET=$(terraform output -raw bucket_estatico)
REGIAO=$(terraform output -raw regiao)
curl -s -o /dev/null -w "%{http_code}\n" \
  "https://${BUCKET}.s3.${REGIAO}.amazonaws.com${ARQ}"
# APROVA: 403. O objeto existe e nao e servido — quem serve e a distribuicao.
# REPROVA com 200: bloqueio de acesso publico ou politica do bucket estao
# frouxos, e o WAF do L47 seria contornavel por quem soubesse o nome do bucket.

# A origem dinamica, pelo nome dela, direto — sem passar pela borda:
curl -s -o /dev/null -w "%{http_code}\n" --max-time 8 \
  "https://origem.${DOMINIO}/api/catalogo" || echo "tempo esgotado (esperado)"
# APROVA: tempo esgotado, porque o grupo de seguranca so aceita as faixas de
# origem do CloudFront — a conexao nem chega a ser aceita.
# REPROVA com 200 ou 403: 200 significa que a regra de entrada esta aberta e
# qualquer pessoa fala com o ALB; 403 significa que a conexao FOI aceita e a
# aplicacao recusou — o cabecalho salvou voce, e o grupo de seguranca esta
# frouxo. As duas leituras sao diferentes, e so a primeira e catastrofe.

echo "== Medicao de fechamento — taxa de acerto POR CAMINHO =="
# A metrica CacheHitRate da um numero unico para a distribuicao inteira, e ele
# mente por construcao: /api/* com 0% de acerto derruba a media do estatico.
# O registro de acesso e o unico lugar onde a pergunta certa cabe.
aws cloudwatch get-metric-statistics \
  --namespace AWS/CloudFront --metric-name CacheHitRate \
  --dimensions Name=DistributionId,Value="$DIST" Name=Region,Value=Global \
  --start-time "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)" \
  --end-time "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  --period 300 --statistics Average --region us-east-1 \
  --query "Datapoints[].Average" --output text
# Repare no `--region us-east-1`: metrica de CloudFront publica sempre ali,
# qualquer que seja a regiao da aplicacao. Procurar em sa-east-1 devolve lista
# vazia e a conclusao errada de que a metrica nao existe.

// A politica do papel que publica o front. Ela e o novo caminho pelo qual
// codigo entra em producao, entao merece o mesmo rigor da politica de deploy.
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "EscreveSomenteNoPrefixoDoFront",
      "Effect": "Allow",
      "Action": ["s3:PutObject", "s3:DeleteObject"],
      "Resource": "arn:aws:s3:::ffv-lab-front-111122223333/*"
    },
    {
      // ListBucket opera sobre o BUCKET, nao sobre a chave: por isso o ARN
      // aqui nao tem "/*". Confundir os dois e a causa mais comum de
      // "AccessDenied" em politica que parece correta.
      "Sid": "ListaParaOSyncCompararTimestamp",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::ffv-lab-front-111122223333"
    },
    {
      // A invalidacao aceita recurso: restrinja a ESTA distribuicao.
      "Sid": "InvalidaSomenteEstaDistribuicao",
      "Effect": "Allow",
      "Action": "cloudfront:CreateInvalidation",
      "Resource": "arn:aws:cloudfront::111122223333:distribution/E1PDQ2EXAMPLE"
    },
    {
      // O unico "*" desta politica, e ele tem motivo: as acoes de LISTAGEM
      // do CloudFront nao operam sobre um recurso — voce lista para
      // descobrir quais recursos existem, entao nao ha ARN a informar. Se
      // o seu roteiro descobre o ID da distribuicao de outra forma (saida
      // do Terraform, por exemplo), APAGUE esta declaracao: ela deixa de
      // ter justificativa no momento em que deixa de ser usada.
      "Sid": "DescobreADistribuicaoQuandoOIdNaoEConhecido",
      "Effect": "Allow",
      "Action": "cloudfront:ListDistributions",
      "Resource": "*"
    }
  ]
}

-- Athena sobre o registro padrao de acesso. E a consulta que a metrica
-- unica nao substitui: ela responde "onde" o acerto acontece.
--
-- A tabela externa vem do guia do Athena para logs do CloudFront; os campos
-- estao na referencia de registro padrao.
SELECT
  CASE
    WHEN uri LIKE '/api/%'    THEN 'api'
    WHEN uri LIKE '/assets/%' THEN 'estatico'
    ELSE 'documento'
  END                                            AS grupo,
  count(*)                                       AS requisicoes,
  round(100.0 * sum(CASE WHEN status_cache IN ('Hit', 'RefreshHit')
                         THEN 1 ELSE 0 END) / count(*), 1) AS acerto_pct,
  round(avg(tempo_total) * 1000, 0)              AS media_ms
FROM logs_cloudfront
WHERE data >= current_date - INTERVAL '1' DAY
GROUP BY 1
ORDER BY requisicoes DESC;

-- Na Cadencia, um dia depois:
--   estatico    412.884 requisicoes   96,4% de acerto    28 ms
--   documento    11.207 requisicoes   88,1% de acerto    41 ms
--   api           9.113 requisicoes    0,0% de acerto   287 ms
--
-- A media ponderada disso e 93,3%, e esse numero nao descreve nenhuma das
-- tres linhas. RefreshHit conta como acerto de proposito: a origem foi
-- consultada, mas o objeto nao foi retransferido — a economia de banda
-- aconteceu, e so a de latencia nao.

# limpar.sh — a ordem importa, e tres itens continuam cobrando depois
set -euo pipefail
PROJETO="${PROJETO:-ffv-lab}"

# 1. Uma distribuicao NAO pode ser apagada enquanto esta habilitada. O
#    Terraform desabilita e espera a propagacao — que leva minutos, nao
#    segundos. Interromper aqui deixa a distribuicao de pe.
terraform destroy -auto-approve

# 2. ZONA HOSPEDADA: se voce criou a zona fora do Terraform (o caminho comum,
#    porque ela vem do registro do dominio), ela sobrevive e cobra por mes.
#    E o destroy da zona falha se restar qualquer registro que nao seja NS/SOA.
aws route53 list-hosted-zones-by-name --dns-name "cadencia.com.br" \
  --query "HostedZones[].[Name,Id,ResourceRecordSetCount]" --output table
# Apagar a zona invalida os CNAME de validacao do ACM: a renovacao automatica
# de qualquer certificado que dependa deles para de funcionar em silencio, e o
# sintoma aparece meses depois, na expiracao.

# 3. BUCKET DE LOGS: nao entra no destroy com objeto dentro, e o registro de
#    acesso continua chegando por algumas horas depois de a distribuicao sair.
#    Espere, depois limpe.
aws s3 rm "s3://${PROJETO}-logs" --recursive --quiet || true
aws s3 rb "s3://${PROJETO}-logs" || true

# 4. BUCKET DO ESTATICO COM VERSIONAMENTO: `rm --recursive` apaga a versao
#    corrente e deixa as anteriores, que continuam ocupando GB-mes. Sao duas
#    listagens diferentes.
aws s3api list-object-versions --bucket "${PROJETO}-front-$(aws sts get-caller-identity --query Account --output text)" \
  --query "{Versoes:length(Versions||`[]`),Marcadores:length(DeleteMarkers||`[]`)}"

# 5. ASSINATURA DE METRICAS ADICIONAIS: cobra por metrica-mes e nao aparece em
#    lista de recurso nenhuma. Se a distribuicao foi apagada, ela vai junto —
#    mas confirme, porque assinatura orfa e fatura sem dono.
aws cloudfront get-monitoring-subscription --id "$(terraform output -raw distribuicao_id)" 2>/dev/null || \
  echo "sem assinatura ativa (esperado depois do destroy)"

# 6. CERTIFICADOS: certificado em uso nao pode ser apagado, entao a ordem e
#    distribuicao/listener primeiro, certificado depois. Certificado nao
#    cobra parado — o que fica e um inventario que ninguem entende.
aws acm list-certificates --region us-east-1 \
  --query "CertificateSummaryList[?contains(DomainName,'cadencia')].[DomainName,CertificateArn]" \
  --output table

# 7. E o que veio do L01 e cobra por hora: ALB, RDS, NAT Gateway e o Elastic IP
#    dele. Rode a limpeza do L01 se voce nao vai seguir para o L06.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values="${PROJETO}" \
  --query "ResourceTagMappingList[].ResourceARN" --output table