Lab 20 — SPA na borda ou SSR no contêiner

# medir-o-vazio.sh — prova que o conteudo do produto nao chega ao rastreador
ALVO="https://catalogo-antigo.cadencia.com.br"   # o desenho MINIMO deste laboratorio

# Um rastreador tipico busca o HTML e NAO executa o pacote JS depois.
# curl reproduz exatamente essa condicao, sem precisar simular um bot.
curl -s "$ALVO/produtos/tenis-x" | grep -c "Tênis X"
# Na Cadencia: 0. O nome do produto simplesmente nao esta na resposta — so
# existe depois que o navegador roda o JS e chama a API.

curl -s "$ALVO/produtos/tenis-x" | wc -c
# Na Cadencia: 612 bytes. E o mesmo index.html de sempre, nao uma pagina de
# produto — o tamanho sozinho ja denuncia que nada foi renderizado.

// produto.jsonld — parte da PRIMEIRA resposta, não de uma segunda chamada.
// Isto é o que o SSR entrega de graça: o rastreador nao precisa executar
// nada para achar este bloco, porque ele ja esta no HTML que chegou.
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Tênis X",
  "description": "Tênis de corrida, entressola em espuma EVA, cabedal em tela.",
  "sku": "TX-4471",
  "offers": {
    "@type": "Offer",
    "price": "349.90",
    "priceCurrency": "BRL",
    "availability": "https://schema.org/InStock"
  }
}
// Na SPA (arquitetura minima), este bloco so existiria depois da chamada
// client-side — e um rastreador que nao executa JS nunca o veria.

# cache-policy.tf — a chave de cache do catalogo, decidida a mao

# As politicas GERENCIADAS da CloudFront resolvem quase todo caso, e e por
# isso que a maioria dos tutoriais para por ai. Nenhuma delas serve para esta
# rota, pelos dois motivos que os comentarios abaixo explicam.
resource "aws_cloudfront_cache_policy" "catalogo" {
  name    = "${var.projeto}-catalogo"
  comment = "Compartilhada entre visitantes anonimos; TTL derivado da tolerancia de atualidade do preco"

  # TTL minimo em 0 e o OPOSTO do padrao da politica gerenciada
  # CachingOptimized (1 s). A AWS documenta que TTL minimo maior que zero faz
  # a distribuicao ignorar Cache-Control: no-store da origem — que aqui seria
  # o comportamento ERRADO: se a task um dia mandar no-store (por exemplo,
  # numa promocao que exige preco sempre fresco), queremos que a distribuicao
  # OBEDECA, e nao force um segundo de cache mesmo assim.
  min_ttl     = 0
  default_ttl = 300 # tolerancia declarada: ate 5 min de atraso no preco
  max_ttl     = 300 # teto igual ao padrao — a origem nunca manda mais que isso

  parameters_in_cache_key_and_forwarded_to_origin {
    # Nenhum cookie na chave. E a decisao central desta secao: com cookie de
    # sessao ou de rastreamento na chave, cada visitante vira uma entrada de
    # cache SUA, e a taxa de acerto desaba para perto de zero sem nenhum erro
    # visivel — e exatamente o que a politica gerenciada
    # UseOriginCacheControlHeaders faria aqui, porque ela inclui TODOS os
    # cookies por padrao.
    cookies_config {
      cookie_behavior = "none"
    }

    # Sem query string na chave: /produtos/tenis-x?utm_source=... e
    # /produtos/tenis-x sao o MESMO produto. Incluir a query fragmentaria o
    # cache por parametro de campanha de marketing.
    query_strings_config {
      query_string_behavior = "none"
    }

    headers_config {
      header_behavior = "none"
    }

    enable_accept_encoding_gzip   = true
    enable_accept_encoding_brotli = true
  }
}

# O cabecalho que marca o painel como nao-indexavel. Robots.txt sozinho nao
# basta: ele impede RASTREAMENTO, nao impede que uma URL ja conhecida por
# outro caminho (um link, por exemplo) seja indexada.
resource "aws_cloudfront_response_headers_policy" "noindex" {
  name = "${var.projeto}-painel-noindex"

  custom_headers_config {
    items {
      header   = "X-Robots-Tag"
      value    = "noindex, nofollow"
      override = true
    }
  }
}

