Lab 11 — API Gateway na frente, ou ALB direto?

{
  "message": "Limit Exceeded"
}

// v1 (Repique Calcados) — formato antigo, que o parceiro ainda consome
{
  "pedidoId": "b3f1...",
  "cliente": "Loja Centro",
  "valor": 189.90,
  "status": "confirmado"
}

// v2 (Estacao Fashion) — mesmo pedido, campo renomeado. O Gateway roteou
// para uma integracao DIFERENTE; o backend, nao o Gateway, devolveu o campo
// certo.
{
  "id": "b3f1...",
  "cliente": "Loja Centro",
  "valor": 189.90,
  "status": "confirmado"
}

# nlb.tf — o destino obrigatorio do VPC Link para REST API

# REST API nao fala diretamente com um Application Load Balancer numa
# integracao privada: o VPC Link classico (usado por REST e WebSocket APIs) se
# apoia num Network Load Balancer. O ALB continua existindo — ele so deixa de
# ser o destino DESTE caminho.
resource "aws_lb" "parceiros" {
  name               = "${var.projeto}-parceiros-nlb"
  internal           = true # sem IP publico: so o Gateway alcanca, via VPC Link
  load_balancer_type = "network"
  subnets            = aws_subnet.privada[*].id
}

resource "aws_lb_target_group" "parceiros" {
  name        = "${var.projeto}-parceiros"
  port        = 8080
  protocol    = "TCP" # NLB opera na camada de transporte; o health check e HTTP
  vpc_id      = aws_vpc.principal.id
  target_type = "ip" # awsvpc: o alvo e o IP da task, igual ao grupo do L01

  health_check {
    protocol = "HTTP"
    path     = "/health/ready"
    port     = "traffic-port"
  }
}

