Lab 04 — Segredo fora do código, com rotação que não derruba a aplicação

# Rode ANTES de mudar nada. Os dois numeros que sairem daqui sao a linha de base.

# (1) O historico do Git ainda serve a senha a quem clonar o repositorio.
git log --all -S "Password=" --oneline -- "*.json" | wc -l
# Na Cadencia: 14 commits. Trocar o arquivo no HEAD nao remove nenhum deles.

# (2) O plano de controle devolve o valor a quem tem permissao de inventario.
aws ecs describe-task-definition --task-definition ffv-lab-api \
  --query 'taskDefinition.containerDefinitions[].environment[?name==`DB_PASSWORD`]'
# Na Cadencia: 1 ocorrencia, em texto claro, na resposta de uma chamada de leitura.

# (3) A idade da credencial. E a pergunta que o formulario fez.
aws secretsmanager describe-secret --secret-id ffv-lab/banco/app-rw \
  --query '{gira:RotationEnabled,ultima:LastRotatedDate,criado:CreatedDate}'
# Na Cadencia: gira=false, ultima=null, criado ha 412 dias.

// O que o Secrets Manager entrega a cada uma das quatro invocacoes da funcao.
// A MESMA funcao e chamada quatro vezes, com `Step` diferente — e nao quatro
// funcoes. Quem espera quatro recursos procura tres que nao existem.
{
  "Step": "createSecret",
  "SecretId": "arn:aws:secretsmanager:us-east-1:111122223333:secret:ffv-lab/banco/app-rw-AbCdEf",
  // Identificador da versao nova. E o que da idempotencia: se a rotacao falhar
  // depois desta etapa, a tentativa seguinte reencontra a mesma versao em vez de
  // gerar outra senha e deixar lixo em AWSPENDING.
  "ClientRequestToken": "c3d4e5f6-90ab-cdef-fedc-ba987EXAMPLE",
  // Presente apenas em rotacao com papel assumido ou entre contas, para o servico
  // validar a identidade do papel. No caso simples, ele nao vem.
  "RotationToken": null
}

# cofre.tf — a chave propria, o segredo da aplicacao e o segredo do mestre

# ── A CMK: o que ela compra em relacao a `aws/secretsmanager` ─────────────────
# A chave gerenciada pela AWS ja cifra o segredo e ja cumpre "criptografado em
# repouso". O que ela NAO permite e politica propria: com CMK voce consegue
# exigir que a chave so seja usada atraves do Secrets Manager, negar uso direto,
# e auditar a chave separadamente do servico. Se o seu requisito e apenas cifrar,
# a chave gerenciada basta e sai de graca — diga isso em vez de criar CMK por
# reflexo.
resource "aws_kms_key" "segredos" {
  description = "${var.projeto} — segredos de aplicacao"

  # Rotacao de material criptografico da CMK. ATENCAO ao que ela NAO faz:
  # nao gira o segredo, nao recifra dado antigo e nao troca chave de dados
  # ja emitida. Ela troca o material atual; o KMS escolhe sozinho a versao
  # correta para decifrar. Sao dois relogios diferentes com o mesmo nome.
  enable_key_rotation = true
  rotation_period_in_days = 365 # padrao quando omitido; explicito para o leitor

  # Espera antes da exclusao definitiva: 7 a 30 dias, padrao 30. Sete e o
  # minimo, e e o que se usa em laboratorio para nao arrastar recurso.
  deletion_window_in_days = 7

  tags = var.tags
}

resource "aws_kms_alias" "segredos" {
  name          = "alias/${var.projeto}-segredos"
  target_key_id = aws_kms_key.segredos.key_id
}

