Lab 01 — App .NET 8 no ECS Fargate com RDS e CloudFront

{
  "timestamp": "2026-08-06T14:22:31.784Z",
  "level": "Warning",
  "traceId": "1-68f3a2c7-4b1e9d0f5a2c8e7b6d4f1a3c",
  "spanId": "5a2c8e7b6d4f1a3c",
  "requestId": "req-9f2c",
  "route": "GET /api/itens",
  "statusCode": 500,
  "durationMs": 4187,
  "dbPoolWaitMs": 4102,
  "dbPoolSize": 20,
  "taskArn": "arn:aws:ecs:us-east-1:111122223333:task/app/9c1f",
  "availabilityZone": "us-east-1b",
  "imageDigest": "sha256:3f7a",
  "message": "timeout aguardando conexao do pool"
}

# Duas AZs porque o requisito é sobreviver à perda de uma. Duas sub-redes
# públicas (só o ALB mora nelas) e duas privadas (aplicação e banco).
data "aws_availability_zones" "disponiveis" {
  state = "available"
}

resource "aws_vpc" "principal" {
  cidr_block           = "10.20.0.0/16"
  enable_dns_hostnames = true          # o endpoint do RDS é um nome, não um IP
  enable_dns_support   = true
  tags                 = local.tags
}

resource "aws_subnet" "publica" {
  count                   = 2
  vpc_id                  = aws_vpc.principal.id
  cidr_block              = cidrsubnet(aws_vpc.principal.cidr_block, 8, count.index)
  availability_zone       = data.aws_availability_zones.disponiveis.names[count.index]
  map_public_ip_on_launch = false      # nada nesta sub-rede precisa de IP automático
  tags                    = merge(local.tags, { Name = "publica-${count.index}" })
}

resource "aws_subnet" "privada" {
  count             = 2
  vpc_id            = aws_vpc.principal.id
  cidr_block        = cidrsubnet(aws_vpc.principal.cidr_block, 8, count.index + 10)
  availability_zone = data.aws_availability_zones.disponiveis.names[count.index]
  tags              = merge(local.tags, { Name = "privada-${count.index}" })
}

# ── A parte que decide a fatura deste laboratório ──────────────────────────
# A task precisa alcançar ECR, S3 (onde as camadas da imagem vivem) e
# CloudWatch Logs. Há dois caminhos:
#
#   NAT Gateway  → simples, e cobra por hora ligada MAIS por GB processado.
#   VPC endpoint → o trafego nao sai da rede da AWS; o gateway do S3 e gratuito.
#
# Aqui vão os endpoints, porque o laboratório não precisa de saída para a
# internet em nenhum outro caminho. Se a sua aplicação chamar uma API externa,
# aí o NAT volta a ser necessário — e a decisão passa a ser consciente.
resource "aws_vpc_endpoint" "s3" {
  vpc_id            = aws_vpc.principal.id
  service_name      = "com.amazonaws.${var.regiao}.s3"
  vpc_endpoint_type = "Gateway"
  route_table_ids   = [aws_route_table.privada.id]
  tags              = local.tags
}

resource "aws_vpc_endpoint" "interface" {
  for_each            = toset(["ecr.api", "ecr.dkr", "logs", "secretsmanager"])
  vpc_id              = aws_vpc.principal.id
  service_name        = "com.amazonaws.${var.regiao}.${each.key}"
  vpc_endpoint_type   = "Interface"
  subnet_ids          = aws_subnet.privada[*].id
  security_group_ids  = [aws_security_group.endpoints.id]
  private_dns_enabled = true           # sem isto o SDK continua tentando o nome público
  tags                = local.tags
}

# Três security groups em cadeia. Nenhum deles cita faixa de IP da VPC: a
# referência é ao GRUPO de origem, e é isso que faz a regra continuar correta
# quando as sub-redes mudarem.
resource "aws_security_group" "alb" {
  name   = "alb"
  vpc_id = aws_vpc.principal.id

  ingress {
    description     = "HTTPS vindo apenas do CloudFront"
    from_port       = 443
    to_port         = 443
    protocol        = "tcp"
    prefix_list_ids = [data.aws_ec2_managed_prefix_list.cloudfront.id]
  }

  egress {
    from_port       = 8080
    to_port         = 8080
    protocol        = "tcp"
    security_groups = [aws_security_group.task.id]
  }

  tags = local.tags
}