resource "aws_lb_listener" "parceiros" {
  load_balancer_arn = aws_lb.parceiros.arn
  port              = 80
  protocol          = "TCP"

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

# O VPC Link e o objeto do API Gateway que aponta para o NLB acima. Uma vez
# criado, qualquer integracao privada do REST API pode referenciá-lo.
resource "aws_api_gateway_vpc_link" "parceiros" {
  name        = "${var.projeto}-vpc-link"
  target_arns = [aws_lb.parceiros.arn]
}

# O SERVICO ECS (definido no L01) ganha um segundo bloco `load_balancer`. Nao
# duplica a task: registra a MESMA implantacao num segundo grupo de destino.
# ECS aceita ate 5 grupos por servico, e exige a role vinculada ao servico
# (AWSServiceRoleForECS) para gerenciar mais de um.
resource "aws_ecs_service" "api" {
  # ... os demais argumentos sao os do L01/L03, inalterados ...

  load_balancer {
    target_group_arn = aws_lb_target_group.api.arn # o grupo original, atras do ALB
    container_name    = "api"
    container_port    = 8080
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.parceiros.arn # o grupo novo, atras do NLB
    container_name    = "api"
    container_port    = 8080
  }
}

# apigateway.tf — o contrato: identidade, cota, taxa e versao

resource "aws_api_gateway_rest_api" "parceiros" {
  name = "${var.projeto}-parceiros"

  endpoint_configuration {
    types = ["REGIONAL"] # sem CloudFront na frente; o publico e um numero pequeno de parceiros B2B
  }
}

resource "aws_api_gateway_resource" "pedido" {
  rest_api_id = aws_api_gateway_rest_api.parceiros.id
  parent_id   = aws_api_gateway_rest_api.parceiros.root_resource_id
  path_part   = "pedidos"
}

resource "aws_api_gateway_resource" "pedido_id" {
  rest_api_id = aws_api_gateway_rest_api.parceiros.id
  parent_id   = aws_api_gateway_resource.pedido.id
  path_part   = "{id}"
}

resource "aws_api_gateway_method" "get_pedido" {
  rest_api_id      = aws_api_gateway_rest_api.parceiros.id
  resource_id      = aws_api_gateway_resource.pedido_id.id
  http_method      = "GET"
  authorization    = "NONE" # a chave de API IDENTIFICA; autorizacao fina fica fora de escopo aqui
  api_key_required = true    # sem chave valida, a requisicao nem chega ao passo de integracao
}

resource "aws_api_gateway_integration" "get_pedido" {
  rest_api_id             = aws_api_gateway_rest_api.parceiros.id
  resource_id             = aws_api_gateway_resource.pedido_id.id
  http_method             = aws_api_gateway_method.get_pedido.http_method
  type                    = "HTTP_PROXY"
  integration_http_method = "GET"
  connection_type         = "VPC_LINK"
  connection_id           = aws_api_gateway_vpc_link.parceiros.id
  # aponta para o NLB interno; a porta e a do listener criado em nlb.tf
  uri = "http://${aws_lb.parceiros.dns_name}/api/pedidos/{id}"

  request_parameters = {
    "integration.request.path.id" = "method.request.path.id"
  }
}

resource "aws_api_gateway_method_settings" "throttle_padrao" {
  rest_api_id = aws_api_gateway_rest_api.parceiros.id
  stage_name  = aws_api_gateway_stage.v1.stage_name
  method_path = "*/*"

  settings {
    # limite de taxa e rajada QUANDO nao ha usage plan cobrindo a chamada —
    # o plano de uso, abaixo, e o que vale para chamadas com chave valida.
    throttling_rate_limit  = 20
    throttling_burst_limit = 10
  }
}

resource "aws_api_gateway_deployment" "parceiros" {
  rest_api_id = aws_api_gateway_rest_api.parceiros.id
  triggers = {
    redeploy = sha1(jsonencode([
      aws_api_gateway_resource.pedido_id.id,
      aws_api_gateway_integration.get_pedido.id,
    ]))
  }
  lifecycle { create_before_destroy = true }
}

# Estagios sao a unidade de versao deste desenho. v1 e v2 sao DUAS integracoes
# distintas — o Gateway roteia; quem devolve o payload no formato certo e o
# backend atras de cada uma.
resource "aws_api_gateway_stage" "v1" {
  deployment_id = aws_api_gateway_deployment.parceiros.id
  rest_api_id   = aws_api_gateway_rest_api.parceiros.id
  stage_name    = "v1"
}

resource "aws_api_gateway_stage" "v2" {
  deployment_id = aws_api_gateway_deployment.parceiros.id
  rest_api_id   = aws_api_gateway_rest_api.parceiros.id
  stage_name    = "v2"
}

# ── Identidade e cota: uma chave e um plano por parceiro ─────────────────────
resource "aws_api_gateway_api_key" "repique" {
  name = "repique-calcados"
}

resource "aws_api_gateway_usage_plan" "repique" {
  name = "plano-repique-calcados"

  api_stages {
    api_id = aws_api_gateway_rest_api.parceiros.id
    stage  = aws_api_gateway_stage.v1.stage_name # so v1: este parceiro ainda nao migrou
  }

  # Cota: teto por PERIODO (dia, semana ou mes). E o numero do contrato.
  quota_settings {
    limit  = 500
    period = "DAY"
  }

  # Throttle: taxa de reposicao do balde de tokens e o tamanho do balde. Protege
  # contra RAJADA — e um mecanismo diferente da cota, com 429 de motivo diferente.
  throttle_settings {
    rate_limit  = 3  # tokens repostos por segundo
    burst_limit = 5  # tamanho do balde
  }
}

resource "aws_api_gateway_usage_plan_key" "repique" {
  key_id        = aws_api_gateway_api_key.repique.id
  key_type      = "API_KEY"
  usage_plan_id = aws_api_gateway_usage_plan.repique.id
}

resource "aws_api_gateway_api_key" "estacao" {
  name = "estacao-fashion"
}

resource "aws_api_gateway_usage_plan" "estacao" {
  name = "plano-estacao-fashion"

  # Duas entradas: este parceiro tem acesso a v1 E v2 durante a janela de
  # migracao. A revogacao de v1, quando chegar, e so remover este bloco.
  api_stages {
    api_id = aws_api_gateway_rest_api.parceiros.id
    stage  = aws_api_gateway_stage.v1.stage_name
  }
  api_stages {
    api_id = aws_api_gateway_rest_api.parceiros.id
    stage  = aws_api_gateway_stage.v2.stage_name
  }

  quota_settings {
    limit  = 2000
    period = "DAY"
  }

  throttle_settings {
    rate_limit  = 10
    burst_limit = 20
  }
}

resource "aws_api_gateway_usage_plan_key" "estacao" {
  key_id        = aws_api_gateway_api_key.estacao.id
  key_type      = "API_KEY"
  usage_plan_id = aws_api_gateway_usage_plan.estacao.id
}

# O API Gateway precisa de uma role de CloudWatch configurada UMA VEZ por
# conta/regiao para logar. E uma policy gerenciada pela AWS: nao ha "*" para
# justificar aqui, so a permissao de escrever no CloudWatch Logs.
resource "aws_iam_role" "apigw_cloudwatch" {
  name = "${var.projeto}-apigw-cloudwatch"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect    = "Allow"
      Principal = { Service = "apigateway.amazonaws.com" }
      Action    = "sts:AssumeRole"
    }]
  })
}