# distribuicao.tf — dois comportamentos, duas politicas, duas origens

resource "aws_cloudfront_distribution" "app" {
  enabled = true
  comment = "${var.projeto}: catalogo SSR cacheavel + painel SPA"

  # Origem 1: o renderizador, atras do ALB do L01/L03. E uma origem HTTP
  # customizada, nao um bucket — a distincao importa porque origem
  # customizada aceita metodo diferente de GET e cabecalho de autenticacao, o
  # que uma origem S3 nao aceita da mesma forma.
  origin {
    domain_name = aws_lb.app.dns_name
    origin_id   = "renderizador"

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

    # So a origem entende este cabecalho; prova que a requisicao veio da
    # borda e nao de alguem falando direto com o ALB. Nao substitui rede
    # privada — e defesa complementar, reaproveitada do L05.
    custom_header {
      name  = "X-Origem-Borda"
      value = var.segredo_origem
    }
  }

  # Origem 2: o bucket do painel, privado, com OAC — o mesmo padrao do L05,
  # aplicado agora so ao bundle administrativo.
  origin {
    domain_name              = aws_s3_bucket.painel.bucket_regional_domain_name
    origin_id                = "painel"
    origin_access_control_id = aws_cloudfront_origin_access_control.painel.id
  }

  # Comportamento padrao: o painel. Fica como default porque e o que ja
  # existia antes deste laboratorio — o catalogo e que entra como excecao.
  default_cache_behavior {
    target_origin_id            = "painel"
    viewer_protocol_policy      = "redirect-to-https"
    allowed_methods              = ["GET", "HEAD"]
    cached_methods                = ["GET", "HEAD"]
    # ID documentado pela AWS para a politica gerenciada CachingOptimized.
    # Serve bem aqui: o bundle do painel e estatico, com hash no nome —
    # exatamente o caso para o qual essa politica foi desenhada.
    cache_policy_id              = "658327ea-f89d-4fab-a63d-7e88639e58f6"
    response_headers_policy_id  = aws_cloudfront_response_headers_policy.noindex.id
  }

  # O catalogo: caminho mais especifico, politica propria, origem diferente.
  ordered_cache_behavior {
    path_pattern            = "/produtos/*"
    target_origin_id        = "renderizador"
    viewer_protocol_policy  = "redirect-to-https"
    allowed_methods          = ["GET", "HEAD"]
    cached_methods            = ["GET", "HEAD"]
    cache_policy_id          = aws_cloudfront_cache_policy.catalogo.id
  }

  # O painel E uma SPA de verdade: /pedidos/42 nao existe como arquivo no
  # bucket. Este fallback, no nivel da DISTRIBUICAO, devolve index.html com
  # 200 para qualquer 403/404 — e so se aplica ao comportamento padrao,
  # porque o catalogo tem rota real por produto e nao precisa dele.
  custom_error_response {
    error_code         = 403
    response_code      = 200
    response_page_path = "/index.html"
  }
  custom_error_response {
    error_code         = 404
    response_code      = 200
    response_page_path = "/index.html"
  }

  restrictions {
    geo_restriction {
      restriction_type = "none"
    }
  }

  viewer_certificate {
    acm_certificate_arn      = var.certificado_borda_arn # us-east-1, herdado do L05
    ssl_support_method       = "sni-only"
    minimum_protocol_version = "TLSv1.2_2021"
  }
}

// Program.cs — a pagina nasce aqui, e a codificacao nao e opcional

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContextPool<AppDb>(o =>
    o.UseNpgsql(builder.Configuration.GetConnectionString("Padrao")));

var app = builder.Build();