resource "aws_security_group" "task" {
  name   = "task"
  vpc_id = aws_vpc.principal.id

  ingress {
    description     = "so o ALB alcanca a aplicacao"
    from_port       = 8080
    to_port         = 8080
    protocol        = "tcp"
    security_groups = [aws_security_group.alb.id]
  }

  egress {
    description = "saida para os endpoints e para o banco"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = [aws_vpc.principal.cidr_block]
  }

  tags = local.tags
}

resource "aws_security_group" "banco" {
  name   = "banco"
  vpc_id = aws_vpc.principal.id

  ingress {
    description     = "5432 apenas do security group da task"
    from_port       = 5432
    to_port         = 5432
    protocol        = "tcp"
    security_groups = [aws_security_group.task.id]
  }

  tags = local.tags
}

resource "aws_db_instance" "principal" {
  identifier     = "app-postgres"
  engine         = "postgres"
  instance_class = var.classe_banco
  allocated_storage     = 20
  max_allocated_storage = 100          # crescimento automatico, com teto declarado

  db_name  = "appdb"
  username = "appadmin"

  # O RDS gera a senha, guarda no Secrets Manager e rotaciona. Sem esta linha
  # alguem escolhe a senha, e ela vaza para o histórico do Terraform.
  manage_master_user_password = true

  multi_az               = true        # requisito: falha de AZ nao para a escrita
  storage_encrypted      = true
  kms_key_id             = aws_kms_key.dados.arn
  db_subnet_group_name   = aws_db_subnet_group.privada.name
  vpc_security_group_ids = [aws_security_group.banco.id]

  backup_retention_period = 7          # habilita PITR; 0 desliga
  deletion_protection     = true
  skip_final_snapshot     = false
  final_snapshot_identifier = "app-postgres-final"

  performance_insights_enabled = true
  tags                         = local.tags
}

# Multi-stage: o SDK compila, a imagem final só roda. A diferença de tamanho
# não é vaidade — superfície menor é menos CVE para responder depois.
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["Api/Api.csproj", "Api/"]
RUN dotnet restore "Api/Api.csproj"
COPY . .
RUN dotnet publish "Api/Api.csproj" -c Release -o /app/publish     /p:UseAppHost=false /p:PublishReadyToRun=true

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
COPY --from=build /app/publish .

# As imagens .NET 8 já trazem um usuário não-root pronto. Rodar como root
# dentro do contêiner é gratuito de evitar e caro de justificar em auditoria.
USER $APP_UID

# .NET 8 trocou ASPNETCORE_URLS por ASPNETCORE_HTTP_PORTS neste cenário.
ENV ASPNETCORE_HTTP_PORTS=8080
EXPOSE 8080
ENTRYPOINT ["dotnet", "Api.dll"]

using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);

// A senha é lida em EXECUÇÃO, com a task role. Nada de credencial na imagem
// nem no repositório. O RDS rotaciona; ler aqui faz a rotação valer sem
// precisar de um novo deploy.
var segredoArn = builder.Configuration["SEGREDO_BANCO_ARN"]!;
var host = builder.Configuration["BANCO_HOST"]!;

using var sm = new AmazonSecretsManagerClient();
var segredo = await sm.GetSecretValueAsync(new GetSecretValueRequest { SecretId = segredoArn });
var credencial = JsonSerializer.Deserialize<Credencial>(segredo.SecretString)!;

var conexao = new NpgsqlConnectionStringBuilder
{
    Host = host,
    Database = "appdb",
    Username = credencial.username,
    Password = credencial.password,
    SslMode = SslMode.VerifyFull,
    RootCertificate = "/app/rds-ca.pem",

    // Pool por processo. O padrão do Npgsql é 100, e o RDS deriva
    // max_connections da memória da instância — duas tasks com pool cheio
    // podem esgotar o banco antes de a CPU dele subir.
    Pooling = true,
    MaxPoolSize = 20,
    Timeout = 5,
    CommandTimeout = 10,
}.ToString();