# A politica de chave e onde o menor privilegio de criptografia mora. A condicao
# `kms:ViaService` amarra o uso ao Secrets Manager: ninguem decifra a chave de
# dados chamando o KMS diretamente, nem com permissao de IAM ampla.
data "aws_iam_policy_document" "chave_segredos" {
  statement {
    sid     = "AdministracaoPelaConta"
    effect  = "Allow"
    actions = ["kms:*"]
    # `Resource: "*"` numa POLITICA DE CHAVE significa "esta chave", nao "todas
    # as chaves": o documento e anexado ao recurso, e nao existe outro alvo
    # possivel. E o unico lugar em que o curinga nao amplia nada.
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = ["arn:aws:iam::${data.aws_caller_identity.atual.account_id}:root"]
    }
  }

  statement {
    sid    = "UsoSomenteAtravesDoSecretsManager"
    effect = "Allow"
    actions = [
      "kms:Decrypt",
      "kms:GenerateDataKey",
      "kms:DescribeKey",
    ]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = [aws_iam_role.task.arn, aws_iam_role.rotacao.arn]
    }
    condition {
      test     = "StringEquals"
      variable = "kms:ViaService"
      values   = ["secretsmanager.${var.regiao}.amazonaws.com"]
    }
  }
}

resource "aws_kms_key_policy" "segredos" {
  key_id = aws_kms_key.segredos.id
  policy = data.aws_iam_policy_document.chave_segredos.json
}

# ── Segredo do MESTRE: rotacao gerenciada, sem Lambda ────────────────────────
# Com `manage_master_user_password`, o RDS gera a senha, cria o segredo e o gira
# a cada sete dias por padrao. A aplicacao NAO usa este segredo: a propria
# documentacao recomenda um usuario com o privilegio minimo em vez do mestre.
# Este e o segredo de migracao e de operacao.
resource "aws_db_instance" "principal" {
  identifier = "${var.projeto}-db"
  engine     = "postgres"

  username                      = "mestre"
  manage_master_user_password   = true
  master_user_secret_kms_key_id = aws_kms_key.segredos.arn
  # Depois que o RDS assume a gestao, a chave do segredo NAO pode mais ser
  # trocada. Escolher a CMK aqui, na criacao, ou aceitar a gerenciada para
  # sempre — nao ha terceira opcao.

  # O resto da instancia vem do L01 e nao muda aqui.
  instance_class      = var.classe_db
  allocated_storage   = 20
  storage_encrypted   = true
  kms_key_id          = aws_kms_key.segredos.arn
  db_subnet_group_name   = aws_db_subnet_group.privada.name
  vpc_security_group_ids = [aws_security_group.db.id]
  skip_final_snapshot    = true # laboratorio; em producao, false
  tags = var.tags
}

# ── Segredo da APLICACAO: o que gira por funcao, e o que a task le ───────────
# O valor inicial NAO e escrito aqui. `random_password` iria para o estado do
# Terraform em texto claro, que e o defeito do desenho minimo. Em vez disso o
# segredo nasce com estrutura e senha vazia, e a PRIMEIRA rotacao preenche.
resource "aws_secretsmanager_secret" "app" {
  name        = "${var.projeto}/banco/app-rw"
  description = "Credencial do usuario de aplicacao; gira por funcao Lambda"
  kms_key_id  = aws_kms_key.segredos.arn

  # Espera de recuperacao: 7 a 30 dias. Enquanto o segredo esta agendado para
  # exclusao ele fica inacessivel e NAO e cobrado — mas o NOME continua
  # ocupado, e recriar com o mesmo nome falha ate a espera terminar.
  recovery_window_in_days = 7

  tags = var.tags
}

# A estrutura JSON e obrigatoria para os modelos de rotacao da AWS, e as chaves
# sao sensiveis a caixa. `masterarn` so entra na estrategia de usuarios
# alternados, e por isso NAO aparece aqui.
resource "aws_secretsmanager_secret_version" "app_inicial" {
  secret_id = aws_secretsmanager_secret.app.id
  secret_string = jsonencode({
    engine               = "postgres"
    host                 = aws_db_instance.principal.address
    port                 = 5432
    dbname               = var.nome_banco
    username             = "app_rw"
    password             = "TROCADO_NA_PRIMEIRA_ROTACAO"
    dbInstanceIdentifier = aws_db_instance.principal.identifier
  })

  # A senha real e escrita pela rotacao. Sem este bloco, cada `apply` reverteria
  # o segredo ao valor de espaco reservado e derrubaria a aplicacao.
  lifecycle {
    ignore_changes = [secret_string]
  }
}

