Lab 36 — Retry, backoff, jitter e circuit breaker no .NET

#!/usr/bin/env bash
# carga-ingenua.sh — 800 clientes concorrentes, cada um repetindo o laco de
# 3 tentativas SEM espera do Function.cs ingenuo. E uma aproximacao em bash
# do comportamento do Lambda sob carga (mesmo padrao de tentativas imediatas)
# — NAO e o mesmo processo .NET. Para medir o pipeline Polly de verdade, use
# o harness em C# da secao de provas.
set -euo pipefail

URL="http://$(terraform output -raw dominio_simulador)/cobrancas"

disparar_um() {
  local codigo
  for tentativa in 1 2 3; do
    codigo=$(curl -s -o /dev/null -w '%{http_code}' -X POST "$URL" \
      -H 'content-type: application/json' \
      -d '{"pedidoId":"x","valorCentavos":1000}')
    [ "$codigo" = "200" ] && { echo 200; return; }
    # SEM sleep: a proxima tentativa comeca no mesmo instante — e exatamente
    # o defeito que este laboratorio mede.
  done
  echo "$codigo"
}
export -f disparar_um
export URL

inicio=$(date +%s)
seq 800 | xargs -P 800 -I{} bash -c disparar_um > /tmp/resultado-ingenuo.txt
fim=$(date +%s)

sucesso=$(grep -c '^200$' /tmp/resultado-ingenuo.txt || true)
echo "duracao: $((fim - inicio)) s"
echo "sucesso: ${sucesso} de 800"
# Medido no ambiente de exemplo da Cadencia: 267 de 800 (33%) — o parceiro
# simulado colapsa sob a propria multiplicacao do retry. Meca no seu ambiente.

{
  "evento": "CIRCUITO_ABERTO",
  "timestamp": "2026-08-07T14:12:03.418Z",
  "motivo": "TaskCanceledException: timeout apos 2000ms",
  "pedidoId": "8f1c2a90-...",
  "requestId": "3e7a9c10-...",
  "_comentario": "Log estruturado escrito pelo OnOpened do Polly. O metric filter do Terraform casa em '$.evento = CIRCUITO_ABERTO' e vira contagem no CloudWatch — nenhuma chamada de API extra, so uma linha de log bem formatada."
}

// Function.cs — o "conserto" que piora tudo sob carga (NÃO faça isto)
//
// Ponto de partida: o L22 termina com uma única tentativa em CobrarCartaoAsync,
// deixando a fila reentregar depois de 60 s quando falha. Um engenheiro,
// incomodado com o cliente esperando ate 60 s por uma recusa, adiciona este
// laco — e e exatamente esta mudanca que faz uma degradacao do parceiro virar
// uma queda completa sob carga de campanha.

private static async Task CobrarCartaoAsync(PedidoRecebido pedido)
{
    HttpResponseMessage? ultimaResposta = null;

    // Tres tentativas, SEM Task.Delay nenhum entre elas. Cada chamada que
    // falha por timeout ja gastou o tempo inteiro do timeout — e a proxima
    // comeca no MESMO instante, sem dar ao parceiro um unico milissegundo
    // para se recuperar. Sob 800 invocacoes concorrentes, isto multiplica a
    // carga contra o parceiro por ate 3x exatamente quando ele mais precisa
    // de MENOS carga, nao mais.
    for (var tentativa = 1; tentativa <= 3; tentativa++)
    {
        ultimaResposta = await _gatewayPagamento.PostAsJsonAsync(
            "https://gateway.exemplo/cobrancas",
            new { pedido.PedidoId, pedido.ValorCentavos });

        if (ultimaResposta.IsSuccessStatusCode) return;

        // Um 429 (limite de taxa do parceiro) e tratado IGUAL a qualquer
        // outro erro: tenta de novo, imediatamente. E o proprio sinal que o
        // parceiro usa para pedir menos carga sendo respondido com mais.
    }

    ultimaResposta!.EnsureSuccessStatusCode(); // lanca; o item entra em batchItemFailures
}

// Function.cs — retry com backoff + jitter, e circuit breaker, como campos
// estaticos construidos UMA VEZ (fora do handler — Polly nao foi feito para
// ser reconstruido a cada invocacao, e reconstruir descartaria o estado do
// disjuntor entre chamadas).