builder.Services.AddDbContext<AppDb>(o => o.UseNpgsql(conexao));

// Dois endpoints DIFERENTES, e é a distinção que evita apagão:
//   /health  → o processo está vivo? Não toca em dependência nenhuma.
//   /ready   → consigo atender? Toca no banco.
// O ALB usa /health. Se ele usasse /ready, uma oscilação do banco tiraria
// TODAS as tasks de rotação ao mesmo tempo, e o balanceador transformaria um
// problema do banco numa indisponibilidade total.
builder.Services.AddHealthChecks()
    .AddNpgSql(conexao, name: "banco", tags: ["ready"]);

var app = builder.Build();

app.MapGet("/health", () => Results.Ok(new { status = "ok" }));
app.MapHealthChecks("/ready", new()
{
    Predicate = c => c.Tags.Contains("ready"),
});

app.MapGet("/api/itens", async (AppDb db) => await db.Itens.AsNoTracking().Take(50).ToListAsync());

app.Run();

record Credencial(string username, string password);

# execution role: quem PUXA a imagem e escreve log. É do agente do ECS.
resource "aws_iam_role" "execucao" {
  name               = "app-execucao"
  assume_role_policy = data.aws_iam_policy_document.confia_ecs_tasks.json
}

resource "aws_iam_role_policy_attachment" "execucao_base" {
  role       = aws_iam_role.execucao.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
}

# task role: quem a SUA APLICAÇÃO é. Trocar as duas é o erro mais comum aqui.
resource "aws_iam_role" "task" {
  name               = "app-task"
  assume_role_policy = data.aws_iam_policy_document.confia_ecs_tasks.json
}

# Menor privilégio de verdade: um segredo, uma chave, duas ações.
data "aws_iam_policy_document" "task" {
  statement {
    actions   = ["secretsmanager:GetSecretValue"]
    resources = [aws_db_instance.principal.master_user_secret[0].secret_arn]
  }
  statement {
    actions   = ["kms:Decrypt"]
    resources = [aws_kms_key.dados.arn]
    condition {
      test     = "StringEquals"
      variable = "kms:ViaService"
      values   = ["secretsmanager.${var.regiao}.amazonaws.com"]
    }
  }
}

resource "aws_ecs_task_definition" "app" {
  family                   = "app"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 512       # combinações de CPU e memória são fixas no Fargate
  memory                   = 1024
  execution_role_arn       = aws_iam_role.execucao.arn
  task_role_arn            = aws_iam_role.task.arn

  container_definitions = jsonencode([{
    name      = "api"
    image     = "${aws_ecr_repository.app.repository_url}@${var.digest_imagem}"
    essential = true
    portMappings = [{ containerPort = 8080, protocol = "tcp" }]

    environment = [
      { name = "ASPNETCORE_HTTP_PORTS", value = "8080" },
      { name = "SEGREDO_BANCO_ARN", value = aws_db_instance.principal.master_user_secret[0].secret_arn },
      { name = "BANCO_HOST", value = aws_db_instance.principal.address },
    ]

    logConfiguration = {
      logDriver = "awslogs"
      options = {
        "awslogs-group"         = aws_cloudwatch_log_group.app.name
        "awslogs-region"        = var.regiao
        "awslogs-stream-prefix" = "api"
      }
    }

    # O health check do CONTÊINER pode ser mais fundo que o do balanceador.
    healthCheck = {
      command     = ["CMD-SHELL", "wget -q -O- http://localhost:8080/health || exit 1"]
      interval    = 15
      timeout     = 3
      retries     = 3
      startPeriod = 20
    }
  }])

  tags = local.tags
}

resource "aws_ecs_service" "app" {
  name            = "app"
  cluster         = aws_ecs_cluster.principal.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 2                  # uma por AZ: perder uma AZ nao zera capacidade
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = aws_subnet.privada[*].id
    security_groups  = [aws_security_group.task.id]
    assign_public_ip = false           # a task nao tem endereco publico
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "api"
    container_port   = 8080
  }

  # Deploy ruim volta sozinho em vez de esperar alguem perceber.
  deployment_circuit_breaker {
    enable   = true
    rollback = true
  }

  # Espera o novo alvo ficar sadio antes de contar como pronto.
  health_check_grace_period_seconds = 30
  enable_execute_command            = true

  depends_on = [aws_lb_listener.https]
  tags       = local.tags
}