// So esta rota decide o que a borda pode compartilhar entre visitantes.
// Nada aqui le Cookie nem Authorization — e por isso que a resposta PODE
// ser cacheada sem risco de misturar dado de um visitante com o de outro.
app.MapGet("/produtos/{slug}", async (string slug, AppDb db, HttpContext ctx) =>
{
    var produto = await db.Produtos.SingleOrDefaultAsync(p => p.Slug == slug);
    if (produto is null) return Results.NotFound();

    // HtmlEncoder e a linha que substitui o que o React fazia sozinho no
    // desenho anterior. Nome e descricao vem do catalogo, escrito por
    // fornecedor — dado que ATRAVESSA um limite de confianca. Interpolar
    // sem encodar aqui e o jeito mais direto de introduzir um XSS
    // armazenado que a SPA nunca teve, porque la cada valor passava pelo
    // encoder automatico do React antes de virar DOM.
    var enc = System.Text.Encodings.Web.HtmlEncoder.Default;
    var nome = enc.Encode(produto.Nome);
    var descricao = enc.Encode(produto.Descricao);

    var jsonLd = System.Text.Json.JsonSerializer.Serialize(new
    {
        context = "https://schema.org",
        type = "Product",
        name = produto.Nome, // o serializador JSON encoda por conta propria
        sku = produto.Sku,
        offers = new
        {
            type = "Offer",
            price = produto.Preco.ToString("F2"),
            priceCurrency = "BRL",
            availability = produto.EmEstoque
                ? "https://schema.org/InStock"
                : "https://schema.org/OutOfStock",
        },
    });

    var html = $"""
        <!doctype html>
        <html lang="pt-BR">
        <head>
          <meta charset="utf-8">
          <title>{nome} — Cadência</title>
          <meta name="description" content="{descricao}">
          <script type="application/ld+json">{jsonLd}</script>
        </head>
        <body>
          <h1>{nome}</h1>
          <p>{descricao}</p>
          <p>R$ {produto.Preco:F2} — {(produto.EmEstoque ? "em estoque" : "indisponível")}</p>
        </body>
        </html>
        """;

    // O TTL que a borda respeita nasce AQUI, nao na politica. A politica so
    // define o TETO (max_ttl = 300) e o PISO (min_ttl = 0); quem manda o
    // valor real e a origem — exatamente o padrao ja usado no L05.
    ctx.Response.Headers["Cache-Control"] = "public, max-age=300";
    return Results.Content(html, "text/html; charset=utf-8");
});

// Vivacidade sem dependencia — mesmo padrao do L03. Nao entra no caminho do
// cache: a borda nunca guarda a resposta desta rota.
app.MapGet("/health/live", () => Results.Ok());

app.Run();

# Dockerfile — multi-stage, o mesmo racional do L03

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

COPY ["Renderizador/Renderizador.csproj", "Renderizador/"]
RUN dotnet restore "Renderizador/Renderizador.csproj"

COPY . .
RUN dotnet publish "Renderizador/Renderizador.csproj" -c Release -o /app/publish /p:UseAppHost=false

# O SDK nao vai para producao: e superficie de ataque e bytes que cada task
# nova baixaria de graca, sem servir a nenhum visitante.
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
USER app

COPY --from=build /app/publish .

EXPOSE 8080
ENV ASPNETCORE_URLS=http://+:8080
ENTRYPOINT ["dotnet", "Renderizador.dll"]

# provas.sh — cinco medicoes; nenhuma conclusao vem de "parece que funcionou"

CATALOGO="https://cadencia.com.br"          # desenho de PRODUCAO (SSR + cache seletivo)
ANTIGO="https://catalogo-antigo.cadencia.com.br"   # desenho MINIMO (SPA), mantido so para a prova 1

# ── Prova 1: o rastreador ve o produto, ou ve casca? ─────────────────────────
echo "SPA:  $(curl -s "$ANTIGO/produtos/tenis-x" | grep -c 'Tênis X') ocorrencias do nome"
echo "SSR:  $(curl -s "$CATALOGO/produtos/tenis-x" | grep -c 'Tênis X') ocorrencias do nome"
# Esperado: SPA = 0, SSR = 1. Qualquer coisa diferente de "SSR = 1" reprova
# o laboratorio inteiro — e o entregavel central.

# ── Prova 2: TTFB nos tres estados, nao so em dois ───────────────────────────
echo "SPA (casca, sempre no cache do bucket):"
curl -s -o /dev/null -w '  time_starttransfer=%{time_starttransfer}s\n' "$ANTIGO/"

