Lab 37 — Consistência eventual do ponto de vista do usuário

{
  "eventID": "3b2c1de9f7a84e6a9c3d1f6b2a7e5c41",
  "eventName": "MODIFY",
  "eventSource": "aws:dynamodb",
  "awsRegion": "us-east-1",
  "dynamodb": {
    "Keys": { "pedidoId": { "S": "PED-93214" } },
    "NewImage": {
      "pedidoId": { "S": "PED-93214" },
      "status": { "S": "confirmado" },
      "autorId": { "S": "usr-7781" },
      "atualizadoEm": { "S": "2026-08-07T18:04:02.118Z" }
    },
    "OldImage": {
      "pedidoId": { "S": "PED-93214" },
      "status": { "S": "pendente" },
      "autorId": { "S": "usr-7781" },
      "atualizadoEm": { "S": "2026-08-07T18:03:58.004Z" }
    },
    "SequenceNumber": "820400000000015221234567",
    "StreamViewType": "NEW_AND_OLD_IMAGES"
  },
  "eventSourceARN": "arn:aws:dynamodb:us-east-1:111122223333:table/Pedidos/stream/2026-08-07T18:00:00.000"
}

# dados.tf — a tabela, a fila e o cache: os tres pontos onde um relogio comeca ou termina

resource "aws_dynamodb_table" "pedidos" {
  name         = "${var.projeto}-pedidos"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "pedidoId"

  attribute {
    name = "pedidoId"
    type = "S"
  }

  # Sem isto nao ha evento para o invalidador ouvir. NEW_AND_OLD_IMAGES porque
  # o invalidador so precisa da CHAVE para apagar o cache, mas o OldImage fica
  # disponivel para auditoria — fora do escopo deste laboratorio, mas caro de
  # adicionar depois se voce escolher KEYS_ONLY agora.
  stream_enabled   = true
  stream_view_type = "NEW_AND_OLD_IMAGES"

  point_in_time_recovery {
    enabled = true
  }
}

# Fila PADRAO, nao FIFO: aceitar mensagem fora de ordem e o pressuposto deste
# desenho, nao uma limitacao contornada. FIFO custaria taxa de mensagem maior
# e um grupo por recurso so para resolver um problema que o invalidador ja
# resolve de outro jeito — apagando a chave em vez de escrever nela.
resource "aws_sqs_queue" "comandos_escrita" {
  name = "${var.projeto}-comandos-escrita"

  # Tempo para o worker processar UM lote antes da mensagem reaparecer para
  # outro consumidor. Maior que o pior caso medido de validacao + PutItem;
  # menor que isso reprocessa mensagem que ainda esta em voo (duplicata).
  visibility_timeout_seconds = 30

  redrive_policy = jsonencode({
    deadLetterTargetArn = aws_sqs_queue.comandos_escrita_dlq.arn
    maxReceiveCount      = 5
  })
}

# Mensagem que falha 5 vezes nao fica reprocessando para sempre: vai para a
# DLQ, e um alarme (secao de observabilidade) avisa alguem. Sem isto, uma
# mensagem invalida fica em loop de visibilidade indefinidamente.
resource "aws_sqs_queue" "comandos_escrita_dlq" {
  name                      = "${var.projeto}-comandos-escrita-dlq"
  message_retention_seconds = 1209600 # 14 dias, o teto do SQS
}

resource "aws_elasticache_replication_group" "cache" {
  replication_group_id      = "${var.projeto}-cache"
  description                = "Chave comum do item e marcador de leitura-propria-escrita"
  engine                     = "redis"
  node_type                  = "cache.t4g.micro"
  num_cache_clusters         = 2 # primario + replica; leitura nao para se o primario falhar
  automatic_failover_enabled = true
  subnet_group_name          = aws_elasticache_subnet_group.cache.name
  security_group_ids         = [aws_security_group.cache.id]
  at_rest_encryption_enabled = true
  transit_encryption_enabled = true
}

resource "aws_elasticache_subnet_group" "cache" {
  name       = "${var.projeto}-cache"
  subnet_ids = aws_subnet.privada[*].id
}

# O grupo do cache so aceita trafego do grupo das funcoes — nunca faixa de IP.
# O Redis nao tem politica de recurso como o DynamoDB; o security group E o
# controle de acesso aqui.
resource "aws_security_group" "cache" {
  name   = "${var.projeto}-cache"
  vpc_id = aws_vpc.principal.id

  ingress {
    from_port       = 6379
    to_port         = 6379
    protocol        = "tcp"
    security_groups = [aws_security_group.funcoes.id]
  }
}

