Lab 10 — Voltar de um desastre, com ensaio

# Rode ANTES de mudar nada. Tres amostras, dois minutos entre elas — porque uma
# amostra pode cair logo depois de um envio de log e mentir para baixo.
for i in 1 2 3; do
  agora=$(date -u +%s)
  ultimo=$(aws rds describe-db-instances --db-instance-identifier app-postgres \
            --query "DBInstances[0].LatestRestorableTime" --output text)
  eu=$(date -u -d "$ultimo" +%s 2>/dev/null || date -u -jf "%Y-%m-%dT%H:%M:%S%z" "$ultimo" +%s)
  printf "amostra %d: defasagem de %d s\n" "$i" $(( agora - eu ))
  sleep 120
done

# Na Cadencia: 214 s, 61 s e 288 s. Nenhuma passou de 300 — o que confirma a
# cadencia de cinco minutos do log e fixa o piso do RPO para perda de
# infraestrutura. Repare que a defasagem OSCILA: ela nao e um valor, e uma
# serra entre zero e cinco minutos. Prometer "RPO de 1 minuto" com este
# mecanismo e prometer o melhor caso de uma serra.

# E o segundo numero, que e o teto para tras:
aws rds describe-db-instance-automated-backups \
  --db-instance-identifier app-postgres \
  --query "DBInstanceAutomatedBackups[0].RestoreWindow" --output json
# { "EarliestTime": "...", "LatestTime": "..." }
# Na Cadencia, antes deste laboratorio, a janela tinha 24 h: a retencao era 1.

{
  "ensaio": "2026-08-11T17:07:00Z",
  "instanteAlvo": "2026-08-11T17:07:00Z",
  "instanteIncidente": "2026-08-11T17:07:12Z",
  "instanciaOrigem": "app-postgres",
  "instanciaRestaurada": "ffv-lab-ensaio-202608111752",
  "enderecoAntigo": "app-postgres.abc123.us-east-1.rds.amazonaws.com",
  "enderecoNovo": "ffv-lab-ensaio-202608111752.abc123.us-east-1.rds.amazonaws.com",
  "marcos": {
    "T0_incidente": 1786000032,
    "T1_detectado": 1786002072,
    "T2_alvo_decidido": 1786002372,
    "T2b_escrita_congelada": 1786002432,
    "T3_restauracao_disparada": 1786002732,
    "T4_instancia_disponivel": 1786003872,
    "T5_corte_efetivado": 1786004172,
    "T6_validado": 1786004652
  },
  "medido": {
    "rtoSegundos": 4620,
    "rpoSegundos": 4140,
    "rpoComCongelamentoSegundos": 2400,
    "volumeAlocadoGb": 180,
    "zonaDuplaNoEnsaio": false
  },
  "comparacaoComOAcordado": {
    "rtoAcordadoSegundos": 1800,
    "rpoAcordadoSegundos": 300,
    "veredito": "REPROVADO nos dois eixos"
  }
}

# banco-backup.tf — a política de retenção, e por que ela não pode ficar em branco
#
# Quando o Terraform não declara `backup_retention_period`, a API aplica o padrão
# DELA: um dia. Pelo console seriam sete. Ninguém escolheu nenhum dos dois, e é
# esse número que decide quão atrás a recuperação para um instante consegue
# chegar. O intervalo permitido é 0 a 35 dias, e zero desliga o mecanismo.

variable "retencao_backup_dias" {
  description = "Janela de PITR em dias. Derive do incidente mais ANTIGO que você quer poder desfazer."
  type        = number
  default     = 14

  validation {
    # Zero desligaria o PITR e 35 é o teto da API. Falhar no plano é mais barato
    # que descobrir no incidente que a janela era de um dia.
    condition     = var.retencao_backup_dias >= 1 && var.retencao_backup_dias <= 35
    error_message = "Use entre 1 e 35: zero desliga o PITR e 35 é o máximo que o RDS aceita."
  }
}

variable "rotulo_snapshot_final" {
  description = "Sufixo do snapshot final. Valor DECLARADO, versionado com o código."
  type        = string
  default     = "v1"
}

