Lab 16 — DynamoDB para quem vem do SQL

# Rode contra a tabela Pedidos (minima), buscando os pendentes de UMA loja.
aws dynamodb scan --table-name ffv-lab-pedidos \
  --filter-expression "loja_id = :l AND #s = :p" \
  --expression-attribute-names '{"#s":"status"}' \
  --expression-attribute-values '{":l":{"S":"a10ecb4e-..."},":p":{"S":"PENDENTE"}}' \
  --return-consumed-capacity TOTAL \
  --query '{lidos: ScannedCount, devolvidos: Count, RCU: ConsumedCapacity.CapacityUnits}'
# Na Cadencia, com a tabela cheia: ScannedCount fecha perto do total de itens da
# tabela inteira; Count fica na casa de dezenas. O RCU cobra pelo primeiro numero.

// O cabecalho do pedido, como ele existe na tabela ENQUANTO pendente.
// Repare que ha quatro "vistas" do MESMO item: PK/SK, GSI1, GSI2, GSI3.
{
  "PK": "PEDIDO#b7a1f0b0-2c44-4e9a-9d31-000000009182",
  "SK": "METADADOS",
  "GSI1PK": "CLIENTE#3f2a1c10-8e3a-4a11-9c2e-000000000001",
  "GSI1SK": "PEDIDO#2026-08-07T14:03:21Z#b7a1f0b0-2c44-4e9a-9d31-000000009182",
  "GSI2PK": "LOJA#a10ecb4e-6f21-4a02-8b9d-000000000512",
  "GSI2SK": "2026-08-07T14:03:21Z",
  "GSI3PK": "LOJA#a10ecb4e-6f21-4a02-8b9d-000000000512",
  "GSI3SK": "2026-08-07T14:03:21Z",
  "total": 187.90,
  "status": "PENDENTE",
  "criado_em": "2026-08-07T14:03:21Z",
  "itens_count": 3
}

// Depois de MarcarComoSeparadoAsync: GSI3PK e GSI3SK foram REMOVIDOS.
// O item continua existindo na chave base e no GSI1/GSI2 — so sumiu do GSI3.
{
  "PK": "PEDIDO#b7a1f0b0-2c44-4e9a-9d31-000000009182",
  "SK": "METADADOS",
  "GSI1PK": "CLIENTE#3f2a1c10-8e3a-4a11-9c2e-000000000001",
  "GSI1SK": "PEDIDO#2026-08-07T14:03:21Z#b7a1f0b0-2c44-4e9a-9d31-000000009182",
  "GSI2PK": "LOJA#a10ecb4e-6f21-4a02-8b9d-000000000512",
  "GSI2SK": "2026-08-07T14:03:21Z",
  "total": 187.90,
  "status": "SEPARADO",
  "criado_em": "2026-08-07T14:03:21Z",
  "itens_count": 3
}

# dynamodb.tf — a tabela unica e os tres indices, cada um por uma pergunta