# funcoes.tf — quatro funcoes: duas no caminho sincrono, duas nos dois relogios assincronos

resource "aws_security_group" "funcoes" {
  name   = "${var.projeto}-funcoes"
  vpc_id = aws_vpc.principal.id

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"] # so saida; a funcao nao recebe conexao direta
  }
}

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

# ── Escrita: enfileira o comando E grava o marcador, na mesma invocacao ─────
resource "aws_iam_role" "escrita" {
  name               = "${var.projeto}-escrita"
  assume_role_policy = data.aws_iam_policy_document.assume_lambda.json
}

data "aws_iam_policy_document" "escrita" {
  statement {
    effect    = "Allow"
    actions   = ["sqs:SendMessage"]
    resources = [aws_sqs_queue.comandos_escrita.arn]
  }
  statement {
    effect  = "Allow"
    actions = ["ec2:CreateNetworkInterface", "ec2:DescribeNetworkInterfaces", "ec2:DeleteNetworkInterface"]
    # Lambda em VPC precisa gerenciar a propria interface de rede; a acao nao
    # aceita recurso especifico — e por isso que aparece com "*", nao preguica.
    resources = ["*"]
  }
}

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

resource "aws_lambda_function" "escrita" {
  function_name = "${var.projeto}-escrita"
  role          = aws_iam_role.escrita.arn
  runtime       = "dotnet8"
  handler       = "Funcoes::Consistencia.EscritaFunction::ManipularAsync"
  filename      = data.archive_file.funcoes.output_path
  timeout       = 10
  memory_size   = 256

  vpc_config {
    subnet_ids         = aws_subnet.privada[*].id
    security_group_ids = [aws_security_group.funcoes.id]
  }

  environment {
    variables = {
      FILA_URL       = aws_sqs_queue.comandos_escrita.url
      REDIS_ENDPOINT = aws_elasticache_replication_group.cache.primary_endpoint_address
      # Deve ser MAIOR que a janela de invalidacao medida na prova 4. Comeca
      # conservador; recalibre com o numero real do seu ambiente.
      TTL_MARCADOR_S = "10"
    }
  }
}

# ── Worker: consome a fila, valida de verdade, grava a fonte da verdade ─────
resource "aws_lambda_event_source_mapping" "worker" {
  event_source_arn = aws_sqs_queue.comandos_escrita.arn
  function_name    = aws_lambda_function.worker.arn
  batch_size       = 10
}

resource "aws_lambda_function" "worker" {
  function_name = "${var.projeto}-worker"
  role          = aws_iam_role.worker.arn
  runtime       = "dotnet8"
  handler       = "Funcoes::Consistencia.WorkerFunction::ProcessarAsync"
  filename      = data.archive_file.funcoes.output_path
  timeout       = 30 # cobre o visibility_timeout da fila com folga
  memory_size   = 256

  vpc_config {
    subnet_ids         = aws_subnet.privada[*].id
    security_group_ids = [aws_security_group.funcoes.id]
  }
}

# ── Invalidador: ouve o Streams, apaga a chave comum ────────────────────────
resource "aws_lambda_event_source_mapping" "invalidador" {
  event_source_arn  = aws_dynamodb_table.pedidos.stream_arn
  function_name     = aws_lambda_function.invalidador.arn
  starting_position = "LATEST"
}

resource "aws_lambda_function" "invalidador" {
  function_name = "${var.projeto}-invalidador"
  role          = aws_iam_role.invalidador.arn
  runtime       = "dotnet8"
  handler       = "Funcoes::Consistencia.InvalidadorFunction::InvalidarAsync"
  filename      = data.archive_file.funcoes.output_path

  vpc_config {
    subnet_ids         = aws_subnet.privada[*].id
    security_group_ids = [aws_security_group.funcoes.id]
  }
}

# ── Leitura: marcador primeiro, chave comum depois, banco por ultimo ────────
resource "aws_lambda_function" "leitura" {
  function_name = "${var.projeto}-leitura"
  role          = aws_iam_role.leitura.arn
  runtime       = "dotnet8"
  handler       = "Funcoes::Consistencia.LeituraFunction::ManipularAsync"
  filename      = data.archive_file.funcoes.output_path

  vpc_config {
    subnet_ids         = aws_subnet.privada[*].id
    security_group_ids = [aws_security_group.funcoes.id]
  }
}