resource "aws_db_instance" "principal" {
  # ── O que já vem do L01, sem alteração ──────────────────────────────────
  identifier             = "app-postgres"
  engine                 = "postgres"
  instance_class          = var.classe_banco
  allocated_storage       = 180
  multi_az                = true          # protege de perda de zona; NÃO protege de DELETE
  db_subnet_group_name    = aws_db_subnet_group.privadas.name
  vpc_security_group_ids  = [aws_security_group.banco.id]
  manage_master_user_password = true
  kms_key_id              = aws_kms_key.dados.arn

  # ── O que este laboratório acrescenta ──────────────────────────────────
  backup_retention_period = var.retencao_backup_dias

  # Trocar de zero para diferente de zero (ou o contrário) causa
  # indisponibilidade — a documentação é explícita. Ir de 1 para 14, que é o caso
  # aqui, é mudança entre dois valores não nulos e se aplica sem parada.
  backup_window = "06:30-07:00"   # UTC. Sem declarar, a AWS sorteia 30 min num bloco de 8 h.

  # Sem isto o snapshot nasce sem etiqueta, e o rateio de custo do L09 não
  # consegue atribuir o armazenamento de backup a ninguém.
  copy_tags_to_snapshot = true

  # O padrão do provider é `true`: apagar a instância levaria os backups
  # automáticos com ela. Em `false`, eles sobrevivem pelo prazo que a retenção
  # tinha no momento da exclusão — e depois expiram sozinhos.
  delete_automated_backups = false

  # O snapshot final é a única cópia que NÃO expira. Ele não substitui a
  # retenção; ele cobre o caso "apaguei a instância e preciso do dado em 2027".
  skip_final_snapshot       = false
  final_snapshot_identifier = "app-postgres-final-${var.rotulo_snapshot_final}"

  # A trava mais barata contra `terraform destroy` disparado na conta errada.
  # Ela obriga um `terraform apply` deliberado antes de qualquer exclusão.
  deletion_protection = true

  # ATENÇÃO ao que NÃO fazer aqui: `final_snapshot_identifier` com `timestamp()`
  # muda em todo plano, e o Terraform passa a propor alteração a cada execução.
  # Nome de snapshot é decisão versionada, não relógio.

  tags = merge(local.tags, {
    # A etiqueta que o AWS Backup usa para selecionar. Banco novo entra no plano
    # por ser etiquetado, não por alguém lembrar de editar o plano.
    Backup = "obrigatorio"
  })
}

output "instante_mais_recente_restauravel" {
  description = "Teto do PITR na última leitura de estado. A distância até o relógio é o piso do RPO."
  # O provider expõe este atributo, mas ele é lido no refresh: não é relógio ao
  # vivo. Para o valor do momento, use `describe-db-instances` — é o que o
  # roteiro do ensaio faz.
  value = aws_db_instance.principal.latest_restorable_time
}

output "endereco_banco_primario" {
  value = aws_db_instance.principal.address
}

# cofre-backup.tf — o ponto de recuperação fora do alcance de quem pode apagá-lo
#
# O cenário deste laboratório inclui credencial comprometida. Se o ponto de
# recuperação vive na mesma conta que o banco, quem tem permissão ampla apaga os
# dois. Cofre em outra conta troca a pergunta "posso apagar?" pela pergunta
# "consigo alcançar?", e a segunda é muito mais difícil.

resource "aws_backup_vault" "cofre" {
  provider    = aws.backup            # alias apontando para a conta de backup
  name        = "${var.projeto}-cofre"
  kms_key_arn = aws_kms_key.cofre.arn # chave da conta de backup, não da de produção
  tags        = local.tags
}

# ── A trava. Leia o modo duas vezes antes de aplicar. ───────────────────────
#
# Não existe argumento "mode": é a PRESENÇA de `changeable_for_days` que decide.
# Presente => modo de conformidade. Ausente => modo de governança.
#
#   governança   → a trava é removível por quem tem a permissão de IAM certa.
#                  Protege de erro operacional e de credencial de aplicação.
#   conformidade → passado o período de carência (mínimo 3 dias, máximo 36.500),
#                  a trava é imutável: nem o usuário raiz nem a AWS a removem
#                  enquanto houver ponto de recuperação dentro.
#
# Num laboratório, conformidade significa pagar armazenamento até o ciclo de vida
# terminar, sem saída. Aqui, governança — e a linha do outro modo fica comentada
# de propósito, com o aviso ao lado.
resource "aws_backup_vault_lock_configuration" "trava" {
  provider          = aws.backup
  backup_vault_name = aws_backup_vault.cofre.name

  # Trabalho que entrar no cofre com ciclo de vida fora deste intervalo FALHA.
  # Recuperação que já estava lá antes da trava mantém o ciclo antigo.
  min_retention_days = 7
  max_retention_days = 35

  # changeable_for_days = 3   # NÃO descomente em laboratório. Ver o aviso acima.
}

resource "aws_backup_plan" "plano" {
  name = "${var.projeto}-plano"
  tags = local.tags

  # ── Regra 1: o contínuo. É ele que dá "qualquer segundo dos últimos 35 dias".
  #
  # Ligar isto transfere ao AWS Backup a administração da janela de backup
  # automático do RDS. Depois disso, mexer na retenção pelo RDS não é o caminho:
  # é pelo plano. E a primeira ativação, quando a retenção sai de zero, é
  # agendada para a próxima janela de manutenção — porque ela causa parada.
  rule {
    rule_name                = "continuo"
    target_vault_name        = aws_backup_vault.cofre.name
    schedule                 = "cron(30 6 * * ? *)"
    enable_continuous_backup = true
    start_window             = 60
    completion_window        = 180

    lifecycle {
      # O teto do contínuo é 35 dias, e ele não transiciona para armazenamento
      # frio: frio exige no mínimo 90 dias, que é mais que o próprio teto.
      delete_after = var.retencao_backup_dias
    }
  }

  # ── Regra 2: o periódico longo, que responde a OUTRA pergunta.
  #
  # O contínuo responde "desfazer o que aconteceu ontem". Este responde "provar
  # como estava o dado no fechamento de março", que é auditoria e não
  # recuperação. Um só não cobre os dois.
  rule {
    rule_name         = "mensal_longo"
    target_vault_name = aws_backup_vault.cofre.name
    schedule          = "cron(0 7 1 * ? *)"

    lifecycle {
      cold_storage_after = 90
      delete_after       = 365   # tem de ser ao menos 90 dias depois do frio
    }
  }
}