resource "aws_dynamodb_table" "pedidos" {
  name         = "${var.projeto}-pedidos"
  billing_mode = "PAY_PER_REQUEST" # sob demanda: a equipe de duas pessoas nao
                                    # tem tempo para dimensionar RCU/WCU manualmente,
                                    # e o pico de campanha e 20x em rajada

  hash_key  = "PK"
  range_key = "SK"

  # So se declara ATRIBUTO aqui para o que e chave — de tabela ou de indice.
  # Os demais campos do item (total, status, sku, quantidade...) NAO entram:
  # DynamoDB nao tem schema fixo para atributo que nao e chave.
  attribute {
    name = "PK"
    type = "S"
  }
  attribute {
    name = "SK"
    type = "S"
  }
  attribute {
    name = "GSI1PK"
    type = "S"
  }
  attribute {
    name = "GSI1SK"
    type = "S"
  }
  attribute {
    name = "GSI2PK"
    type = "S"
  }
  attribute {
    name = "GSI2SK"
    type = "S"
  }
  attribute {
    name = "GSI3PK"
    type = "S"
  }
  attribute {
    name = "GSI3SK"
    type = "S"
  }

  # GSI1 — historico por cliente. Mesma forma de chave que o L14 usava na base;
  # aqui e indice porque a base foi reivindicada pela coleção de itens do pedido.
  global_secondary_index {
    name            = "GSI1"
    hash_key        = "GSI1PK"
    range_key       = "GSI1SK"
    projection_type = "INCLUDE"
    non_key_attributes = ["total", "status", "criado_em"]
  }

  # GSI2 — pedidos de uma loja num intervalo. SK e o timestamp ISO: BETWEEN
  # funciona porque a ordem lexicografica de ISO 8601 coincide com a cronologica.
  global_secondary_index {
    name            = "GSI2"
    hash_key        = "GSI2PK"
    range_key       = "GSI2SK"
    projection_type = "ALL" # o painel da loja le o pedido inteiro, sem segunda consulta
  }

  # GSI3 — fila de separacao, ESPARSO por desenho. So o pedido pendente carrega
  # GSI3PK/GSI3SK; a aplicacao os REMOVE ao marcar como separado, e o item some
  # do indice sozinho. Sem isto, a fila cresceria para sempre.
  global_secondary_index {
    name            = "GSI3"
    hash_key        = "GSI3PK"
    range_key       = "GSI3SK"
    projection_type = "KEYS_ONLY" # a fila so precisa do PEDIDO#<id> para buscar o detalhe depois
  }

  point_in_time_recovery {
    enabled = true
  }

  server_side_encryption {
    enabled     = true
    kms_key_arn = aws_kms_key.app.arn
  }

  # Ha um teto de indices secundarios globais por tabela — confira o valor
  # atual em Service Quotas antes de planejar um quinto ou sexto GSI.
  tags = {
    Projeto = var.projeto
  }
}

# A task LE e ESCREVE, mas nunca faz Scan em rota de producao. Nao conceder a
# acao e o guardrail que torna o antipadrao do desenho minimo detectavel em
# tempo de deploy — nao em incidente.
data "aws_iam_policy_document" "app_dynamodb" {
  statement {
    effect = "Allow"
    actions = [
      "dynamodb:GetItem",
      "dynamodb:Query",
      "dynamodb:PutItem",
      "dynamodb:UpdateItem",
      "dynamodb:TransactWriteItems",
    ]
    resources = [
      aws_dynamodb_table.pedidos.arn,
      "${aws_dynamodb_table.pedidos.arn}/index/*",
    ]
  }
}

# Endpoint de GATEWAY, nao de interface: DynamoDB e S3 sao os dois servicos que
# usam este tipo. Entra na tabela de rotas da sub-rede, sem ENI e sem cobranca
# por hora — diferente do endpoint de interface que Secrets Manager usa.
resource "aws_vpc_endpoint" "dynamodb" {
  vpc_id            = aws_vpc.principal.id
  service_name      = "com.amazonaws.${var.regiao}.dynamodb"
  vpc_endpoint_type = "Gateway"
  route_table_ids   = aws_route_table.privada[*].id
}

output "tabela_pedidos" {
  value       = aws_dynamodb_table.pedidos.name
  description = "nome da tabela unica; os tres GSIs vivem dentro dela"
}

// PedidoRepository.cs — quatro perguntas, quatro caminhos, nenhum Scan

public sealed class PedidoRepository
{
    private readonly IAmazonDynamoDB _ddb;
    private const string Tabela = "cadencia-pedidos";

    public PedidoRepository(IAmazonDynamoDB ddb) => _ddb = ddb;