using Polly;
using Polly.CircuitBreaker;
using Polly.Retry;

private static readonly HttpClient _gatewayPagamento = new()
{
    // Reduzido dos 5 s do L22 de proposito: com retry disponivel, uma unica
    // espera longa vale menos do que falhar rapido e deixar o Polly decidir
    // a proxima tentativa. Ver a formula do orcamento na secao ao lado.
    Timeout = TimeSpan.FromSeconds(2),
};

private static readonly ResiliencePipeline<HttpResponseMessage> _resiliencia =
    new ResiliencePipelineBuilder<HttpResponseMessage>()
        .AddRetry(new RetryStrategyOptions<HttpResponseMessage>
        {
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .Handle<TaskCanceledException>() // timeout do HttpClient vira esta excecao
                .HandleResult(r => !r.IsSuccessStatusCode),
            MaxRetryAttempts = 2, // 1 tentativa inicial + 2 retentativas = 3 no total
            BackoffType = DelayBackoffType.Exponential,
            // O PONTO CENTRAL deste laboratorio. Sem jitter, todo invocacao
            // que falhou no mesmo segundo espera o MESMO tempo e tenta de
            // novo no mesmo segundo seguinte — o backoff exponencial sozinho
            // ainda sincroniza. Com UseJitter=true e backoff exponencial, o
            // Polly aciona o DecorrelatedJitterBackoffV2: cada espera depende
            // da anterior de forma nao-deterministica, quebrando a
            // sincronizacao entre as 800 invocacoes concorrentes.
            UseJitter = true,
            Delay = TimeSpan.FromMilliseconds(200),
            MaxDelay = TimeSpan.FromSeconds(1.5), // teto: mantem o pior caso previsivel
            OnRetry = args =>
            {
                Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(new
                {
                    evento = "RETRY_TENTATIVA",
                    tentativa = args.AttemptNumber + 1,
                    espera_ms = args.RetryDelay.TotalMilliseconds,
                }));
                return default;
            },
        })
        .AddCircuitBreaker(new CircuitBreakerStrategyOptions<HttpResponseMessage>
        {
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .Handle<TaskCanceledException>()
                .HandleResult(r => !r.IsSuccessStatusCode),
            // Numa janela de 10 s, com pelo menos 20 chamadas reais, abre se
            // metade delas falhar. MinimumThroughput existe para nao abrir o
            // circuito com base numa amostra pequena demais — mas isso tem
            // um efeito colateral que a secao de troubleshooting trata: em
            // trafego calmo (fora de campanha), 20 chamadas em 10 s pode
            // nunca acontecer, e o disjuntor nunca abre, mesmo com o parceiro
            // genuinamente fora.
            FailureRatio = 0.5,
            SamplingDuration = TimeSpan.FromSeconds(10),
            MinimumThroughput = 20,
            BreakDuration = TimeSpan.FromSeconds(15),
            OnOpened = args =>
            {
                // Log ESTRUTURADO, nao chamada de API — o metric filter do
                // Terraform ao lado transforma esta linha em metrica, sem
                // exigir nenhuma permissao nova para a funcao.
                Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(new
                {
                    evento = "CIRCUITO_ABERTO",
                    motivo = args.Outcome.Exception?.Message ?? "limiar de falha atingido",
                }));
                return default;
            },
            OnClosed = args =>
            {
                Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(
                    new { evento = "CIRCUITO_FECHADO" }));
                return default;
            },
            OnHalfOpened = args =>
            {
                Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(
                    new { evento = "CIRCUITO_MEIO_ABERTO" }));
                return default;
            },
        })
        .Build();

private static async Task CobrarCartaoAsync(PedidoRecebido pedido)
{
    try
    {
        var resposta = await _resiliencia.ExecuteAsync(async ct =>
            await _gatewayPagamento.PostAsJsonAsync(
                "https://gateway.exemplo/cobrancas",
                new { pedido.PedidoId, pedido.ValorCentavos }, ct));

        resposta.EnsureSuccessStatusCode();
    }
    catch (BrokenCircuitException)
    {
        // O circuito estava ABERTO: nenhuma chamada de rede foi feita. Isto
        // e DIFERENTE de esgotar as tentativas de retry — aqui a decisao foi
        // tomada ANTES de discar. A mensagem volta para a fila e sera
        // reentregue quando (e se) o circuito tiver fechado de novo.
        throw;
    }
}