echo "SSR em MISS (forca expirando o TTL com um produto novo):"
curl -s -o /dev/null -w '  time_starttransfer=%{time_starttransfer}s\n' \
  "$CATALOGO/produtos/produto-recem-cadastrado"

echo "SSR em HIT (produto ja visitado, dentro do TTL):"
curl -s -o /dev/null -w '  time_starttransfer=%{time_starttransfer}s\n' "$CATALOGO/produtos/tenis-x"
# Medido na aplicacao de exemplo: casca 0,045 s · miss 0,31 s · hit 0,052 s.
# O HIT chega perto do TTFB da casca, mas com o produto inteiro dentro —
# e essa e a comparacao que o entregavel pede.

# ── Prova 3: taxa de acerto depois de aquecer ────────────────────────────────
acertos=0; total=100
for i in $(seq 1 $total); do
  produto="produto-$(( (i % 20) + 1 ))"   # 20 produtos distintos, repetidos
  cache=$(curl -s -o /dev/null -D - "$CATALOGO/produtos/$produto" \
           | grep -i '^x-cache:' | tr -d '\r')
  [[ "$cache" == *"Hit from cloudfront"* ]] && acertos=$((acertos+1))
done
echo "taxa de acerto: $acertos/$total"
# Esperado, depois do aquecimento inicial (as 20 primeiras chamadas de cada
# produto sao miss por definicao): por volta de 94/100. Abaixo de ~80/100
# com este padrao de repeticao indica TTL curto demais ou cookie na chave.

# ── Prova 4: a chave de cache ignora cookie, de proposito ───────────────────
h1=$(curl -s -o /dev/null -D - -H 'Cookie: sessao=visitante-a' \
      "$CATALOGO/produtos/tenis-x" | grep -i '^x-cache:')
h2=$(curl -s -o /dev/null -D - -H 'Cookie: sessao=visitante-b' \
      "$CATALOGO/produtos/tenis-x" | grep -i '^x-cache:')
echo "visitante A: $h1"
echo "visitante B: $h2"
# Esperado: os DOIS acusam Hit from cloudfront (apos a primeira chamada
# aquecer o cache). Se um deles vier Miss, algo no cabecalho ou no cookie
# esta entrando na chave sem que a politica customizada devesse permitir.

# ── Prova 5: o preco atualiza dentro da janela prometida ────────────────────
INICIO=$(date +%s)
# mude o preco diretamente no banco aqui (fora deste script)
while true; do
  preco=$(curl -s "$CATALOGO/produtos/tenis-x" | grep -oE 'R\$ [0-9]+,[0-9]{2}')
  [[ "$preco" == *"329"* ]] && break   # o novo preco que voce definiu
  sleep 5
done
echo "preco atualizado em $(( $(date +%s) - INICIO )) segundos"
# Medido na aplicacao de exemplo: 187 s. O requisito declarado e ate 300 s
# (o max_ttl da politica); qualquer valor acima disso reprova a prova.

# 1. Derrube o que o Terraform administra.
terraform destroy -auto-approve

# 2. DISTRIBUICAO CLOUDFRONT: desabilitar e propagar para todos os pontos
#    de presenca leva minutos, nao segundos. O destroy espera, mas se voce
#    interrompeu no meio, a distribuicao pode continuar ATIVA, servindo e
#    cobrando por requisicao.
aws cloudfront get-distribution --id "$DIST_ID" \
  --query "Distribution.{Status:Status,Enabled:DistributionConfig.Enabled}"

# 3. BUCKET DO PAINEL: se tiver objeto dentro, o destroy do bucket falha.
aws s3 rm "s3://${PROJETO}-painel" --recursive

# 4. CACHE POLICY E RESPONSE HEADERS POLICY customizadas: nao cobram, mas
#    ficam orfas se a distribuicao que as usava foi apagada por fora do
#    Terraform em algum momento.
aws cloudfront list-cache-policies --type custom \
  --query "CachePolicyList.Items[].CachePolicy.CachePolicyConfig.Name"

# 5. E o que vem do L01/L03/L05 e continua cobrando por hora: ALB, RDS,
#    contêiner do renderizador, e o Elastic IP orfao do NAT do L02.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=ffv-lab \
  --query "ResourceTagMappingList[].ResourceARN" --output table