    // ── Escrita: cabecalho e itens na MESMA transacao, na MESMA particao ──────
    public async Task CriarPedidoAsync(Pedido pedido, CancellationToken ct)
    {
        var itens = new List<TransactWriteItem>
        {
            new()
            {
                Put = new Put
                {
                    TableName = Tabela,
                    // Condicao impede recriar um pedido com o mesmo codigo —
                    // e e a unica garantia de idempotencia deste caminho.
                    ConditionExpression = "attribute_not_exists(PK)",
                    Item = new Dictionary<string, AttributeValue>
                    {
                        ["PK"] = new($"PEDIDO#{pedido.Id}"),
                        ["SK"] = new("METADADOS"),
                        // GSI1: historico por cliente — mesma forma do L14.
                        ["GSI1PK"] = new($"CLIENTE#{pedido.ClienteId}"),
                        ["GSI1SK"] = new($"PEDIDO#{pedido.CriadoEm:O}#{pedido.Id}"),
                        // GSI2: pedidos da loja, por data.
                        ["GSI2PK"] = new($"LOJA#{pedido.LojaId}"),
                        ["GSI2SK"] = new(pedido.CriadoEm.ToString("O")),
                        // GSI3: fila de pendentes — ESPARSO. So existe aqui
                        // porque o pedido NASCE pendente. Some quando o status muda.
                        ["GSI3PK"] = new($"LOJA#{pedido.LojaId}"),
                        ["GSI3SK"] = new(pedido.CriadoEm.ToString("O")),
                        ["total"] = new() { N = pedido.Total.ToString(CultureInfo.InvariantCulture) },
                        ["status"] = new("PENDENTE"),
                        ["criado_em"] = new(pedido.CriadoEm.ToString("O")),
                        ["itens_count"] = new() { N = pedido.Itens.Count.ToString() },
                    },
                },
            },
        };

        itens.AddRange(pedido.Itens.Select((item, i) => new TransactWriteItem
        {
            Put = new Put
            {
                TableName = Tabela,
                Item = new Dictionary<string, AttributeValue>
                {
                    ["PK"] = new($"PEDIDO#{pedido.Id}"),
                    ["SK"] = new($"ITEM#{i:D3}"),
                    ["sku"] = new(item.Sku),
                    ["quantidade"] = new() { N = item.Quantidade.ToString() },
                    ["preco_unitario"] = new() { N = item.PrecoUnitario.ToString(CultureInfo.InvariantCulture) },
                },
            },
        }));

        // Uma transacao so: ou o cabecalho e TODOS os itens gravam, ou nada
        // grava. TransactWriteItems custa o dobro da unidade de escrita normal
        // por item — o preco de garantir que nao existe pedido sem item.
        await _ddb.TransactWriteItemsAsync(new TransactWriteItemsRequest { TransactItems = itens }, ct);
    }

    // ── AP2: detalhe do pedido + itens, por codigo — chave base, um round trip ─
    public async Task<PedidoDetalhe?> ObterDetalheAsync(string pedidoId, CancellationToken ct)
    {
        var resp = await _ddb.QueryAsync(new QueryRequest
        {
            TableName = Tabela,
            KeyConditionExpression = "PK = :pk",
            ExpressionAttributeValues = new() { [":pk"] = new($"PEDIDO#{pedidoId}") },
        }, ct);

        if (resp.Items.Count == 0) return null;

        // O cabecalho e SK=METADADOS; os itens sao os demais. Uma Query so
        // trouxe os dois — nao ha segunda chamada para "buscar os itens".
        var cabecalho = resp.Items.First(i => i["SK"].S == "METADADOS");
        var itens = resp.Items.Where(i => i["SK"].S.StartsWith("ITEM#"));
        return PedidoDetalhe.De(cabecalho, itens);
    }

    // ── AP1: historico por cliente, paginado — GSI1 ────────────────────────────
    public async Task<PaginaDePedidos> ObterHistoricoAsync(
        string clienteId, string? cursor, CancellationToken ct)
    {
        var resp = await _ddb.QueryAsync(new QueryRequest
        {
            TableName = Tabela,
            IndexName = "GSI1",
            KeyConditionExpression = "GSI1PK = :pk",
            ExpressionAttributeValues = new() { [":pk"] = new($"CLIENTE#{clienteId}") },
            ScanIndexForward = false, // mais recente primeiro
            Limit = 20,
            ExclusiveStartKey = Cursor.Decodificar(cursor),
        }, ct);

        return PaginaDePedidos.De(resp.Items, resp.LastEvaluatedKey);
    }

    // ── AP3: pedidos da loja num intervalo — GSI2, SK entre datas ──────────────
    public async Task<IReadOnlyList<Pedido>> ObterPorLojaEIntervaloAsync(
        string lojaId, DateTimeOffset inicio, DateTimeOffset fim, CancellationToken ct)
    {
        var resp = await _ddb.QueryAsync(new QueryRequest
        {
            TableName = Tabela,
            IndexName = "GSI2",
            KeyConditionExpression = "GSI2PK = :pk AND GSI2SK BETWEEN :ini AND :fim",
            ExpressionAttributeValues = new()
            {
                [":pk"] = new($"LOJA#{lojaId}"),
                [":ini"] = new(inicio.ToString("O")),
                [":fim"] = new(fim.ToString("O")),
            },
        }, ct);

        return resp.Items.Select(Pedido.De).ToList();
    }