// simulador/Program.cs — alvo controlado para reproduzir o storm com seguranca.
// Chamar o parceiro de pagamento REAL num teste de carga nao e uma opcao: ele
// tem limite de taxa contratual, e o objetivo aqui e medir o CLIENTE, nao
// incomodar um parceiro de producao. Este simulador reage como o parceiro
// documentado reage sob carga, com a capacidade como premissa declarada.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Capacidade medida do parceiro real ao longo de meses de fatura da
// Cadencia — NAO confirmada por documentacao publica dele. E a premissa que
// autoriza este numero especifico; ajuste-o se o seu parceiro for diferente.
const int CAPACIDADE_RPS = 400;
var emVoo = 0;

app.MapPost("/cobrancas", async (HttpContext ctx) =>
{
    Interlocked.Increment(ref emVoo);
    try
    {
        if (emVoo > CAPACIDADE_RPS)
        {
            // Acima da capacidade declarada: latencia alta e boa parte das
            // respostas vira 429, como o parceiro real sob throttling.
            await Task.Delay(Random.Shared.Next(800, 2500));
            if (Random.Shared.NextDouble() < 0.6)
                return Results.StatusCode(429);
        }
        else
        {
            await Task.Delay(Random.Shared.Next(80, 180)); // latencia normal do parceiro
        }
        return Results.Ok(new { status = "aprovado" });
    }
    finally
    {
        Interlocked.Decrement(ref emVoo);
    }
});

app.MapGet("/saude", () => Results.Ok());

app.Run();

# simulador.tf — alvo controlado, atras de ALB, para o teste de carga
# Reaproveita o cluster e a VPC ja criados no L01/L22 — so a task e o alvo
# sao novos.

resource "aws_lb_target_group" "simulador" {
  name        = "${var.projeto}-simulador-parceiro"
  port        = 8080
  protocol    = "HTTP"
  vpc_id      = aws_vpc.principal.id
  target_type = "ip"

  health_check {
    path                = "/saude"
    interval            = 10
    healthy_threshold   = 2
    unhealthy_threshold = 2
  }
}

resource "aws_ecs_task_definition" "simulador_parceiro" {
  family                   = "${var.projeto}-simulador-parceiro"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 256
  memory                   = 512
  execution_role_arn       = aws_iam_role.execucao.arn

  container_definitions = jsonencode([{
    name         = "simulador"
    image        = "${aws_ecr_repository.simulador.repository_url}:${var.sha_do_simulador}"
    essential    = true
    portMappings = [{ containerPort = 8080, protocol = "tcp" }]
    logConfiguration = {
      logDriver = "awslogs"
      options = {
        "awslogs-group"         = aws_cloudwatch_log_group.simulador.name
        "awslogs-region"        = var.regiao
        "awslogs-stream-prefix" = "simulador"
      }
    }
  }])
}

resource "aws_ecs_service" "simulador_parceiro" {
  name            = "${var.projeto}-simulador-parceiro"
  cluster         = aws_ecs_cluster.principal.id
  task_definition = aws_ecs_task_definition.simulador_parceiro.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = aws_subnet.privada[*].id
    security_groups  = [aws_security_group.simulador.id]
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.simulador.arn
    container_name   = "simulador"
    container_port   = 8080
  }
}

output "dominio_simulador" {
  value       = aws_lb.simulador.dns_name
  description = "endpoint HTTP do simulador; e contra ele que os dois testes de carga rodam"
}

# observabilidade-circuito.tf — a transicao do disjuntor, visivel sem abrir codigo
# O SNS (aws_sns_topic.alertas) e o mesmo do L22; nao ha topico novo aqui.

