Lab 13 — Cache que salva o banco, e a invalidação que quebra tudo

#!/usr/bin/env bash
# medir-p95.sh — mede o p95 do endpoint de catalogo, antes e depois do cache
set -euo pipefail

URL="https://$(terraform output -raw dominio)/api/catalogo/produtos/COD-58231"

# hey: 50 conexoes simultaneas por 30 s, contra UM sku quente. O numero que
# sai daqui e a linha de base — nada de "parece mais rapido".
hey -z 30s -c 50 "$URL" | tee resultado.txt

grep -E "50%|90%|95%|99%" resultado.txt
# Na Cadencia, sem cache: p95 de 340 ms (bate na replica a cada chamada).
# Com cache aquecido: p95 de 4 ms — a diferenca e o que a seção de custo
# compara contra subir a classe da replica para o mesmo ganho.

{
  "sku": "COD-58231",
  "precoCentavos": 129900,
  "estoqueAlerta": 12,
  "versao": 47,
  "cacheadoEm": "2026-08-07T18:03:11Z"
}

# elasticache.tf — o grupo de replicacao Multi-AZ, e por que nao e um no so

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

resource "aws_elasticache_parameter_group" "cache" {
  name   = "${var.projeto}-redis7"
  family = "redis7"

  # O padrao da AWS ja e volatile-lru: sob pressao de memoria, so expira quem
  # TEM ttl. Chave sem ttl nunca sai por essa politica — e e por isso que toda
  # chave deste laboratorio nasce com ttl explicito, inclusive a de trava.
  parameter {
    name  = "maxmemory-policy"
    value = "volatile-lru"
  }
}

resource "aws_elasticache_replication_group" "cache" {
  replication_group_id      = "${var.projeto}-catalogo"
  description                = "Cache de catalogo: cache-aside com invalidacao pela escrita"
  engine                     = "redis"
  engine_version              = "7.1"
  node_type                   = "cache.r7g.large"

  # 1 primario + 1 replica: e o minimo que autoriza failover automatico. Um
  # unico no (num_cache_clusters = 1) e o desenho MINIMO deste laboratorio, e
  # o motivo de nao ir para producao esta na secao de decisoes.
  num_cache_clusters          = 2
  automatic_failover_enabled  = true
  multi_az_enabled            = true

  parameter_group_name        = aws_elasticache_parameter_group.cache.name
  subnet_group_name           = aws_elasticache_subnet_group.cache.name
  security_group_ids          = [aws_security_group.cache.id]

  # AUTH exige criptografia em transito habilitada; sem os dois juntos o
  # provider recusa o apply. E o par que fecha a exposicao da secao de
  # seguranca.
  at_rest_encryption_enabled  = true
  transit_encryption_enabled  = true
  auth_token                  = data.aws_secretsmanager_secret_version.cache_auth.secret_string

  # Snapshot aqui NAO e backup de dado de negocio — o RDS continua sendo a
  # unica fonte de verdade. Ele so acelera o reaquecimento apos substituicao
  # de no, e por isso um dia de retencao basta.
  snapshot_retention_limit    = 1

  tags = { Projeto = var.projeto }
}

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

  # So a task fala com o cache. Nao ha 0.0.0.0/0 nem faixa de sub-rede: a
  # origem permitida e o security group DA TASK, por referencia.
  ingress {
    from_port       = 6379
    to_port          = 6379
    protocol         = "tcp"
    security_groups  = [aws_security_group.task.id]
  }
}

# Leitura do segredo com recurso especifico — nao ha "*" nesta politica.
data "aws_iam_policy_document" "ler_segredo_cache" {
  statement {
    effect    = "Allow"
    actions   = ["secretsmanager:GetSecretValue"]
    resources = [aws_secretsmanager_secret.cache_auth.arn]
  }
}

output "endpoint_primario_cache" {
  value       = aws_elasticache_replication_group.cache.primary_endpoint_address
  description = "DNS que sempre resolve para o no primario — imune a failover"
}

// ProdutoCacheService.cs — cache-aside com trava de reconstrucao e invalidacao pela escrita