# Os papeis de worker, invalidador e leitura seguem o mesmo padrao do de
# escrita — dynamodb:PutItem/GetItem restrito ao ARN da tabela, mais as tres
# acoes de ENI acima — e foram omitidos aqui por repeticao, nao por estarem
# ausentes: cada funcao tem o SEU papel, nunca um papel compartilhado entre as
# quatro, porque o menor privilegio de cada uma e diferente.

resource "aws_apigatewayv2_api" "http" {
  name          = "${var.projeto}-http"
  protocol_type = "HTTP"
}

resource "aws_apigatewayv2_route" "escrita" {
  api_id    = aws_apigatewayv2_api.http.id
  route_key = "POST /pedidos/{id}"
  target    = "integrations/${aws_apigatewayv2_integration.escrita.id}"
}

resource "aws_apigatewayv2_route" "leitura" {
  api_id    = aws_apigatewayv2_api.http.id
  route_key = "GET /pedidos/{id}"
  target    = "integrations/${aws_apigatewayv2_integration.leitura.id}"
}

// Funcoes.cs — os dois handlers que resolvem o sintoma do usuario, sem mudar
// a arquitetura duravel por baixo

using System.Text.Json;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.SQS;
using Amazon.SQS.Model;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.CloudWatch;
using Amazon.CloudWatch.Model;
using StackExchange.Redis;

namespace Consistencia;

public class EscritaFunction
{
    private static readonly IAmazonSQS Sqs = new AmazonSQSClient();
    private static readonly Lazy<ConnectionMultiplexer> Redis = new(() =>
        ConnectionMultiplexer.Connect(Environment.GetEnvironmentVariable("REDIS_ENDPOINT")!));
    private static readonly int TtlMarcadorSegundos =
        int.Parse(Environment.GetEnvironmentVariable("TTL_MARCADOR_S") ?? "10");

    public async Task<APIGatewayHttpApiV2ProxyResponse> ManipularAsync(
        APIGatewayHttpApiV2ProxyRequest req)
    {
        var pedidoId = req.PathParameters["id"];
        // A identidade do autor vem do contexto de autorizacao ja validado
        // pelo API Gateway (JWT authorizer) — fora do escopo deste
        // laboratorio, que assume que a identidade ja chega resolvida.
        var autorId = req.RequestContext.Authorizer.Jwt.Claims["sub"];
        var corpo = JsonSerializer.Deserialize<PedidoEntrada>(req.Body)!;

        // Validacao de FORMA apenas. A validacao de REGRA de negocio — que
        // pode rejeitar o pedido — acontece no worker, depois da fila. Essa
        // divisao e o que permite responder rapido sem mentir sobre o que
        // ja foi checado.
        if (string.IsNullOrWhiteSpace(corpo.Status))
            return Resposta(400, new { erro = "status obrigatorio" });

        var comando = new
        {
            pedidoId,
            autorId,
            corpo.Status,
            enviadoEm = DateTimeOffset.UtcNow,
        };
        var comandoJson = JsonSerializer.Serialize(comando);

        await Sqs.SendMessageAsync(new SendMessageRequest
        {
            QueueUrl    = Environment.GetEnvironmentVariable("FILA_URL"),
            MessageBody = comandoJson,
        });

        // O passo que resolve os DOIS atrasos do desenho minimo: grava o
        // resultado que o autor vai querer ler, no MESMO request que aceitou
        // a escrita — sem esperar fila nem worker. TTL curto: o marcador nao
        // e fonte da verdade, e um atalho com prazo de validade.
        //
        // Fail-open, igual a Leitura: se o Redis estiver fora do ar aqui, a
        // ESCRITA (que ja foi enfileirada acima) nao pode falhar por causa de
        // um atalho de visibilidade. O autor so perde o marcador, nao a escrita.
        try
        {
            var db = Redis.Value.GetDatabase();
            await db.StringSetAsync(
                $"rw:{autorId}:{pedidoId}",
                comandoJson,
                TimeSpan.FromSeconds(TtlMarcadorSegundos));
        }
        catch (RedisConnectionException)
        {
            // Sem marcador, o autor cai no caminho comum ate a fila processar —
            // pior UX, nunca escrita perdida: a mensagem ja esta no SQS.
        }

        return Resposta(200, comando);
    }