# O ARN e parametro, nao segredo: publicavel, versionavel, estavel. E ele que
# vai para a definicao de task.
output "arn_segredo_app" {
  value       = aws_secretsmanager_secret.app.arn
  description = "Identificador do segredo; nao autoriza nada por si"
}

# rotacao.tf — quem gira, com que alcance de rede, e em que agenda

# A funcao de rotacao precisa alcancar a porta 5432 do banco. Este e o defeito
# numero um de rotacao que falha calada: a funcao existe, a agenda existe, e ela
# expira tentando abrir conexao. Sem sub-rede e grupo de seguranca, nada disso
# aparece na aplicacao — aparece uma semana depois, como erro de autenticacao.
resource "aws_security_group" "rotacao" {
  name   = "${var.projeto}-rotacao"
  vpc_id = aws_vpc.principal.id

  egress {
    description     = "Postgres no banco"
    from_port       = 5432
    to_port         = 5432
    protocol        = "tcp"
    security_groups = [aws_security_group.db.id]
  }

  egress {
    description     = "API do Secrets Manager pelo endpoint de interface"
    from_port       = 443
    to_port         = 443
    protocol        = "tcp"
    security_groups = [aws_security_group.endpoints.id]
  }

  tags = var.tags
}

# O grupo do banco referencia o GRUPO da funcao, nao faixa de IP. Faixa de IP
# num grupo de banco e o antipadrao que L02 e L44 tratam.
resource "aws_security_group_rule" "db_aceita_rotacao" {
  type                     = "ingress"
  security_group_id        = aws_security_group.db.id
  from_port                = 5432
  to_port                  = 5432
  protocol                 = "tcp"
  source_security_group_id = aws_security_group.rotacao.id
  description              = "Rotacao de credencial"
}

# A funcao vem do modelo publicado pela AWS para PostgreSQL em usuario unico.
# Escrever a sua propria so se justifica para segredo que nao e de banco.
resource "aws_serverlessapplicationrepository_cloudformation_stack" "rotacao" {
  name             = "${var.projeto}-rotacao-postgres"
  application_id   = "arn:aws:serverlessrepo:us-east-1:297356227824:applications/SecretsManagerRDSPostgreSQLRotationSingleUser"
  capabilities     = ["CAPABILITY_IAM", "CAPABILITY_RESOURCE_POLICY"]

  parameters = {
    functionName        = "${var.projeto}-rotacao-postgres"
    endpoint            = "https://secretsmanager.${var.regiao}.amazonaws.com"
    vpcSubnetIds        = join(",", aws_subnet.privada[*].id)
    vpcSecurityGroupIds = aws_security_group.rotacao.id
  }
}

# A agenda. Quatro horas e o intervalo minimo suportado; sete dias e o que o RDS
# usa por padrao no segredo do mestre. Trinta dias e o valor deste laboratorio,
# e ele nao e universal: escolha pelo tempo que uma credencial vazada pode
# continuar util no SEU caso, nao pelo que parece prudente.
resource "aws_secretsmanager_secret_rotation" "app" {
  secret_id           = aws_secretsmanager_secret.app.id
  rotation_lambda_arn = aws_serverlessapplicationrepository_cloudformation_stack.rotacao.outputs["RotationLambdaARN"]

  rotation_rules {
    schedule_expression = "rate(30 days)"
    # Janela de duas horas. Ela nao pode invadir a janela seguinte, e comeca a
    # meia-noite UTC quando nao se declara hora de inicio.
    duration = "2h"
  }
}