    // ── AP4: fila de pendentes da loja — GSI3, esparso, sem FilterExpression ───
    public async Task<IReadOnlyList<string>> ObterFilaPendenteAsync(string lojaId, CancellationToken ct)
    {
        var resp = await _ddb.QueryAsync(new QueryRequest
        {
            TableName = Tabela,
            IndexName = "GSI3",
            KeyConditionExpression = "GSI3PK = :pk",
            ExpressionAttributeValues = new() { [":pk"] = new($"LOJA#{lojaId}") },
        }, ct);

        // KEYS_ONLY: so o PK volta. Quem chama busca o detalhe pela chave base
        // se precisar dos itens — a fila existe para LISTAR, nao para exibir tudo.
        return resp.Items.Select(i => i["PK"].S.Replace("PEDIDO#", "")).ToList();
    }

    // ── Transicao de status: remove as chaves do GSI3, e o item some da fila ──
    public async Task MarcarComoSeparadoAsync(string pedidoId, CancellationToken ct)
    {
        await _ddb.UpdateItemAsync(new UpdateItemRequest
        {
            TableName = Tabela,
            Key = new()
            {
                ["PK"] = new($"PEDIDO#{pedidoId}"),
                ["SK"] = new("METADADOS"),
            },
            // REMOVE, nao SET status="SEPARADO" sozinho. O indice filtra por
            // PRESENCA de atributo, nao por valor — mudar so o status deixa o
            // pedido separado aparecendo na fila para sempre.
            UpdateExpression = "SET #s = :novo REMOVE GSI3PK, GSI3SK",
            ExpressionAttributeNames = new() { ["#s"] = "status" },
            ExpressionAttributeValues = new() { [":novo"] = new("SEPARADO") },
            ConditionExpression = "attribute_exists(PK)",
        }, ct);
    }
}

#!/usr/bin/env bash
# medir-scan-vs-query.sh — a mesma pergunta, dois caminhos, RCU real da conta
set -euo pipefail

LOJA="a10ecb4e-6f21-4a02-8b9d-000000000512"
HOJE="2026-08-07"

echo "== Scan na tabela Pedidos (desenho minimo), filtrando por loja e status =="
aws dynamodb scan \
  --table-name ffv-lab-pedidos \
  --filter-expression "loja_id = :l AND #s = :p" \
  --expression-attribute-names '{"#s":"status"}' \
  --expression-attribute-values "{\":l\":{\"S\":\"$LOJA\"},\":p\":{\"S\":\"PENDENTE\"}}" \
  --return-consumed-capacity TOTAL \
  --query '{lidos: ScannedCount, devolvidos: Count, RCU: ConsumedCapacity.CapacityUnits}'
# Esperado: ScannedCount fecha perto do total de itens da tabela; Count e uma
# fracao pequena disso. RCU cobra pelo primeiro numero, nao pelo segundo.

echo "== Query no GSI3 (desenho de producao), mesma pergunta =="
aws dynamodb query \
  --table-name ffv-lab-pedidos-cadencia \
  --index-name GSI3 \
  --key-condition-expression "GSI3PK = :pk" \
  --expression-attribute-values "{\":pk\":{\"S\":\"LOJA#$LOJA\"}}" \
  --return-consumed-capacity TOTAL \
  --query '{lidos: ScannedCount, devolvidos: Count, RCU: ConsumedCapacity.CapacityUnits}'
# Esperado: ScannedCount = Count (a Query so le o que bate com a chave), e RCU
# ordens de grandeza menor que o Scan acima — para a MESMA resposta.

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

TABELA=ffv-lab-pedidos-cadencia

# ── Prova 1: as quatro Query devolvem o mesmo dado que o Scan devolvia ───────
CODIGO=$(aws dynamodb scan --table-name $TABELA --index-name GSI1 --limit 1 \
  --query 'Items[0].PK.S' --output text | sed 's/PEDIDO#//')