    private static APIGatewayHttpApiV2ProxyResponse Resposta(int codigo, object corpo) => new()
    {
        StatusCode = codigo,
        Body       = JsonSerializer.Serialize(corpo),
        Headers    = new Dictionary<string, string> { ["Content-Type"] = "application/json" },
    };
}

public record PedidoEntrada(string Status);

public class LeituraFunction
{
    private static readonly Lazy<ConnectionMultiplexer> Redis = new(() =>
        ConnectionMultiplexer.Connect(Environment.GetEnvironmentVariable("REDIS_ENDPOINT")!));
    private static readonly IAmazonDynamoDB Dynamo = new AmazonDynamoDBClient();
    private static readonly IAmazonCloudWatch Metricas = new AmazonCloudWatchClient();

    public async Task<APIGatewayHttpApiV2ProxyResponse> ManipularAsync(
        APIGatewayHttpApiV2ProxyRequest req)
    {
        var pedidoId = req.PathParameters["id"];
        var autorId  = req.RequestContext.Authorizer.Jwt.Claims["sub"];
        IDatabase db;
        try { db = Redis.Value.GetDatabase(); }
        catch (RedisConnectionException)
        {
            // Falha do Redis nao vira 500 para o leitor: cai direto para o
            // banco. Fail-open para consistencia, nao fail-closed para erro.
            return await LerDoBancoAsync(pedidoId, "RedisIndisponivel");
        }

        // 1) O marcador do PROPRIO autor tem prioridade. Se existir, E a
        // escrita que ele acabou de fazer — nao ha condicao de corrida
        // possivel aqui, porque foi ele mesmo quem gravou.
        var marcador = await db.StringGetAsync($"rw:{autorId}:{pedidoId}");
        if (marcador.HasValue)
        {
            await PublicarMetricaAsync("MarcadorAutor");
            return Resposta(200, marcador.ToString());
        }

        // 2) Chave compartilhada, igual para qualquer usuario. Pode estar
        // desatualizada se a invalidacao ainda nao chegou — aceitavel para
        // quem NAO e o autor da ultima escrita.
        var chaveComum = $"item:{pedidoId}";
        var comum = await db.StringGetAsync(chaveComum);
        if (comum.HasValue)
        {
            await PublicarMetricaAsync("ChaveComum");
            return Resposta(200, comum.ToString());
        }

        // 3) Cache-miss: busca no DynamoDB e repovoa a chave comum.
        return await LerDoBancoAsync(pedidoId, "BancoAposMiss", db, chaveComum);
    }

    private async Task<APIGatewayHttpApiV2ProxyResponse> LerDoBancoAsync(
        string pedidoId, string origemMetrica, IDatabase? db = null, string? chaveParaRepovoar = null)
    {
        // Leitura padrao (eventualmente consistente): a mesma tabela nao tem
        // por que custar o dobro so porque o cache falhou ou estava vazio.
        var item = await Dynamo.GetItemAsync(new GetItemRequest
        {
            TableName = "Pedidos",
            Key = new() { ["pedidoId"] = new AttributeValue(pedidoId) },
        });
        if (item.Item.Count == 0) return Resposta(404, new { erro = "nao encontrado" });

        var valor = JsonSerializer.Serialize(item.Item);
        if (db is not null && chaveParaRepovoar is not null)
            await db.StringSetAsync(chaveParaRepovoar, valor, TimeSpan.FromMinutes(5));

        await PublicarMetricaAsync(origemMetrica);
        return Resposta(200, valor);
    }

    // A prova da secao de implantacao le esta metrica, nao o log — e a
    // diferenca entre testar e medir.
    private static Task PublicarMetricaAsync(string origem) =>
        Metricas.PutMetricDataAsync(new PutMetricDataRequest
        {
            Namespace = "Consistencia/Leitura",
            MetricData = new List<MetricDatum> { new()
            {
                MetricName = "OrigemDaResposta",
                Dimensions = new List<Dimension> { new() { Name = "Origem", Value = origem } },
                Value      = 1,
                Unit       = StandardUnit.Count,
            }},
        });

    private static APIGatewayHttpApiV2ProxyResponse Resposta(int codigo, object corpo) => new()
    {
        StatusCode = codigo,
        Body       = corpo is string s ? s : JsonSerializer.Serialize(corpo),
        Headers    = new Dictionary<string, string> { ["Content-Type"] = "application/json" },
    };
}

// Funcoes.cs (continuacao) — a validacao de verdade e a invalidacao; nada
// aqui muda em relacao ao desenho minimo, e essa estabilidade e proposital