public sealed class ProdutoCacheService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly IProdutoRepository _repo; // consulta a REPLICA do L07, nao o primario
    private static readonly Random _jitter = Random.Shared;

    private const int TtlBaseSegundos = 30;       // o numero que o negocio aceitou tolerar
    private const int JitterMaximoSegundos = 10;  // espalha a expiracao das chaves quentes
    private const int TravaTimeoutSegundos = 5;   // teto: mesmo se o titular cair, a trava solta

    public ProdutoCacheService(IConnectionMultiplexer redis, IProdutoRepository repo)
    {
        _redis = redis;
        _repo = repo;
    }

    public async Task<ProdutoCacheDto?> ObterAsync(string sku)
    {
        var db = _redis.GetDatabase();

        // A chave NAO leva loja: o preco e o mesmo para as 1.200 lojas, e
        // incluir a loja fragmentaria um cache de 500 chaves em ate 600 mil.
        var chave = $"produto:{sku}";

        var cacheado = await db.StringGetAsync(chave);
        if (cacheado.HasValue)
            return JsonSerializer.Deserialize<ProdutoCacheDto>(cacheado!);

        // MISS. So uma requisicao reconstroi; as outras aguardam um instante
        // ou seguem direto ao banco SEM popular — a trava evita a debandada,
        // nao o miss em si, que e inevitavel na primeira leitura de cada chave.
        var chaveTrava = $"trava:{chave}";
        var obteveTrava = await db.StringSetAsync(
            chaveTrava, Environment.MachineName,
            TimeSpan.FromSeconds(TravaTimeoutSegundos), When.NotExists);

        if (!obteveTrava)
        {
            await Task.Delay(150); // quem tem a trava provavelmente ja publicou
            var segundaTentativa = await db.StringGetAsync(chave);
            if (segundaTentativa.HasValue)
                return JsonSerializer.Deserialize<ProdutoCacheDto>(segundaTentativa!);

            // Ainda sem cache: consulta a replica SEM popular, para nao
            // competir por escrita no Redis com quem tem a trava.
            return await ConsultarReplicaAsync(sku, populaCache: false);
        }

        try
        {
            return await ConsultarReplicaAsync(sku, populaCache: true);
        }
        finally
        {
            await db.KeyDeleteAsync(chaveTrava);
        }
    }

    private async Task<ProdutoCacheDto?> ConsultarReplicaAsync(string sku, bool populaCache)
    {
        var produto = await _repo.BuscarPorSkuAsync(sku); // a mesma consulta indexada do L07
        if (produto is null) return null;

        if (populaCache)
        {
            var ttl = TimeSpan.FromSeconds(TtlBaseSegundos + _jitter.Next(0, JitterMaximoSegundos));
            var db = _redis.GetDatabase();
            await db.StringSetAsync($"produto:{sku}", JsonSerializer.Serialize(produto), ttl);
        }

        return produto;
    }

    public async Task InvalidarAposEscritaAsync(string sku)
    {
        // Chamado SO depois do commit no primario ser confirmado. DEL, nunca
        // SET com o valor novo: gravar aqui arriscaria formato diferente do
        // que a leitura padrao produz, e o proximo GET reconstroi certo.
        var db = _redis.GetDatabase();
        await db.KeyDeleteAsync($"produto:{sku}");
    }
}

// PrecoService.cs — a ordem que importa: commit primeiro, invalidacao depois

public sealed class PrecoService
{
    private readonly AppDb _db;
    private readonly ProdutoCacheService _cache;

    public PrecoService(AppDb db, ProdutoCacheService cache)
    {
        _db = db;
        _cache = cache;
    }

    public async Task AtualizarPrecoAsync(string sku, decimal novoPreco)
    {
        await using var tx = await _db.Database.BeginTransactionAsync();

        var produto = await _db.Produtos.SingleAsync(p => p.Sku == sku);
        produto.PrecoCentavos = (int)(novoPreco * 100);
        produto.Versao++;

        await _db.SaveChangesAsync();
        await tx.CommitAsync(); // so invalida DEPOIS do commit confirmado no primario

        // Inverter esta ordem — invalidar antes do commit — abriria uma
        // janela em que o cache ja esta vazio mas o dado antigo ainda e o
        // UNICO que existe: pior do que nao ter invalidado nada.
        await _cache.InvalidarAposEscritaAsync(sku);
    }
}

# Este laboratorio reaproveita a imagem do L03. A unica dependencia nova e o
# cliente StackExchange.Redis, que entra no .csproj:
#
#   <PackageReference Include="StackExchange.Redis" Version="2.8.16" />
#
# Nao ha estagio de build novo nem porta nova exposta.

#!/usr/bin/env bash
# provocar-debandada.sh — reproduz a debandada de proposito, no desenho MINIMO
set -euo pipefail