aws dynamodb query --table-name $TABELA \
  --key-condition-expression "PK = :pk" \
  --expression-attribute-values "{\":pk\":{\"S\":\"PEDIDO#$CODIGO\"}}" \
  --query 'Items[].SK.S'
# Esperado: METADADOS + um ou mais ITEM#NNN — cabecalho e itens na mesma resposta.

# ── Prova 2: nenhuma chamada de producao usa Scan ────────────────────────────
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=Scan \
  --start-time "$(date -u -d '1 hour ago' +%FT%TZ)" \
  --query 'Events[].Username'
# Esperado: vazio, ou so a identidade de ferramenta de migracao/backfill — nunca
# a role da task da API.

# ── Prova 3: o GSI3 e realmente esparso ──────────────────────────────────────
TOTAL_TABELA=$(aws dynamodb describe-table --table-name $TABELA \
  --query 'Table.ItemCount' --output text)
TOTAL_GSI3=$(aws dynamodb describe-table --table-name $TABELA \
  --query "Table.GlobalSecondaryIndexes[?IndexName=='GSI3'].ItemCount | [0]" --output text)
echo "tabela: $TOTAL_TABELA itens · GSI3: $TOTAL_GSI3 itens"
# Esperado: GSI3 bem menor que a tabela, e proporcional a quantos pedidos estao
# HOJE pendentes — nao ao total historico. ItemCount do describe-table e
# atualizado a cada ~6h; para o numero exato agora, conte via Query.

# ── Prova 4: marcar como separado tira o pedido da fila, sem apagar nada ─────
aws dynamodb query --table-name $TABELA --index-name GSI3 \
  --key-condition-expression "GSI3PK = :pk" \
  --expression-attribute-values "{\":pk\":{\"S\":\"LOJA#$LOJA_TESTE\"}}" \
  --query 'length(Items)'
# anote o numero, rode MarcarComoSeparadoAsync num pedido dessa loja, repita:
aws dynamodb query --table-name $TABELA --index-name GSI3 \
  --key-condition-expression "GSI3PK = :pk" \
  --expression-attribute-values "{\":pk\":{\"S\":\"LOJA#$LOJA_TESTE\"}}" \
  --query 'length(Items)'
# Esperado: o segundo numero e o primeiro menos um. O pedido continua existindo
# (prova 1 ainda o encontra pela chave base) — so saiu do indice esparso.

# ── Prova 5: a diferenca de RCU entre Scan e Query, na sua conta ────────────
# Rode medir-scan-vs-query.sh e compare ConsumedCapacity.CapacityUnits dos dois.
# Esperado: a Query fica ordens de grandeza abaixo do Scan para o mesmo resultado.

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

# 2. TABELA DYNAMODB: o destroy remove a tabela E os GSIs junto, sem
#    confirmacao adicional. Confirme que era mesmo isso que voce queria antes
#    de rodar o passo 1 — nao ha lixeira.
aws dynamodb describe-table --table-name ffv-lab-pedidos-cadencia 2>/dev/null \
  && echo "AINDA EXISTE" || echo "removida"

# 3. BACKUPS SOB DEMANDA: point-in-time recovery nao deixa arquivo separado,
#    mas um backup MANUAL criado a parte sobrevive ao destroy da tabela.
aws dynamodb list-backups --table-name ffv-lab-pedidos-cadencia \
  --query "BackupSummaries[].BackupArn" --output table

# 4. ENDPOINT DE VPC: nao cobra por hora (e gateway), mas fica na tabela de
#    rotas se nao for removido pelo Terraform.
aws ec2 describe-vpc-endpoints \
  --filters Name=service-name,Values=com.amazonaws.us-east-1.dynamodb \
  --query "VpcEndpoints[].VpcEndpointId" --output table

# 5. E o que veio do L01/L07/L14 e continua cobrando por hora: ALB, RDS/Aurora,
#    NAT Gateway e o Elastic IP dele. Se voce nao vai seguir para o L15 ou L19,
#    rode a limpeza deles tambem.

# 6. Prova final: nada com nome do projeto de pe.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=ffv-lab --output table