resource "aws_backup_selection" "bancos" {
  iam_role_arn = aws_iam_role.backup.arn
  name         = "bancos-etiquetados"
  plan_id      = aws_backup_plan.plano.id

  # Seleção por etiqueta e não por ARN: banco novo entra no plano por ser
  # etiquetado. O risco simétrico é banco que nasce SEM a etiqueta — e é por isso
  # que a seção de observabilidade liga a checagem do Backup Audit Manager.
  selection_tag {
    type  = "STRINGEQUALS"
    key   = "Backup"
    value = "obrigatorio"
  }
}

# ── O papel que o AWS Backup assume ───────────────────────────────────────
resource "aws_iam_role" "backup" {
  name               = "${var.projeto}-backup"
  assume_role_policy = data.aws_iam_policy_document.confia_backup.json
}

data "aws_iam_policy_document" "confia_backup" {
  statement {
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["backup.amazonaws.com"]
    }
  }
}

resource "aws_iam_role_policy_attachment" "backup_base" {
  role       = aws_iam_role.backup.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSBackupServiceRolePolicyForBackup"
}

resource "aws_iam_role_policy_attachment" "backup_restaura" {
  role       = aws_iam_role.backup.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSBackupServiceRolePolicyForRestores"
}

# A permissão que o guia do AWS Backup exige para o contínuo do RDS e que não
# está nas políticas gerenciadas: ligar o backup contínuo MODIFICA a instância,
# porque muda a retenção dela.
data "aws_iam_policy_document" "backup_extra" {
  statement {
    actions   = ["rds:ModifyDBInstance"]
    resources = [aws_db_instance.principal.arn]
  }
}

// ProvedorDeConexao.cs — a peça que transforma repontar em troca de valor
//
// O ponto central deste laboratório em uma linha de código: a aplicação NÃO
// guarda o endereço do banco. Ela o resolve, e aceita que ele mude sem reiniciar.
using System.Text.Json;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
using Amazon.SimpleSystemsManagement;
using Amazon.SimpleSystemsManagement.Model;
using Npgsql;

public sealed class ProvedorDeConexao : IAsyncDisposable
{
    private readonly IAmazonSimpleSystemsManagement _ssm;
    private readonly IAmazonSecretsManager _segredos;
    private readonly string _nomeParametro;
    private readonly string _arnSegredo;
    private readonly ILogger<ProvedorDeConexao> _log;
    private readonly SemaphoreSlim _trava = new(1, 1);

    private NpgsqlDataSource? _fonte;
    public string HostAtual { get; private set; } = "(nao resolvido)";

    public ProvedorDeConexao(IAmazonSimpleSystemsManagement ssm,
                             IAmazonSecretsManager segredos,
                             IConfiguration cfg,
                             ILogger<ProvedorDeConexao> log)
    {
        _ssm = ssm;
        _segredos = segredos;
        // Nome do parâmetro e ARN do segredo por configuração. O que vem por
        // variável de ambiente é a REFERÊNCIA, nunca o valor.
        _nomeParametro = cfg["Banco:ParametroEndereco"]!;
        _arnSegredo = cfg["Banco:ArnSegredo"]!;
        _log = log;
    }

    public NpgsqlDataSource Fonte =>
        _fonte ?? throw new InvalidOperationException("Chame ResolverAsync antes do primeiro uso.");

    /// <summary>
    /// Lê o endereço ativo e, se mudou, constrói um pool novo e descarta o antigo.
    /// Devolve true quando houve troca — é o sinal que o roteiro do ensaio observa
    /// para cronometrar o instante do corte.
    /// </summary>
    public async Task<bool> ResolverAsync(CancellationToken ct = default)
    {
        await _trava.WaitAsync(ct);
        try
        {
            var par = await _ssm.GetParameterAsync(
                new GetParameterRequest { Name = _nomeParametro }, ct);
            var host = par.Parameter.Value.Trim();
            if (host == HostAtual && _fonte is not null) return false;

            var seg = await _segredos.GetSecretValueAsync(
                new GetSecretValueRequest { SecretId = _arnSegredo }, ct);
            var cred = JsonSerializer.Deserialize<Credencial>(seg.SecretString)!;

            var construtor = new NpgsqlConnectionStringBuilder
            {
                Host = host,
                Port = 5432,
                Database = "appdb",
                Username = cred.username,
                Password = cred.password,
                SslMode = SslMode.VerifyFull,
                RootCertificate = "/etc/ssl/certs/rds-global-bundle.pem",
                // O pool é o assunto do L07. Aqui ele importa por outro motivo:
                // trocar de banco exige DESCARTAR o pool antigo, senão as
                // conexões abertas continuam apontando para o banco danificado.
                MaxPoolSize = 20,
                MinPoolSize = 2,
                Timeout = 5,
                CommandTimeout = 15,
                KeepAlive = 30,
                ApplicationName = "api-pedidos",
            };

            var nova = new NpgsqlDataSourceBuilder(construtor.ConnectionString).Build();
            var antiga = _fonte;
            _fonte = nova;
            var anterior = HostAtual;
            HostAtual = host;

            _log.LogWarning("Endereco do banco trocado de {Antes} para {Depois}", anterior, host);

            if (antiga is not null)
            {
                // Espera curta para o comando em voo terminar, e só então fecha.
                // Descartar imediatamente cortaria transação legítima; esperar
                // para sempre deixaria escrita indo para o banco errado.
                _ = Task.Run(async () =>
                {
                    await Task.Delay(TimeSpan.FromSeconds(10), CancellationToken.None);
                    await antiga.DisposeAsync();
                });
            }
            return true;
        }
        finally { _trava.Release(); }
    }