resource "aws_cloudwatch_log_metric_filter" "circuito_aberto" {
  name = "${var.projeto}-circuito-pagamento-aberto"
  # O log group padrao que o Lambda ja escreve — nao exige nenhuma permissao
  # nova para a funcao, porque e so texto de log, nao chamada de API.
  log_group_name = "/aws/lambda/${aws_lambda_function.consumidor.function_name}"

  # Casa a linha estruturada que o OnOpened escreve. E TEXTO de log: o metric
  # filter e quem transforma isso em numero.
  pattern = "{ $.evento = \"CIRCUITO_ABERTO\" }"

  metric_transformation {
    name      = "CircuitoAbertoPagamento"
    namespace = "${var.projeto}/resiliencia"
    value     = "1"
    unit      = "Count"
  }
}

# NAO dispara na primeira abertura — isso e o disjuntor fazendo o trabalho
# dele. Dispara quando ele soma 3 janelas de 1 minuto com nova abertura,
# sinal de que o parceiro nao esta voltando dentro do tempo que o disjuntor
# sozinho tolera.
resource "aws_cloudwatch_metric_alarm" "circuito_reabrindo" {
  alarm_name          = "${var.projeto}-circuito-pagamento-reabrindo"
  namespace           = "${var.projeto}/resiliencia"
  metric_name         = "CircuitoAbertoPagamento"
  statistic           = "Sum"
  period              = 60
  evaluation_periods  = 3
  threshold           = 1
  comparison_operator = "GreaterThanOrEqualToThreshold"
  treat_missing_data  = "notBreaching"

  alarm_actions = [aws_sns_topic.alertas.arn]
}

// CargaTeste/Program.cs — dispara 800 chamadas concorrentes reutilizando o
// MESMO codigo de producao (ingenuo OU Polly, por variavel de ambiente), e
// conta quantas chamadas de rede de fato aconteceram — a prova de que o
// circuito aberto realmente pula a rede, nao so espera mais para tentar de
// novo.

var usaPolly = Environment.GetEnvironmentVariable("USA_POLLY") == "true";
var url = Environment.GetEnvironmentVariable("URL_SIMULADOR")!;
var chamadasDeRede = 0;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(2) };

async Task<bool> TentarIngenuo()
{
    for (var t = 0; t < 3; t++)
    {
        Interlocked.Increment(ref chamadasDeRede);
        try
        {
            var r = await http.PostAsJsonAsync(url, new { pedidoId = "x", valorCentavos = 1000 });
            if (r.IsSuccessStatusCode) return true;
        }
        catch (TaskCanceledException) { /* timeout: proxima tentativa imediata */ }
    }
    return false;
}

async Task<bool> TentarComPolly()
{
    try
    {
        var r = await Resiliencia.Pipeline.ExecuteAsync(async ct =>
        {
            Interlocked.Increment(ref chamadasDeRede); // so incrementa quando a rede E tocada
            return await http.PostAsJsonAsync(url, new { pedidoId = "x", valorCentavos = 1000 }, ct);
        });
        return r.IsSuccessStatusCode;
    }
    catch { return false; }
}

var relogio = System.Diagnostics.Stopwatch.StartNew();
var tarefas = Enumerable.Range(0, 800)
    .Select(_ => usaPolly ? TentarComPolly() : TentarIngenuo());
var resultados = await Task.WhenAll(tarefas);
relogio.Stop();

Console.WriteLine($"modo: {(usaPolly ? "polly" : "ingenuo")}");
Console.WriteLine($"duracao: {relogio.Elapsed.TotalSeconds:F1} s");
Console.WriteLine($"sucesso: {resultados.Count(r => r)} de 800");
Console.WriteLine($"chamadas de rede reais: {chamadasDeRede}");
// Medido no ambiente de exemplo: ingenuo faz ate 2.400 chamadas de rede para
// 800 pedidos (3x); com Polly e o circuito abrindo, o total fica pertode
// 1.000 — a diferenca E o numero de chamadas que o disjuntor evitou.

#!/usr/bin/env bash
set -euo pipefail

# A ordem importa: o simulador nao tem dependente, mas o log group e o alarme
# sobrevivem ao destroy se nao estiverem no mesmo state.
terraform destroy \
  -target=aws_ecs_service.simulador_parceiro \
  -target=aws_ecs_task_definition.simulador_parceiro \
  -target=aws_lb_target_group.simulador \
  -auto-approve

terraform destroy -auto-approve

echo "Confira manualmente: log group /aws/lambda/<projeto>-consumidor-pedidos"
echo "nao e removido por este destroy — ele pertence ao L22."