# ── Permissao da task: menor privilegio de verdade, nos dois servicos ────────
data "aws_iam_policy_document" "task_le_segredo" {
  statement {
    sid       = "LeSomenteOSegredoDaAplicacao"
    effect    = "Allow"
    actions   = ["secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret"]
    resources = [aws_secretsmanager_secret.app.arn]
    # DescribeSecret entra porque o componente de cache do lado do cliente o
    # exige para saber quais versoes existem. Sem ele, a leitura falha com
    # AccessDenied numa chamada que o codigo nao faz explicitamente.
  }

  statement {
    sid       = "DecifraSomenteAtravesDoCofre"
    effect    = "Allow"
    actions   = ["kms:Decrypt"]
    resources = [aws_kms_key.segredos.arn]
    condition {
      test     = "StringEquals"
      variable = "kms:ViaService"
      values   = ["secretsmanager.${var.regiao}.amazonaws.com"]
    }
    # As duas declaracoes acima sao a criptografia de envelope aparecendo na
    # policy: uma autoriza pedir o segredo, a outra autoriza decifrar a chave de
    # dados que o protege. Negar qualquer uma das duas bloqueia a leitura.
  }

  statement {
    sid       = "LeParametroDoAmbiente"
    effect    = "Allow"
    actions   = ["ssm:GetParameters", "ssm:GetParametersByPath"]
    resources = ["arn:aws:ssm:${var.regiao}:${data.aws_caller_identity.atual.account_id}:parameter/${var.projeto}/*"]
  }
}

resource "aws_iam_role_policy" "task_le_segredo" {
  role   = aws_iam_role.task.id
  policy = data.aws_iam_policy_document.task_le_segredo.json
}

# parametro.tf — o que NAO e segredo, e a definicao de task sem valor dentro

# Camada padrao: 10.000 parametros por conta e regiao, valor de ate 4 KB, sem
# custo adicional. A camada avancada sobe para 100.000 e 8 KB, habilita politica
# de parametro e compartilhamento entre contas — e cobra. Passar de padrao para
# avancada e possivel; voltar nao e.
resource "aws_ssm_parameter" "host" {
  name  = "/${var.projeto}/banco/host"
  type  = "String" # nao e sensivel: o host nao autoriza nada
  value = aws_db_instance.principal.address
  tags  = var.tags
}

resource "aws_ssm_parameter" "pool_maximo" {
  name  = "/${var.projeto}/banco/pool-maximo"
  type  = "String"
  value = "20"
  tags  = var.tags
}

# SecureString existe e cifra com KMS igual ao Secrets Manager. Ele e a escolha
# certa para segredo que NAO gira: chave de API de terceiro sem rotacao
# automatica, por exemplo. Nao ha rotacao nem geracao de senha aleatoria aqui.
resource "aws_ssm_parameter" "chave_parceiro" {
  name   = "/${var.projeto}/integracao/chave-parceiro"
  type   = "SecureString"
  key_id = aws_kms_key.segredos.arn
  value  = var.chave_parceiro # variavel sensivel, vinda do cofre do pipeline
  tags   = var.tags

  lifecycle {
    ignore_changes = [value]
  }
}