    public ValueTask DisposeAsync() => _fonte?.DisposeAsync() ?? ValueTask.CompletedTask;

    private sealed record Credencial(string username, string password);
}

// ── O vigia que faz o corte acontecer sem deploy ───────────────────────────
// Quinze segundos é uma escolha, não um padrão: é o teto que a equipe aceitou
// para a parcela de repontar. Menos que isso multiplica chamadas ao Parameter
// Store sem ganho perceptível.
public sealed class VigiaDeEndereco(ProvedorDeConexao provedor, ILogger<VigiaDeEndereco> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            try { await provedor.ResolverAsync(ct); }
            catch (Exception e) { log.LogError(e, "Falha ao resolver o endereco ativo"); }
            await Task.Delay(TimeSpan.FromSeconds(15), ct);
        }
    }
}

// Program.cs — as rotas de saúde, e a terceira pergunta que este módulo acrescenta
using Npgsql;
using Polly;
using Polly.Retry;

var construtor = WebApplication.CreateBuilder(args);
construtor.Services.AddAWSService<Amazon.SimpleSystemsManagement.IAmazonSimpleSystemsManagement>();
construtor.Services.AddAWSService<Amazon.SecretsManager.IAmazonSecretsManager>();
construtor.Services.AddSingleton<ProvedorDeConexao>();
construtor.Services.AddHostedService<VigiaDeEndereco>();
construtor.Services.AddOpenTelemetry().WithTracing(t => t.AddNpgsql().AddOtlpExporter());

// Repetição com espera crescente E dispersão. Sem dispersão, todas as tasks
// tentam no mesmo milissegundo e transformam oscilação em apagão (assunto do L36).
var repeticao = new ResiliencePipelineBuilder()
    .AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true,
        Delay = TimeSpan.FromMilliseconds(200),
        ShouldHandle = new PredicateBuilder().Handle<NpgsqlException>(e => e.IsTransient),
    })
    .Build();

var app = construtor.Build();
var provedor = app.Services.GetRequiredService<ProvedorDeConexao>();
await provedor.ResolverAsync();

// ── Vivacidade: NÃO toca o banco ──────────────────────────────────────────
// Se esta rota consultasse o banco, uma restauração em andamento marcaria todas
// as tasks como mortas, o ECS as substituiria em laço, e as novas nasceriam
// igualmente mortas. Você teria transformado um incidente de dado num incidente
// de disponibilidade, no pior momento possível.
app.MapGet("/health/live", () => Results.Ok(new { vivo = true }));

// ── Prontidão: toca o banco E confere a identidade dele ───────────────────
// Três perguntas, e a terceira é a que este laboratório acrescenta:
//   1. o pool abre conexão?                        (rede e instância)
//   2. o schema esperado está aplicado?            (migration)
//   3. estamos ligados ao host que o parâmetro manda?  (o corte terminou)
app.MapGet("/health/ready", async (ProvedorDeConexao pr) =>
{
    try
    {
        await using var conexao = await pr.Fonte.OpenConnectionAsync();
        await using var cmd = new NpgsqlCommand(
            "SELECT count(*) FROM information_schema.tables WHERE table_name = 'pedido_item'",
            conexao);
        var tabelas = (long)(await cmd.ExecuteScalarAsync())!;
        if (tabelas == 0) return Results.StatusCode(503);

        // A conexão real informa o host a que chegou. Comparar com o que o
        // parâmetro pediu é o que distingue "o pool recarregou" de "o pool ainda
        // está falando com o banco antigo" — e essa distinção é o corte.
        var alinhado = string.Equals(conexao.Host, pr.HostAtual, StringComparison.OrdinalIgnoreCase);
        return alinhado
            ? Results.Ok(new { pronto = true, host = conexao.Host })
            : Results.StatusCode(503);
    }
    catch { return Results.StatusCode(503); }
});

// ── A rota que o roteiro do ensaio consulta para cronometrar o corte ──────
// Sem autenticação de usuário final: ela vive na rede privada, atrás do
// balanceador interno, e devolve só o host — nunca credencial.
app.MapGet("/interno/onde-estou", (ProvedorDeConexao pr) =>
    Results.Ok(new { host = pr.HostAtual, quando = DateTimeOffset.UtcNow }));

app.Run();

#!/usr/bin/env bash
# ensaiar-restauracao.sh — o laboratorio inteiro cabe aqui, e o que ele produz
# nao e um "ok": sao dois numeros, em segundos.
set -euo pipefail