# 1. Aquece as 500 chaves quentes de uma vez, TODAS com o MESMO ttl fixo —
#    e exatamente o que o desenho minimo faz no deploy.
for sku in $(cat skus-quentes.txt); do
  curl -s "https://$(terraform output -raw dominio)/api/catalogo/produtos/$sku" >/dev/null
done
echo "500 chaves aquecidas juntas, ttl fixo de 30s"

# 2. Sustenta carga por mais de 30 s. Observe o CloudWatch da REPLICA durante
#    a janela em torno do segundo 30: DatabaseConnections deve saltar.
hey -z 90s -c 100 -m GET \
  $(sed 's|^|https://'"$(terraform output -raw dominio)"'/api/catalogo/produtos/|' skus-quentes.txt) \
  2>&1 | tail -5

aws cloudwatch get-metric-statistics \
  --namespace AWS/RDS --metric-name DatabaseConnections \
  --dimensions Name=DBInstanceIdentifier,Value=ffv-lab-replica \
  --start-time "$(date -u -d '-2 min' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 10 --statistics Maximum --output table
# Esperado: um pico isolado por volta do segundo 30, e nao antes disso —
# a assinatura de uma debandada sincronizada, nao de carga organica.

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

PROJETO=ffv-lab; SKU=COD-58231

# ── Prova 1: p95 antes e depois do cache aquecido ────────────────────────────
# Rode medir-p95.sh com o cache frio (recem-implantado) e de novo com o
# cache quente. Esperado: p95 cai de ~340 ms para a casa de um digito.

# ── Prova 2: a debandada acontece no MINIMO e some na PRODUCAO ───────────────
# provocar-debandada.sh no desenho minimo mostra pico isolado de
# DatabaseConnections no ciclo do ttl. O MESMO script contra o desenho de
# producao (ttl com jitter + trava) nao deve mostrar pico correlacionado —
# a leitura de DatabaseConnections deve ficar estavel durante a janela.

# ── Prova 3: a trava reduz N consultas identicas para 1 ──────────────────────
psql "$DATABASE_URL_REPLICA" -c \
  "SELECT calls FROM pg_stat_statements WHERE query LIKE '%produtos WHERE sku%'"
# Anote o valor de 'calls'. Provoque um miss simultaneo de 50 requisicoes na
# MESMA chave (ab -n 50 -c 50). Sem trava, calls sobe por volta de 50; com
# trava, sobe por volta de 1 — as outras 49 aguardaram ou pularam a populacao.

# ── Prova 4: a invalidacao vale no proximo GET, nao no proximo TTL ───────────
curl -s "https://.../api/catalogo/produtos/$SKU" | jq .preco_centavos   # antes
curl -s -X PUT "https://.../api/catalogo/produtos/$SKU/preco" \
  -d '{"precoCentavos": 99900}'                                        # muda
curl -s "https://.../api/catalogo/produtos/$SKU" | jq .preco_centavos   # depois
# Esperado: o terceiro comando ja devolve 99900, sem esperar os 30 s de ttl.

# ── Prova 5: failover do cache, medido pela aplicacao ─────────────────────────
aws elasticache test-failover \
  --replication-group-id "${PROJETO}-catalogo" --node-group-id 0001
( while true; do
    curl -s -o /dev/null -w '%{http_code} ' "https://.../api/catalogo/produtos/$SKU"
    sleep 0.2
  done ) & LACO=$!
sleep 60; kill $LACO
# Esperado: nenhum erro de conexao — a aplicacao usa o endpoint primario, que
# e o mesmo DNS antes e depois. Pode haver um breve aumento de latencia (cold
# miss na chave recem-promovida), nao erro.

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

# 2. SNAPSHOT FINAL: se "final_snapshot_identifier" estava setado, ele
#    sobrevive ao destroy e cobra GB-mes sozinho.
aws elasticache describe-snapshots --replication-group-id ffv-lab-catalogo \
  --query "Snapshots[].SnapshotName" --output table
aws elasticache delete-snapshot --snapshot-name <nome-do-snapshot> 2>/dev/null || true

# 3. SEGREDO NO SECRETS MANAGER: por padrao entra em janela de recuperacao
#    de 30 dias, continuando a cobrar taxa mensal ate a exclusao definitiva.
aws secretsmanager delete-secret \
  --secret-id ffv-lab-cache-auth --force-delete-without-recovery

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