using System.Text.Json;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Lambda.SQSEvents;
using Amazon.Lambda.DynamoDBEvents;
using StackExchange.Redis;

namespace Consistencia;

public class WorkerFunction
{
    private static readonly IAmazonDynamoDB Dynamo = new AmazonDynamoDBClient();
    private static readonly Lazy<ConnectionMultiplexer> Redis = new(() =>
        ConnectionMultiplexer.Connect(Environment.GetEnvironmentVariable("REDIS_ENDPOINT")!));

    public async Task ProcessarAsync(SQSEvent evento)
    {
        foreach (var msg in evento.Records)
        {
            var comando = JsonSerializer.Deserialize<ComandoEscrita>(msg.Body)!;

            // A validacao de REGRA acontece aqui, nao na API. Se falhar, o
            // item nunca chega ao DynamoDB — e o marcador que a Escrita ja
            // gravou continua de pe ate o TTL expirar, mostrando ao autor um
            // valor que o sistema decidiu recusar. Por isso apagamos.
            if (!RegraDeStatusValida(comando.Status))
            {
                var db = Redis.Value.GetDatabase();
                await db.KeyDeleteAsync($"rw:{comando.AutorId}:{comando.PedidoId}");
                continue; // mensagem processada; a rejeicao e o resultado
            }

            // Escrita idempotente por natureza: PutItem com o mesmo
            // pedidoId sobrescreve. Se o SQS entregar a mesma mensagem duas
            // vezes (at-least-once), o efeito final e o mesmo.
            await Dynamo.PutItemAsync(new PutItemRequest
            {
                TableName = "Pedidos",
                Item = new()
                {
                    ["pedidoId"]     = new AttributeValue(comando.PedidoId),
                    ["autorId"]      = new AttributeValue(comando.AutorId),
                    ["status"]       = new AttributeValue(comando.Status),
                    ["atualizadoEm"] = new AttributeValue(DateTimeOffset.UtcNow.ToString("O")),
                },
            });
        }
    }

    private static bool RegraDeStatusValida(string status) =>
        status is "pendente" or "confirmado" or "cancelado";
}

public record ComandoEscrita(string PedidoId, string AutorId, string Status, DateTimeOffset EnviadoEm);

public class InvalidadorFunction
{
    private static readonly Lazy<ConnectionMultiplexer> Redis = new(() =>
        ConnectionMultiplexer.Connect(Environment.GetEnvironmentVariable("REDIS_ENDPOINT")!));

    public async Task InvalidarAsync(DynamoDBEvent evento)
    {
        var db = Redis.Value.GetDatabase();

        foreach (var registro in evento.Records)
        {
            if (registro.EventName is not ("INSERT" or "MODIFY")) continue;

            var pedidoId = registro.Dynamodb.Keys["pedidoId"].S;

            // DELETE, nunca SET. A fila que carrega este evento e a mesma
            // maquina de Streams->Lambda, sujeita a nova tentativa e a
            // reprocessamento: se dois eventos do mesmo item forem
            // processados fora de ordem, escrever o "novo valor" poderia
            // deixar no cache um dado MAIS VELHO que o atual. Apagar e
            // idempotente — nao importa a ordem, o resultado final e sempre
            // "sem chave", e a proxima leitura busca a verdade no DynamoDB.
            await db.KeyDeleteAsync($"item:{pedidoId}");
        }
    }
}

#!/usr/bin/env bash
# medir-divergencia-autor.sh — a prova do defeito, ANTES da correção
# Roda contra o desenho MÍNIMO (sem marcador). Escreve, e imediatamente tenta
# ler como o MESMO autor, repetidas vezes, contando quantas leituras não
# batem com o que acabou de ser escrito.
set -euo pipefail

BASE_URL="$(terraform output -raw url_api)"
TOKEN="$(obter-token-teste.sh usr-7781)"  # helper local, fora do escopo
PEDIDO="ped-$(date +%s)"

curl -s -X POST "$BASE_URL/pedidos/$PEDIDO" \
  -H "Authorization: Bearer $TOKEN" -d '{"status":"confirmado"}' > /dev/null

divergentes=0; total=50
for i in $(seq 1 $total); do
  resp=$(curl -s "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN")
  echo "$resp" | grep -q '"status":"confirmado"' || divergentes=$((divergentes+1))
done
echo "$divergentes de $total leituras do PRÓPRIO autor não viram a escrita"
# Medido no ambiente de exemplo, com a fila em backlog normal: 21 de 50
# (42%). O número varia com o backlog da fila no instante do teste — meça
# o seu, não copie este.