PROJETO="${PROJETO:-ffv-lab}"
ORIGEM="app-postgres"
ALVO="${PROJETO}-ensaio-$(date -u +%Y%m%d%H%M)"
PARAMETRO="/${PROJETO}/banco/endereco-ativo"
URL_INTERNA="${URL_INTERNA:?defina a URL interna da API}"
MARCOS="marcos-$(date -u +%Y%m%dT%H%M%SZ).tsv"

marcar() { printf '%s\t%s\t%s\n' "$(date -u +%s)" "$(date -u +%FT%TZ)" "$1" | tee -a "$MARCOS"; }
epoca_de() { awk -F'\t' -v m="$1" '$3==m {print $1; exit}' "$MARCOS"; }

# ── T0 · o incidente ───────────────────────────────────────────────────────
# No ensaio ele e provocado, e o instante e anotado com precisao de segundo,
# porque o RPO se calcula contra ele. Num incidente real este e o numero mais
# dificil de obter: ele vem da auditoria do banco, nao da memoria de ninguem.
marcar T0_incidente
psql "$(cadeia_de_conexao_producao)" <<'SQL'
  BEGIN;
  -- O comando do ensaio e deliberadamente parecido com o do incidente real:
  -- uma unica linha, sintaticamente perfeita, semanticamente catastrofica.
  DELETE FROM pedido_item WHERE criado_em > now() - interval '30 days';
  COMMIT;
SQL

# ── T1 · detectar ──────────────────────────────────────────────────────────
# Aqui o ensaio pode trapacear de duas formas, e as duas invalidam o numero:
# marcar T1 imediatamente (porque voce sabia da hora) ou nao marcar. O honesto e
# esperar o SINAL que existe na sua conta. Se nao existe sinal, use o tempo
# medio de reclamacao da operacao e escreva ao lado que e uma estimativa.
read -r -p "Pressione ENTER quando o alarme (ou a ligacao da operacao) chegar: " _
marcar T1_detectado

# ── T2 · decidir o instante alvo ───────────────────────────────────────────
# A precisao desta decisao vira RPO direto. Com pgaudit ou com o registro de
# transacao, voce tem o segundo. Sem isso, sobra o chute, e o chute prudente
# custa minutos de dado que existiam.
ALVO_ISO="${ALVO_ISO:?defina o instante alvo em ISO-8601 UTC, por exemplo 2026-08-11T17:07:00Z}"
ALVO_EPOCA=$(date -u -d "$ALVO_ISO" +%s 2>/dev/null || date -u -jf "%Y-%m-%dT%H:%M:%SZ" "$ALVO_ISO" +%s)
marcar T2_alvo_decidido

# A janela e um TETO. Pedir um instante fora dela falha, e falha aqui e barata.
aws rds describe-db-instance-automated-backups \
  --db-instance-identifier "$ORIGEM" \
  --query 'DBInstanceAutomatedBackups[0].RestoreWindow' --output json

# ── T2b · congelar a escrita ───────────────────────────────────────────────
# A alavanca que o primeiro ensaio revelou, e que nao esta em nenhum console:
# enquanto a aplicacao grava no banco danificado, o RPO cresce. Somente-leitura
# aqui congela a perda no valor que ela tem agora.
aws ssm put-parameter --name "/${PROJETO}/app/modo" --value "somente-leitura" --overwrite
marcar T2b_escrita_congelada

# ── T3 · disparar a restauracao ────────────────────────────────────────────
# Os tres argumentos que evitam o incidente dentro do incidente. Sem eles, a
# instancia nasce com a VPC, o grupo de seguranca e o grupo de parametros
# PADRAO da conta — e a aplicacao nao conecta, ou conecta e fica lenta.
aws rds restore-db-instance-to-point-in-time \
  --source-db-instance-identifier "$ORIGEM" \
  --target-db-instance-identifier "$ALVO" \
  --restore-time "$ALVO_ISO" \
  --db-subnet-group-name "$(terraform output -raw grupo_subrede_privada)" \
  --vpc-security-group-ids "$(terraform output -raw sg_banco)" \
  --db-parameter-group-name "$(terraform output -raw grupo_parametros)" \
  --db-instance-class "$(terraform output -raw classe_banco)" \
  --no-multi-az \
  --no-publicly-accessible \
  --tags Key=Projeto,Value="$PROJETO" Key=Efemero,Value=sim
marcar T3_restauracao_disparada

# Zona unica no ensaio economiza; num corte real use --multi-az, e cronometre de
# novo, porque a etapa alonga. O que voce NAO pode e ensaiar com zona unica e
# prometer o numero para um corte com zona dupla.

# ── T4 · disponivel ────────────────────────────────────────────────────────
aws rds wait db-instance-available --db-instance-identifier "$ALVO"
marcar T4_instancia_disponivel

# Disponivel nao e pronta: os blocos continuam vindo do S3 em segundo plano.
aws rds describe-db-instances --db-instance-identifier "$ALVO" \
  --query 'DBInstances[0].[StorageOperationStatus,StorageOperationPercentProgress]' \
  --output text