resource "aws_iam_role_policy_attachment" "apigw_cloudwatch" {
  role       = aws_iam_role.apigw_cloudwatch.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonAPIGatewayPushToCloudWatchLogs"
}

output "url_v1" {
  value       = "${aws_api_gateway_stage.v1.invoke_url}/pedidos/{id}"
  description = "URL do estagio v1 — payload no formato antigo (pedidoId)"
}

output "url_v2" {
  value       = "${aws_api_gateway_stage.v2.invoke_url}/pedidos/{id}"
  description = "URL do estagio v2 — payload no formato novo (id)"
}

// Program.cs — o que muda no backend: NADA na decisao de cota, so correlacao

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

var app = builder.Build();

// v1: formato antigo. Existe porque a Estacao Fashion ainda consome assim, e o
// contrato com ela nao muda so porque o codigo mudou — muda quando o CLIENTE
// aponta para outra URL. E o estagio do Gateway que decide qual destas duas
// rotas responde a cada parceiro, nao um "if" de versao dentro do controller.
app.MapGet("/api/pedidos/{id:guid}", async (Guid id, AppDb db) =>
    await db.Pedidos.FindAsync(id) is { } ped
        ? Results.Ok(new { pedidoId = ped.Id, ped.Cliente, ped.Valor, ped.Status })
        : Results.NotFound());

// v2: o campo renomeado que motivou a versao existir. O Gateway roteia o
// estagio v2 para ESTA rota — a transformacao do payload e responsabilidade do
// backend, nao do Gateway, a menos que voce escreva um mapping template VTL.
app.MapGet("/api/v2/pedidos/{id:guid}", async (Guid id, AppDb db) =>
    await db.Pedidos.FindAsync(id) is { } ped
        ? Results.Ok(new { id = ped.Id, ped.Cliente, ped.Valor, ped.Status })
        : Results.NotFound());

// O unico dado do Gateway que a aplicacao usa: um cabecalho de CORRELACAO para
// log, mapeado no Terraform a partir de $context.identity.apiKeyId — nunca para
// decidir cota (isso ja foi decidido) nem para autorizar (a chave nao prova
// identidade de usuario final, so identifica o parceiro contratante).
app.Use(async (ctx, next) =>
{
    if (ctx.Request.Headers.TryGetValue("X-Partner-Correlation-Id", out var id))
        app.Logger.LogInformation("Requisicao do parceiro {ChaveId}", id.ToString());
    await next();
});

app.MapGet("/health/ready", async (AppDb db) =>
    await db.Database.CanConnectAsync() ? Results.Ok() : Results.StatusCode(503));

app.Run();

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

PROJETO=ffv-lab
V1=$(terraform output -raw url_v1)
V2=$(terraform output -raw url_v2)
CHAVE_REPIQUE=$(aws apigateway get-api-key --api-key "$(terraform output -raw chave_repique_id)" \
  --include-value --query value --output text)