#!/usr/bin/env bash
# provas.sh — quatro medições contra o desenho de PRODUÇÃO (com marcador)

BASE_URL="$(terraform output -raw url_api)"
TOKEN_A="$(obter-token-teste.sh usr-7781)"
TOKEN_B="$(obter-token-teste.sh usr-4402)"  # um SEGUNDO usuário, que não escreveu nada

# ── Prova 1: divergência do autor, com o marcador ativo ──────────────────────
PEDIDO="ped-$(date +%s)"
curl -s -X POST "$BASE_URL/pedidos/$PEDIDO" \
  -H "Authorization: Bearer $TOKEN_A" -d '{"status":"confirmado"}' > /dev/null
divergentes=0
for i in $(seq 1 50); do
  resp=$(curl -s "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN_A")
  echo "$resp" | grep -q '"Status":"confirmado"' || divergentes=$((divergentes+1))
done
echo "Prova 1 — divergência do autor: $divergentes de 50 (esperado: 0)"

# ── Prova 2: outros usuários continuam eventualmente consistentes ───────────
# Isto NÃO é um bug remanescente: é a decisão central do módulo funcionando.
resp_b=$(curl -s "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN_B")
echo "Prova 2 — leitura de outro usuário logo após a escrita: $resp_b"
echo "  (esperado: pode mostrar 'pendente' por alguns segundos — é o design, não a falha)"

# ── Prova 3: a métrica publicada confirma a origem de cada resposta ─────────
aws cloudwatch get-metric-statistics --namespace Consistencia/Leitura \
  --metric-name OrigemDaResposta --dimensions Name=Origem,Value=MarcadorAutor \
  --start-time "$(date -u -d '5 min ago' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 300 --statistics Sum --output text
echo "Prova 3 — esperado: Sum próximo de 50 (as leituras do autor na prova 1)"

# ── Prova 4: a janela real de invalidação, para calibrar o TTL do marcador ──
# Compara o instante do PutItem (atualizadoEm) com o instante do DELETE nos
# logs do invalidador. O TTL do marcador tem de ser MAIOR que este p99.
aws logs filter-log-events --log-group-name /aws/lambda/ffv-lab-invalidador \
  --filter-pattern "apagou" --query 'events[].message' --output text
echo "Prova 4 — o maior intervalo observado é o piso do TTL do marcador"

# ── Prova 5: DELETE é idempotente diante de eventos fora de ordem ───────────
# Duas escritas rápidas no mesmo item; a leitura final (após o marcador
# expirar) tem de bater com o ÚLTIMO estado gravado no DynamoDB, não importa
# a ordem em que os dois eventos do Streams chegaram ao invalidador.
curl -s -X POST "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN_A" \
  -d '{"status":"confirmado"}' > /dev/null &
curl -s -X POST "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN_A" \
  -d '{"status":"cancelado"}' > /dev/null &
wait; sleep 12  # aguarda o marcador expirar (TTL=10s) e a invalidação assentar
final=$(curl -s "$BASE_URL/pedidos/$PEDIDO" -H "Authorization: Bearer $TOKEN_B")
verdade=$(aws dynamodb get-item --table-name ffv-lab-pedidos \
  --key "{\"pedidoId\":{\"S\":\"$PEDIDO\"}}" --query 'Item.status.S' --output text)
echo "Prova 5 — cache: $final | DynamoDB: $verdade (têm de bater)"

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

# 2. FILA DLQ: mensagens retidas por ate 14 dias sobrevivem se a fila
#    principal foi apagada antes da DLQ, ou se o destroy foi interrompido.
aws sqs list-queues --queue-name-prefix ffv-lab-comandos --output table

# 3. GRUPOS DE LOGS das quatro funcoes: tem retencao propria e nao
#    pertencem ao ciclo de vida do Lambda que os escreveu.
for fn in escrita leitura worker invalidador; do
  aws logs delete-log-group --log-group-name "/aws/lambda/ffv-lab-${fn}" 2>/dev/null || true
done

# 4. METRICAS CUSTOMIZADAS nao sao apagaveis por comando, mas continuam
#    aparecendo no CloudWatch (sem cobrar) ate expirar por retencao padrao.
#    Confirme que nenhum alarme criado a mao ficou orfao.
aws cloudwatch describe-alarms --alarm-name-prefix ffv-lab --output table

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