NOVO_HOST=$(aws rds describe-db-instances --db-instance-identifier "$ALVO" \
  --query 'DBInstances[0].Endpoint.Address' --output text)
echo "endereco novo: $NOVO_HOST"   # compare com o antigo: nunca sao iguais

# Aquecimento das tabelas do caminho critico. Uma varredura completa obriga o
# RDS a trazer os blocos, e e mais rapido pagar isso agora que na primeira
# consulta de um usuario.
psql "postgresql://$NOVO_HOST/appdb" -c "SELECT count(*) FROM pedido_item" \
                                     -c "SELECT count(*) FROM pedido"

# ── T5 · o corte ───────────────────────────────────────────────────────────
# Uma escrita de valor, e o vigia da aplicacao faz o resto. O marco so e
# registrado quando a aplicacao CONFIRMA que trocou — nao quando o comando
# retorna. A diferenca entre os dois e o ciclo de recarga do pool.
aws ssm put-parameter --name "$PARAMETRO" --value "$NOVO_HOST" --overwrite
until [ "$(curl -sf "$URL_INTERNA/interno/onde-estou" | jq -r .host)" = "$NOVO_HOST" ]; do
  sleep 1
done
marcar T5_corte_efetivado
aws ssm put-parameter --name "/${PROJETO}/app/modo" --value "normal" --overwrite

# ── T6 · validar ───────────────────────────────────────────────────────────
# A pergunta nao e "a instancia subiu". E "a invariante de negocio voltou".
psql "postgresql://$NOVO_HOST/appdb" <<'SQL'
  \set ON_ERROR_STOP on
  -- Nenhum pedido pode ter ficado sem item: e a invariante que o DELETE violou.
  SELECT count(*) AS pedidos_orfaos FROM pedido p
   WHERE NOT EXISTS (SELECT 1 FROM pedido_item i WHERE i.pedido_id = p.id);
  -- E a contagem tem de voltar ao patamar de antes do incidente.
  SELECT count(*) AS itens FROM pedido_item;
SQL
marcar T6_validado

# ── Os dois numeros ────────────────────────────────────────────────────────
T0=$(epoca_de T0_incidente); T5=$(epoca_de T5_corte_efetivado); T6=$(epoca_de T6_validado)
T2B=$(epoca_de T2b_escrita_congelada)

RTO=$(( T6 - T0 ))
RPO=$(( T5 - ALVO_EPOCA ))              # o real, sem congelamento
RPO_CONGELADO=$(( T2B - ALVO_EPOCA ))   # o real, com congelamento

printf '\nRTO medido ............... %d s (%d min)\n' "$RTO" $(( RTO / 60 ))
printf 'RPO medido ............... %d s (%d min)\n' "$RPO" $(( RPO / 60 ))
printf 'RPO com congelamento ..... %d s (%d min)\n' "$RPO_CONGELADO" $(( RPO_CONGELADO / 60 ))

# Publicar e o que impede o numero de morrer neste terminal.
aws cloudwatch put-metric-data --namespace "FFV/Desastre" \
  --metric-name RtoMedidoSegundos --value "$RTO" --unit Seconds
aws cloudwatch put-metric-data --namespace "FFV/Desastre" \
  --metric-name RpoMedidoSegundos --value "$RPO" --unit Seconds

# ── Limpeza do que o ensaio criou ─────────────────────────────────────────
# Sem isto, o ensaio mensal deixa doze instancias cobrando por hora ligada.
aws ssm put-parameter --name "$PARAMETRO" --value "$(terraform output -raw endereco_banco_primario)" --overwrite
aws rds delete-db-instance --db-instance-identifier "$ALVO" \
  --skip-final-snapshot --delete-automated-backups

# ensaio.tf — o papel de quem restaura, e por que o curinga aqui é honesto

data "aws_caller_identity" "atual" {}

resource "aws_iam_role" "operador_de_desastre" {
  name = "${var.projeto}-operador-desastre"
  # Assumido por quem conduz o ensaio e pela máquina de estados. Papel separado
  # do papel da aplicação: restaurar não é uma capacidade que a API precise ter.
  assume_role_policy = data.aws_iam_policy_document.confia_operador.json
}