# ── A definicao de task: repare no que NAO esta aqui ────────────────────────
resource "aws_ecs_task_definition" "api" {
  family                   = "${var.projeto}-api"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 512
  memory                   = 1024

  # Duas roles, dois papeis. A execution role e do AGENTE: puxar imagem,
  # escrever log e resolver o campo `secrets`. A task role e da SUA APLICACAO:
  # e com ela que o processo chama o Secrets Manager em tempo de execucao.
  # Trocar as duas e o erro mais comum da banda 1.
  execution_role_arn = aws_iam_role.execution.arn
  task_role_arn      = aws_iam_role.task.arn

  container_definitions = jsonencode([{
    name  = "api"
    image = "${aws_ecr_repository.api.repository_url}:${var.sha}"

    environment = [
      # Parametro, nao segredo: identificador estavel e nao sensivel. Este e o
      # unico "endereco" que a aplicacao precisa saber.
      { name = "SEGREDO_BANCO_ARN", value = aws_secretsmanager_secret.app.arn },
      { name = "PARAMETRO_PREFIXO", value = "/${var.projeto}" },
      { name = "AWS_REGION", value = var.regiao },
      # NAO existe DB_PASSWORD aqui. E o criterio de aceite do laboratorio, e a
      # prova 1 confere exatamente esta ausencia.
    ]

    # `secrets` seria o caminho nativo, e ele resolve o vazamento: o valor nao
    # aparece em describe-task-definition. O que ele NAO resolve e rotacao — a
    # documentacao diz que, se o segredo muda, e preciso forcar nova implantacao
    # ou iniciar task nova. Por isso ele fica reservado ao que nao gira.
    secrets = [
      { name = "CHAVE_PARCEIRO", valueFrom = aws_ssm_parameter.chave_parceiro.arn },
    ]

    portMappings = [{ containerPort = 8080, protocol = "tcp" }]

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

  tags = var.tags
}

# Endpoint de interface do Secrets Manager: a leitura em tempo de execucao passa
# a nascer e morrer dentro da rede da AWS. Sem ele, a task em sub-rede privada
# precisa de NAT para falar com o cofre — e paga hora ligada mais byte
# processado por um trafego que nao precisava sair.
resource "aws_vpc_endpoint" "secretsmanager" {
  vpc_id              = aws_vpc.principal.id
  service_name        = "com.amazonaws.${var.regiao}.secretsmanager"
  vpc_endpoint_type   = "Interface"
  subnet_ids          = aws_subnet.privada[*].id
  security_group_ids  = [aws_security_group.endpoints.id]
  private_dns_enabled = true
  tags                = var.tags
}

// Program.cs — a aplicacao que rele o segredo sem reiniciar o processo
//
// O ponto do arquivo inteiro: NADA aqui conhece a senha em tempo de compilacao,
// e o processo e capaz de descobrir que ela mudou sem ser reiniciado. Sem a
// segunda metade, a primeira nao vale nada — o segredo saiu do repositorio e a
// rotacao virou indisponibilidade agendada.

using System.Text.Json;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Extensions.Caching;
using Npgsql;
using Polly;

var builder = WebApplication.CreateBuilder(args);

// ── 1. O que e parametro entra por variavel de ambiente comum ────────────────
// O ARN identifica; nao autoriza. Quem o obtiver sem a permissao de IAM nao le
// nada, e quem tiver a permissao nao precisa dele escondido. E por isso que ele
// pode estar no Terraform, no Git e no log.
var arnSegredo = builder.Configuration["SEGREDO_BANCO_ARN"]
    ?? throw new InvalidOperationException("SEGREDO_BANCO_ARN ausente na definicao de task");

// ── 2. Cache do lado do cliente ─────────────────────────────────────────────
// O componente da AWS renova de hora em hora por padrao e a politica de descarte
// e "menos usado recentemente". Cinco minutos aqui NAO e gosto: e o teto da
// janela em que a aplicacao ainda pediria a senha anterior depois do
// finish_secret. Baixar custa chamada de API; subir custa janela de falha.
var cache = new SecretsManagerCache(
    new AmazonSecretsManagerClient(),
    new SecretCacheConfiguration { CacheItemTTL = 300_000 }); // milissegundos

// A estrutura JSON e a que os modelos de rotacao da AWS esperam, e as chaves sao
// sensiveis a caixa. Ler campo por campo, em vez de montar cadeia de conexao no
// cofre, mantem host e porta como PARAMETRO e so a senha como segredo.
static async Task<(string usuario, string senha)> LerCredencialAsync(
    SecretsManagerCache cache, string arn)
{
    var json = await cache.GetSecretString(arn);
    using var doc = JsonDocument.Parse(json);
    var raiz = doc.RootElement;
    return (raiz.GetProperty("username").GetString()!,
            raiz.GetProperty("password").GetString()!);
}

var (usuarioInicial, _) = await LerCredencialAsync(cache, arnSegredo);

// ── 3. Uma fonte de dados por processo, com provedor periodico de senha ──────
// O pool vive na fonte de dados; uma conexao por requisicao sem pool e o defeito
// que L07 mede. O provedor periodico e o mecanismo que fecha o laco deste
// modulo: o retorno de chamada e invocado por TEMPORIZADOR, nao na abertura da
// conexao, entao ele nao entra no caminho da latencia.
var fonte = new NpgsqlDataSourceBuilder(new NpgsqlConnectionStringBuilder
{
    Host = builder.Configuration["BANCO_HOST"],
    Port = 5432,
    Database = builder.Configuration["BANCO_NOME"],
    Username = usuarioInicial,
    SslMode = SslMode.VerifyFull,
    MaxPoolSize = int.Parse(builder.Configuration["BANCO_POOL_MAXIMO"] ?? "20"),
    // Conexao ociosa e podada, e conexao podada e conexao que sera reaberta com
    // a senha vigente. Sem poda, uma conexao criada antes da rotacao pode viver
    // por dias e esconder que o provedor esta devolvendo valor errado.
    ConnectionIdleLifetime = 300,
}.ConnectionString);

fonte.UsePeriodicPasswordProvider(
    async (_, ct) => (await LerCredencialAsync(cache, arnSegredo)).senha,
    successRefreshInterval: TimeSpan.FromMinutes(5),
    failureRefreshInterval: TimeSpan.FromSeconds(10));
// O segundo intervalo e muito menor que o primeiro de proposito: falha ao ler o
// segredo tem de ser reexaminada em segundos, nao em minutos.

var origem = fonte.Build();
builder.Services.AddSingleton(origem);

// ── 4. A nova tentativa que cobre a janela de recusa ────────────────────────
// Na estrategia de usuario unico existe um intervalo curto entre a troca no
// banco e a atualizacao percebida pelo cliente. A propria AWS descreve o risco
// como baixo e a mitigacao como estrategia apropriada de nova tentativa. O
// jitter e obrigatorio: sem ele, todas as tasks tentam no mesmo instante e a
// recuperacao vira um segundo pico.
builder.Services.AddResiliencePipeline("banco", p => p
    .AddRetry(new()
    {
        ShouldHandle = new PredicateBuilder()
            .Handle<PostgresException>(e => e.SqlState == "28P01"), // senha invalida
        MaxRetryAttempts = 4,
        Delay = TimeSpan.FromMilliseconds(400),
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true,
    }));

var app = builder.Build();

// ── 5. Vivacidade e prontidao respondem a perguntas diferentes ──────────────
// Vivacidade nao toca o banco: se tocasse, uma queda do banco marcaria todas as
// tasks como mortas e o ECS as substituiria em laco. Prontidao toca — e agora
// tambem responde se o segredo esta legivel, porque credencial ilegivel e um
// jeito novo de a task estar de pe e nao poder atender.
app.MapGet("/health/live", () => Results.Ok(new { estado = "vivo" }));

app.MapGet("/health/ready", async (NpgsqlDataSource origem) =>
{
    await using var conexao = await origem.OpenConnectionAsync();
    await using var cmd = conexao.CreateCommand();
    cmd.CommandText = "select 1";
    await cmd.ExecuteScalarAsync();
    return Results.Ok(new { estado = "pronto" });
});

// Rota de diagnostico do laboratorio. Ela devolve o USUARIO e o instante da
// ultima releitura — nunca a senha. Uma rota que devolvesse a senha seria o
// mesmo vazamento que o modulo existe para fechar, com o carimbo de "debug".
app.MapGet("/diagnostico/credencial", async () =>
{
    var (usuario, senha) = await LerCredencialAsync(cache, arnSegredo);
    return Results.Ok(new
    {
        usuario,
        impressao = Convert.ToHexString(
            System.Security.Cryptography.SHA256.HashData(
                System.Text.Encoding.UTF8.GetBytes(senha)))[..12],
        lido_em = DateTimeOffset.UtcNow,
    });
});

app.Run();

# Prova 1 — nenhum segredo no repositorio, e nenhum na definicao de task.
# Duas superficies diferentes: uma e o Git, a outra e o plano de controle.

# (a) O repositorio, incluindo o historico. `git grep` no HEAD nao basta:
# commit antigo continua servindo a senha a quem clona.
git log --all -p -S 'Password=' -- '*.json' '*.cs' '*.tf' | head -40
# Esperado: nada. Se aparecer, o segredo esta no historico e trocar o arquivo
# NAO resolve — e preciso girar a credencial, porque ela vazou.

# (b) O plano de controle. Este comando e o antipadrao central do modulo em
# forma de uma linha: ele devolve tudo o que esta em `environment`.
aws ecs describe-task-definition \
  --task-definition ffv-lab-api \
  --query 'taskDefinition.containerDefinitions[].environment' --output json
# Esperado: SEGREDO_BANCO_ARN, PARAMETRO_PREFIXO e AWS_REGION. Nenhuma senha.
# Antes deste laboratorio, na Cadencia, a mesma consulta devolvia 1 par
# DB_PASSWORD com a senha em texto claro. A medida e binaria: 1 -> 0.

# (c) O que sobrou em `secrets` sao referencias, nao valores.
aws ecs describe-task-definition \
  --task-definition ffv-lab-api \
  --query 'taskDefinition.containerDefinitions[].secrets' --output json
# Esperado: apenas ARN. ARN identifica; nao autoriza.

# Prova 2 — a rotacao aconteceu, e os rotulos provam a ordem.
# Este e o comando que torna o mecanismo OBSERVAVEL em vez de decorado.

# Antes: uma versao com AWSCURRENT (e possivelmente uma com AWSPREVIOUS).
aws secretsmanager describe-secret --secret-id ffv-lab/banco/app-rw \
  --query 'VersionIdsToStages'

# Dispara a rotacao agora, sem esperar a agenda.
aws secretsmanager rotate-secret --secret-id ffv-lab/banco/app-rw

# Durante: se voce for rapido, ve TRES rotulos ao mesmo tempo.
aws secretsmanager describe-secret --secret-id ffv-lab/banco/app-rw \
  --query 'VersionIdsToStages'
# Exemplo de saida no meio da rotacao:
# { "a1b2...": ["AWSCURRENT"], "c3d4...": ["AWSPENDING"] }

# Depois: AWSPENDING desapareceu e AWSPREVIOUS apareceu na versao antiga.
# { "a1b2...": ["AWSPREVIOUS"], "c3d4...": ["AWSCURRENT"] }
#
# APROVA se, ao final, nenhuma versao carrega AWSPENDING.
# REPROVA — e este e o diagnostico que vale memorizar — se AWSPENDING continua
# preso numa versao diferente da AWSCURRENT. Nesse estado, qualquer rotacao
# seguinte supoe que a anterior ainda esta em andamento e devolve erro. A
# rotacao para de acontecer em silencio, e o segredo envelhece com a agenda
# ativa no console.

# Prova 3 — a aplicacao atravessa a rotacao sem implantacao e sem erro.
# Sem esta prova, o laboratorio entregou um cofre e uma promessa.

URL="https://$(terraform output -raw dominio)"
ruins=0; total=0
( while true; do
    c=$(curl -s -o /dev/null -w "%{http_code}" --max-time 3 "$URL/health/ready")
    total=$((total+1)); [ "$c" = "200" ] || ruins=$((ruins+1))
    echo "$(date +%T) $c"; sleep 0.5
  done ) &
LACO=$!

# A impressao da senha ANTES. Doze caracteres de um resumo SHA-256: identifica a
# troca sem revelar valor. Nunca imprima a senha, nem em laboratorio.
curl -s "$URL/diagnostico/credencial"
# {"usuario":"app_rw","impressao":"9F2C41A0B7D3","lido_em":"..."}

aws secretsmanager rotate-secret --secret-id ffv-lab/banco/app-rw
sleep 420   # 5 min de cache + folga; nao ha implantacao nenhuma no meio

curl -s "$URL/diagnostico/credencial"
# {"usuario":"app_rw","impressao":"41E0C8B92AF7","lido_em":"..."}
# A impressao MUDOU e o usuario nao — e a assinatura de usuario unico.

kill $LACO
echo "$ruins de $total"
# Medido na aplicacao de exemplo: 1 de 842. A unica falha foi um 503 na janela
# entre o set_secret e a releitura, absorvido pela nova tentativa do cliente
# seguinte. Com o cache em uma hora, o mesmo teste devolveu 137 de 851 — a
# diferenca inteira e o valor do intervalo de cache, e nada mais.

# Prova 4 — o envelope existe, e negar UMA das duas permissoes basta.
# Esta prova transforma "criptografia de envelope" de definicao em experimento.

# (a) A cadeia aparece no CloudTrail. Repare no contexto de cifragem: ele amarra
# a operacao do KMS ao segredo e a versao especificos.
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=Decrypt \
  --max-results 5 \
  --query 'Events[].CloudTrailEvent' --output text | python3 -m json.tool | \
  grep -A3 encryptionContext
# Esperado:
#   "SecretARN": "arn:aws:secretsmanager:...:secret:ffv-lab/banco/app-rw-AbCdEf"
#   "SecretVersionId": "c3d4..."
# A chamada e invocada por secretsmanager.amazonaws.com em seu nome. Voce nunca
# ve a chave de dados: o cofre a usa fora do KMS e a remove da memoria.

# (b) Agora quebre so a metade criptografica. Mantenha
# secretsmanager:GetSecretValue intacto e remova kms:Decrypt da task role.
aws iam put-role-policy --role-name ffv-lab-task \
  --policy-name le-segredo --policy-document file://sem-kms-decrypt.json

# Force uma task nova e leia a rota de diagnostico.
curl -s -o /dev/null -w '%{http_code}\n' "$URL/diagnostico/credencial"
# Esperado: 500, com AccessDeniedException do KMS no log da aplicacao.
#
# APROVA porque prova a afirmacao: a permissao de ler o segredo NAO e suficiente.
# O cofre precisa decifrar a chave de dados antes de devolver o valor, e essa
# decifragem e autorizada separadamente. Quem entende isso responde corretamente
# a questao classica de certificacao em que "a policy do Secrets Manager esta
# correta e a leitura falha".

# Prova 5 — o que e parametro nao paga preco de segredo, e da para medir.

# Quantos segredos existem, e quantos deles giram?
aws secretsmanager list-secrets \
  --query 'SecretList[].{nome:Name,gira:RotationEnabled,ultima:LastRotatedDate}' \
  --output table
# APROVA se todo segredo listado tem gira=True. Segredo sem rotacao e uma de
# duas coisas: parametro no lugar errado, ou divida declarada com data.
#
# Na Cadencia, a primeira execucao listou 9 segredos: 2 giravam. Dos 7 restantes,
# 5 eram nivel de log, nome de fila e URL de webhook — parametro puro, movido
# para o Parameter Store na camada padrao, que nao tem custo adicional.

# A contagem de leituras, que e a segunda dimensao de custo. Sem cache, cada
# task nova e cada requisicao que abrisse conexao geraria uma chamada.
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=GetSecretValue \
  --start-time "$(date -u -v-1H +%Y-%m-%dT%H:%M:%SZ)" \
  --query 'length(Events)'
# Com cache de 5 min e 2 tasks: cerca de 24 por hora. Sem cache, na mesma hora
# de trafego, foram 1.106. E a mesma funcionalidade, com duas ordens de grandeza
# de diferenca na dimensao que a fatura cobra.

# 1. Desligue a agenda ANTES de mexer no segredo. Rotacao disparando durante a
#    destruicao deixa versao presa em AWSPENDING e o destroy falha em seguida.
aws secretsmanager cancel-rotate-secret --secret-id ffv-lab/banco/app-rw

# 2. A infraestrutura declarada.
terraform destroy -auto-approve

# 3. O segredo fica INACESSIVEL e agendado para exclusao, nao excluido. Em
#    laboratorio, exclua sem recuperacao — senao o NOME continua ocupado por 7 dias
#    e recriar o ambiente falha. Em producao, NUNCA use esta forma.
aws secretsmanager delete-secret --secret-id ffv-lab/banco/app-rw \
  --force-delete-without-recovery

# 4. A chave do KMS entra em espera de 7 a 30 dias. Sete e o minimo, e foi o que o
#    Terraform declarou; nao existe exclusao imediata de chave.
aws kms describe-key --key-id alias/ffv-lab-segredos \
  --query 'KeyMetadata.{estado:KeyState,exclusao:DeletionDate}'

# 5. O endpoint de interface cobra por hora por zona. Confirme que ele sumiu.
aws ec2 describe-vpc-endpoints --query 'VpcEndpoints[].ServiceName'

# 6. O grupo de logs da funcao de rotacao NAO e do Terraform: a pilha do repositorio
#    de aplicacoes o criou, e ele sobrevive com a retencao que tiver.
aws logs delete-log-group --log-group-name /aws/lambda/ffv-lab-rotacao-postgres

# 7. Por ultimo, a pilha da funcao.
aws cloudformation delete-stack --stack-name ffv-lab-rotacao-postgres