resource "aws_lb_target_group" "app" {
  name        = "app"
  port        = 8080
  protocol    = "HTTP"
  vpc_id      = aws_vpc.principal.id
  target_type = "ip"                   # obrigatorio com awsvpc

  health_check {
    path                = "/health"    # raso de propósito: ver a seção de armadilhas
    matcher             = "200"
    interval            = 15
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 3
  }

  # Padrao e 300s. Uma API HTTP curta nao precisa de 5 minutos para drenar, e
  # esse valor faz cada deploy parecer travado.
  deregistration_delay = 20
  tags                 = local.tags
}

# 1. Construir e publicar a imagem, capturando o DIGEST (não a tag).
aws ecr get-login-password --region "$REGIAO" \
  | docker login --username AWS --password-stdin "$CONTA.dkr.ecr.$REGIAO.amazonaws.com"

docker build -t app:local .
docker tag app:local "$REPO:$(git rev-parse --short HEAD)"
docker push "$REPO:$(git rev-parse --short HEAD)"

DIGEST=$(aws ecr describe-images --repository-name app \
  --image-ids imageTag="$(git rev-parse --short HEAD)" \
  --query 'imageDetails[0].imageDigest' --output text)

# 2. Aplicar a infraestrutura amarrada àquele digest exato.
terraform apply -var="digest_imagem=$DIGEST"

# 3. Acompanhar o rollout. O circuit breaker reverte sozinho se falhar.
aws ecs wait services-stable --cluster app --services app

# 4. Provar que está no ar, e que o front e a API respondem.
curl -fsS "https://$DOMINIO/health"
curl -fsS "https://$DOMINIO/api/itens" | head -c 200

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "LerApenasOSegredoDesteBanco",
      "Effect": "Allow",
      "Action": "secretsmanager:GetSecretValue",
      "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:rds!db-9c1f-*"
    },
    {
      "Sid": "DecifrarApenasViaSecretsManager",
      "Effect": "Allow",
      "Action": "kms:Decrypt",
      "Resource": "arn:aws:kms:us-east-1:111122223333:key/8b2e",
      "Condition": {
        "StringEquals": { "kms:ViaService": "secretsmanager.us-east-1.amazonaws.com" }
      }
    }
  ]
}

# A ordem importa: o Terraform recusa remover o banco com proteção ligada, e
# recusa remover a VPC enquanto houver endpoint ou ENI de task pendurada.
terraform apply -var="digest_imagem=$DIGEST" \
  -var="protecao_delecao=false" -var="desired_count=0"

aws ecs wait services-inactive --cluster app --services app || true
terraform destroy -var="digest_imagem=$DIGEST" -var="protecao_delecao=false"

# ── O que o destroy NÃO leva, e continua cobrando ──────────────────────────
aws rds describe-db-snapshots --snapshot-type manual \
  --query 'DBSnapshots[].DBSnapshotIdentifier'      # snapshot final fica

aws logs describe-log-groups \
  --query 'logGroups[?retentionInDays==null].logGroupName'  # log sem retenção

aws ecr list-images --repository-name app --query 'imageIds[].imageDigest'
aws ec2 describe-addresses --query 'Addresses[?AssociationId==null]'  # EIP órfão
aws kms describe-key --key-id "$CHAVE" --query 'KeyMetadata.KeyState'  # em espera

# ── Endpoint de VPC — o que este laboratório cria em vez do NAT ──
#
# O de GATEWAY (S3, DynamoDB) não cobra por hora: ele é uma rota, e some com a VPC.
# O de INTERFACE (ECR, Secrets Manager, CloudWatch Logs) cobra POR HORA E POR AZ,
# e é o que precisa ser conferido. O destroy leva os declarados aqui; um criado à
# mão numa tentativa anterior continua cobrando.
aws ec2 describe-vpc-endpoints \
  --query 'VpcEndpoints[*].[VpcEndpointId,ServiceName,VpcEndpointType,State]' \
  --output table
# aws ec2 delete-vpc-endpoints --vpc-endpoint-ids <id>