data "aws_iam_policy_document" "operador" {
  # ── A restauração ─────────────────────────────────────────────────────────
  statement {
    actions = [
      "rds:RestoreDBInstanceToPointInTime",
      "rds:RestoreDBInstanceFromDBSnapshot",
    ]
    # O DESTINO ainda não existe quando esta política é escrita: o ARN exato é
    # desconhecido por construção, não por preguiça. O curinga cobre só o prefixo
    # das instâncias de ensaio, e é o mais estreito possível aqui.
    resources = [
      "arn:aws:rds:${var.regiao}:${data.aws_caller_identity.atual.account_id}:db:${var.projeto}-ensaio-*",
      aws_db_instance.principal.arn,
      "arn:aws:rds:${var.regiao}:${data.aws_caller_identity.atual.account_id}:subgrp:*",
      "arn:aws:rds:${var.regiao}:${data.aws_caller_identity.atual.account_id}:pg:*",
    ]
  }

  # ── A leitura de estado ───────────────────────────────────────────────────
  statement {
    actions = [
      "rds:DescribeDBInstances",
      "rds:DescribeDBInstanceAutomatedBackups",
      "rds:DescribeDBSnapshots",
    ]
    # As ações de descrição do RDS são de escopo de conta e não aceitam ARN de
    # recurso. Confira na referência de ações do IAM antes de copiar para outra
    # conta: essa lista muda, e o que hoje é curinga obrigatório pode virar
    # opcional amanhã.
    resources = ["*"]
  }

  # ── O corte, que é uma escrita de valor ───────────────────────────────────
  statement {
    actions   = ["ssm:PutParameter", "ssm:GetParameter"]
    resources = [aws_ssm_parameter.endereco_ativo.arn]
  }

  # ── A limpeza do que o ensaio criou ───────────────────────────────────────
  statement {
    actions = ["rds:DeleteDBInstance", "rds:AddTagsToResource"]
    resources = [
      "arn:aws:rds:${var.regiao}:${data.aws_caller_identity.atual.account_id}:db:${var.projeto}-ensaio-*",
    ]
    # Deliberadamente SEM o banco de produção na lista. A instância de ensaio é
    # descartável; a de produção tem proteção de exclusão ligada e não deve
    # sequer aparecer no alcance deste papel.
  }
}

# ── A indireção: o único valor que o corte altera ─────────────────────────
resource "aws_ssm_parameter" "endereco_ativo" {
  name        = "/${var.projeto}/banco/endereco-ativo"
  description = "Host do banco que a aplicação deve usar. Trocar aqui é o corte."
  type        = "String"
  value       = aws_db_instance.principal.address

  lifecycle {
    # O corte de desastre escreve neste parâmetro FORA do Terraform. Sem isto, o
    # próximo `apply` desfaria o corte e devolveria a aplicação ao banco
    # danificado — que é o pior defeito possível nesta arquitetura.
    ignore_changes = [value]
  }
}

resource "aws_cloudwatch_log_group" "ensaio" {
  name              = "/aws/vendedlogs/states/${var.projeto}-ensaio"
  retention_in_days = 90   # os marcos do ensaio são o histórico de RTO da equipe
  tags              = local.tags
}

# ── Prova 3 · nao existe restaurar sobre a instancia atual ───────────────
# Nao ha argumento para isso em nenhuma das duas operacoes. A propria API
# recusa o destino que ja existe, e a recusa e a prova:
aws rds restore-db-instance-to-point-in-time \
  --source-db-instance-identifier app-postgres \
  --target-db-instance-identifier app-postgres \
  --use-latest-restorable-time 2>&1 | tail -1
# An error occurred (DBInstanceAlreadyExists) ...

# E os dois enderecos, lado a lado:
aws rds describe-db-instances \
  --query "DBInstances[?starts_with(DBInstanceIdentifier, 'app-postgres') || \
           starts_with(DBInstanceIdentifier, 'ffv-lab-ensaio')]\
           .[DBInstanceIdentifier,Endpoint.Address]" --output table

# ── Prova 4 · disponivel nao e pronta ───────────────────────────────────
for i in $(seq 1 10); do
  aws rds describe-db-instances --db-instance-identifier "$ALVO" \
    --query "DBInstances[0].[DBInstanceStatus,StorageOperationStatus,\
             StorageOperationPercentProgress]" --output text
  sleep 60
done
# Na Cadencia: available / Initializing / 34 ... 61 ... 88 ... e depois os dois
# campos desaparecem, que e como a API diz "terminou". A leitura de
# `pedido_item` no primeiro minuto levou 4,1 s; depois de aquecida, 180 ms.

# ── Prova 5 · o snapshot manual sobrevive e o automatico nao ────────────
# Faca numa instancia DESCARTAVEL, nunca na de producao.
aws rds create-db-snapshot --db-instance-identifier descartavel \
  --db-snapshot-identifier manual-de-teste
aws rds wait db-snapshot-completed --db-snapshot-identifier manual-de-teste
aws rds delete-db-instance --db-instance-identifier descartavel \
  --skip-final-snapshot --delete-automated-backups
aws rds wait db-instance-deleted --db-instance-identifier descartavel

# O manual continua la:
aws rds describe-db-snapshots --snapshot-type manual \
  --query "DBSnapshots[?DBInstanceIdentifier=='descartavel'].DBSnapshotIdentifier"
# ["manual-de-teste"]

# O automatico, nao:
aws rds describe-db-instance-automated-backups \
  --query "DBInstanceAutomatedBackups[?DBInstanceIdentifier=='descartavel']"
# []  <- e com --no-delete-automated-backups esta lista teria uma entrada,
#        valida pelo prazo que a retencao tinha na hora da exclusao.

"""Publica o RPO e a janela de retencao como metrica, a cada 5 minutos.

Existe porque nenhuma das duas grandezas tem metrica nativa. O calculo e
trivial; o valor esta em ele acontecer sem ninguem pedir.
"""
import os
from datetime import datetime, timezone

import boto3

RDS = boto3.client("rds")
CW = boto3.client("cloudwatch")
INSTANCIA = os.environ["INSTANCIA"]