CHAVE_ESTACAO=$(aws apigateway get-api-key --api-key "$(terraform output -raw chave_estacao_id)" \
  --include-value --query value --output text)

# ── Prova 1: sem chave, a requisicao nem chega a integracao ──────────────────
curl -s -o /dev/null -w '%{http_code}\n' "$V1/pedidos/11111111-1111-1111-1111-111111111111"
# Esperado: 403. E o Gateway recusando por FALTA de identificacao — a task nunca
# recebeu nada, o que se confirma vendo o log dela vazio no mesmo intervalo.

# ── Prova 2: a chave da Repique nao abre a v2 ─────────────────────────────────
curl -s -o /dev/null -w '%{http_code}\n' -H "x-api-key: $CHAVE_REPIQUE" \
  "$V2/pedidos/11111111-1111-1111-1111-111111111111"
# Esperado: 403. A chave esta associada ao par (API, estagio v1) — nao a API
# inteira. E a prova de que versao aqui e decisao de contrato, nao so de rota.

# ── Prova 3: a cota da Repique estoura em 500, nao em 1000 ───────────────────
for i in $(seq 1 505); do
  curl -s -o /dev/null -w '%{http_code} ' -H "x-api-key: $CHAVE_REPIQUE" \
    "$V1/pedidos/11111111-1111-1111-1111-111111111111"
done; echo
# Esperado: 200 ate a requisicao 500, depois 429 com mensagem de "Limit Exceeded"
# (quota). Compare com o desenho minimo: la, o mesmo teste passava de 500 antes
# de qualquer bloqueio, porque o contador nao era compartilhado entre tasks.

# ── Prova 4: throttle e cota sao mecanismos diferentes ───────────────────────
# Dispare 20 requisicoes simultaneas (nao sequenciais) com a chave da Estacao
# (rate_limit=10, burst_limit=20) e repita 1s depois.
seq 1 20 | xargs -P20 -I{} curl -s -o /dev/null -w '%{http_code} ' -H "x-api-key: $CHAVE_ESTACAO" "$V1/pedidos/{}" ; echo
sleep 1
curl -s -o /dev/null -w '%{http_code}\n' -H "x-api-key: $CHAVE_ESTACAO" "$V1/pedidos/11111111-1111-1111-1111-111111111111"
# Esperado: algumas 429 na rajada (estourou o balde), e a chamada 1s depois volta
# a 200 — porque o balde reencheu. Diferente da prova 3: aqui NAO e o dia que
# precisa virar para voltar a funcionar.

# ── Prova 5: o mesmo servico ECS responde nos dois caminhos ──────────────────
aws ecs describe-services --cluster "$PROJETO" --services "${PROJETO}-api" \
  --query 'services[0].loadBalancers[].targetGroupArn' --output table
# Esperado: DOIS ARNs de grupo de destino listados para o MESMO servico —
# confirma que a task nao foi duplicada, so passou a responder por dois caminhos.

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

# 2. CHAVES DE API: nao sao removidas por destroy se foram desassociadas
#    manualmente do estado em algum momento. Confirme que sumiram.
aws apigateway get-api-keys --query "items[].{nome:name,id:id}" --output table

# 3. NETWORK LOAD BALANCER: cobra por hora mesmo sem trafego. Se o destroy
#    falhar por dependencia (listener ou target group ainda associado),
#    ele fica de pe indefinidamente.
aws elbv2 describe-load-balancers \
  --query "LoadBalancers[?contains(LoadBalancerName, 'parceiros')]" --output table

# 4. VPC LINK: nao tem tarifa propria, mas so existe enquanto o NLB existir.
#    Confirme que nao ficou orfao apontando para um NLB ja apagado.
aws apigateway get-vpc-links --query "items[].{nome:name,status:status}" --output table

# 5. Prova final: nada com a tag do projeto de pe.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=ffv-lab-parceiros \
  --query "ResourceTagMappingList[].ResourceARN" --output table