def handler(evento, contexto):
    agora = datetime.now(timezone.utc)
    inst = RDS.describe_db_instances(DBInstanceIdentifier=INSTANCIA)["DBInstances"][0]

    # Ausente enquanto a instancia nao estiver disponivel: backup nao ocorre
    # fora do estado `available`, e tratar a ausencia como zero mentiria.
    ultimo = inst.get("LatestRestorableTime")
    if ultimo is None:
        return {"publicado": False, "motivo": inst["DBInstanceStatus"]}

    rpo = (agora - ultimo).total_seconds()

    janela = RDS.describe_db_instance_automated_backups(
        DBInstanceIdentifier=INSTANCIA)["DBInstanceAutomatedBackups"][0]["RestoreWindow"]
    dias = (agora - janela["EarliestTime"]).total_seconds() / 86400

    CW.put_metric_data(Namespace="FFV/Desastre", MetricData=[
        {"MetricName": "RpoSegundos", "Value": rpo, "Unit": "Seconds"},
        {"MetricName": "DiasRecuperaveis", "Value": dias, "Unit": "Count"},
    ])
    return {"publicado": True, "rpoSegundos": rpo, "diasRecuperaveis": dias}

# 0. A proteção de exclusão do banco impede o destroy. Isto e de proposito:
#    desligue deliberadamente, e so quando tiver certeza da conta.
aws sts get-caller-identity --query Account --output text   # confira ANTES
aws rds modify-db-instance --db-instance-identifier app-postgres \
  --no-deletion-protection --apply-immediately

# 1. Derrube o que o Terraform administra. Ele vai criar o snapshot final,
#    porque `skip_final_snapshot = false` — e o snapshot final NAO expira.
terraform destroy -auto-approve

# 2. INSTANCIAS DE ENSAIO orfas. Um ensaio interrompido no meio deixa uma
#    instancia do tamanho da producao cobrando por hora ligada.
aws rds describe-db-instances \
  --query "DBInstances[?starts_with(DBInstanceIdentifier, 'ffv-lab-ensaio')]\
           .[DBInstanceIdentifier,DBInstanceStatus,AllocatedStorage]" --output table
aws rds delete-db-instance --db-instance-identifier ffv-lab-ensaio-XXXX \
  --skip-final-snapshot --delete-automated-backups

# 3. SNAPSHOTS MANUAIS, incluindo o final. Sao os unicos que NAO expiram:
#    ficam cobrando GB-mes ate alguem apagar, e o limite e 100 por regiao.
aws rds describe-db-snapshots --snapshot-type manual \
  --query "DBSnapshots[].[DBSnapshotIdentifier,AllocatedStorage,SnapshotCreateTime]" \
  --output table
aws rds delete-db-snapshot --db-snapshot-identifier app-postgres-final-v1

# 4. BACKUPS AUTOMATICOS RETIDOS. Com delete_automated_backups = false eles
#    sobrevivem a instancia e expiram sozinhos — mas cobram ate expirar, e o
#    limite e 40 por regiao.
aws rds describe-db-instance-automated-backups \
  --query "DBInstanceAutomatedBackups[].[DBInstanceIdentifier,DbiResourceId,Status]" \
  --output table
aws rds delete-db-instance-automated-backup --dbi-resource-id db-XXXXXXXX

# 5. PONTOS DE RECUPERACAO NO COFRE. Se a trava for de governanca, isto
#    funciona com a permissao certa. Se for de CONFORMIDADE e a carencia
#    venceu, nao funciona para ninguem — nem para voce, nem para a AWS.
aws backup describe-backup-vault --backup-vault-name ffv-lab-cofre \
  --query "[Locked,LockDate,NumberOfRecoveryPoints]" --output text
aws backup list-recovery-points-by-backup-vault --backup-vault-name ffv-lab-cofre \
  --query "RecoveryPoints[].RecoveryPointArn" --output text
aws backup delete-recovery-point --backup-vault-name ffv-lab-cofre \
  --recovery-point-arn "arn:aws:backup:..."
aws backup delete-backup-vault-lock-configuration --backup-vault-name ffv-lab-cofre
aws backup delete-backup-vault --backup-vault-name ffv-lab-cofre   # so se vazio

# 6. GRUPO DE LOGS do ensaio: tem retencao propria e nao pertence ao ciclo da
#    maquina de estados. Continua cobrando ingestao retida depois de tudo apagado.
aws logs delete-log-group --log-group-name /aws/vendedlogs/states/ffv-lab-ensaio

# 7. E o que veio do L01 e do L02 e cobra por hora ligada: balanceador (ALB),
#    endpoint de VPC, repositorio ECR com imagem, e — se voce optou por saida
#    para a internet — NAT Gateway com o Elastic IP dele, que cobra justamente
#    por NAO estar associado a nada.
aws ec2 describe-addresses --query "Addresses[?AssociationId==null].PublicIp" --output table
aws ec2 describe-nat-gateways --query "NatGateways[?State=='available'].NatGatewayId" --output table
aws ec2 describe-vpc-endpoints --query "VpcEndpoints[].VpcEndpointId" --output table
aws elbv2 describe-load-balancers --query "LoadBalancers[].LoadBalancerArn" --output table
aws ecr describe-repositories --query "repositories[].repositoryName" --output table

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