Lab 40 — Teste de carga e o gargalo real

# O jeito rapido, e por isso o mais tentador, de tentar responder
# "quanto aguenta" — sem degrau, sem isolamento, sem simulador.
# NAO RODE isto contra producao. E o antipadrao que este laboratorio existe
# para substituir.
ab -n 50000 -c 300 https://api.cadencia.exemplo/pedidos
# Cada pedido criado aqui e um pedido REAL. Cada cobranca tentada chega
# ao gateway de pagamento DE VERDADE. E o pico e instantaneo — nao ha como
# separar saturacao real de latencia de partida a frio.

// O que a task .NET publica ao fim de CADA degrau. E o registro que vira
// a curva de carga, e a base para a decisao "subir, ficar ou parar".
{
  "degrau": 5,
  "rps_alvo": 220,
  "rps_aplicado_medio": 218.4,
  "duracao_segundos": 420,
  "p99_ms": 812,
  "taxa_erro": 0.021,
  "estabilizou": true,
  "sinais": {
    "ecs_cpu_media_pct": 54.2,
    "rds_database_connections": 187,
    "rds_max_database_connections_allowed": 190,
    "cache_hit_rate_pct": 89.7,
    "disjuntor_aberto": false
  },
  // 187 de 190 e o sinal que decide este degrau: RDS perto do teto
  // enquanto CPU, cache e disjuntor seguem dentro do esperado.
  "decisao": "parar_e_confirmar"
}

# rds-proxy.tf — a UNICA peca nova que o teste de carga justificou

# RDS Proxy exige a credencial do banco no Secrets Manager — nunca em
# variavel de ambiente da task. Reaproveita o segredo que o RDS ja usa.
resource "aws_db_proxy" "api" {
  name                   = "${var.projeto}-proxy"
  engine_family          = "POSTGRESQL"
  role_arn               = aws_iam_role.rds_proxy.arn
  vpc_subnet_ids         = var.subnets_privadas
  require_tls            = true

  auth {
    auth_scheme = "SECRETS"
    secret_arn  = aws_secretsmanager_secret.db_credencial.arn
    iam_auth    = "DISABLED"
  }
}

resource "aws_db_proxy_default_target_group" "api" {
  db_proxy_name = aws_db_proxy.api.name

  connection_pool_config {
    # Medido no teste: pico de uso monitorado foi por volta de 62% do
    # max_connections da instancia. A documentacao da AWS recomenda
    # MaxConnectionsPercent >= 1,3 vezes o uso monitorado (nao +30 pontos
    # percentuais) — aqui, 1,3 x 62% = ~81%, e o proxy redistribui cota
    # de conexao entre nos internamente sem aviso previo.
    max_connections_percent      = 90
    max_idle_connections_percent = 45
    connection_borrow_timeout    = 120
  }
}

resource "aws_db_proxy_target" "api" {
  db_proxy_name          = aws_db_proxy.api.name
  target_group_name      = aws_db_proxy_default_target_group.api.name
  db_instance_identifier = aws_db_instance.api.identifier
}

# Menor privilegio: o proxy so precisa buscar o segredo especifico dele.
# GetSecretValue aceita recurso, entao "*" nao se justifica aqui.
data "aws_iam_policy_document" "rds_proxy_segredo" {
  statement {
    effect    = "Allow"
    actions   = ["secretsmanager:GetSecretValue"]
    resources = [aws_secretsmanager_secret.db_credencial.arn]
  }
}

output "endpoint_proxy" {
  value       = aws_db_proxy.api.endpoint
  description = "A aplicacao aponta para AQUI, nao mais para o endpoint direto do RDS"
}

# executor-de-carga.tf — a role do executor NAO tem acesso a nada de
# producao. E a garantia estrutural do requisito de isolamento.

resource "aws_iam_role" "executor_carga" {
  name               = "${var.projeto}-executor-carga"
  assume_role_policy = data.aws_iam_policy_document.assume_ecs_tasks.json
}

# So publica metrica e le a URL do ambiente ISOLADO. Nao ha permissao de
# escrita em RDS, em fila ou em qualquer recurso de producao — a task nao
# fala com o banco, ela so fala HTTP com o ALB de staging.
data "aws_iam_policy_document" "executor_carga" {
  statement {
    effect    = "Allow"
    actions   = ["cloudwatch:PutMetricData"]
    # PutMetricData nao aceita recurso: e operacao de conta, nao de metrica
    # especifica — por isso o "*" aqui, e em nenhum outro lugar da policy.
    resources = ["*"]
    condition {
      test     = "StringEquals"
      variable = "cloudwatch:namespace"
      values   = ["Cadencia/TesteDeCarga"]
    }
  }
}

resource "aws_sfn_state_machine" "degraus" {
  name     = "${var.projeto}-degraus-de-carga"
  role_arn = aws_iam_role.orquestrador.arn

  # Cada estado dispara um degrau (task ECS RunTask), espera o tempo de
  # estabilizacao, e o proximo estado le o registro publicado para decidir
  # entre "Subir", "Confirmar" ou "Parar" — a mesma logica do metodo.
  definition = templatefile("${path.module}/degraus.asl.json", {
    cluster_arn         = aws_ecs_cluster.principal.arn
    task_definition_arn = aws_ecs_task_definition.executor_carga.arn
    subnets             = jsonencode(var.subnets_privadas)
  })
}

// GeradorDeCarga/Program.cs — aplica um degrau de carga, mede
// estabilizacao e publica o registro que decide o proximo passo.
// Nao e a aplicacao de producao: e um executavel a parte, isolado.
using System.Collections.Concurrent;
using System.Diagnostics;
using Amazon.CloudWatch;
using Amazon.CloudWatch.Model;

var alvoUrl = Environment.GetEnvironmentVariable("ALVO_URL_ISOLADO")
    ?? throw new InvalidOperationException("ALVO_URL_ISOLADO e obrigatorio");
var rpsAlvo = int.Parse(args[0]);
var duracaoSegundos = int.Parse(args[1]);

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(5) };
using var cw = new AmazonCloudWatchClient();

// DISPARO concorrente, nao sequencial: um laco que so espera a proxima
// requisicao terminar antes de comecar a seguinte tem throughput maximo
// de 1/latencia — sob saturacao, exatamente quando o teste mais precisa
// medir, o proprio gerador vira o gargalo. Aqui cada tick do timer DISPARA
// uma requisicao em paralelo (fire-and-track, nao fire-and-forget: o Task
// e guardado e aguardado no final) — a cadencia de disparo fica desacoplada
// da latencia de resposta.
var latencias = new ConcurrentBag<double>();
var erros = 0;
var emVoo = new ConcurrentBag<Task>();
var cronometro = Stopwatch.StartNew();
var intervaloEntreDisparos = TimeSpan.FromSeconds(1.0 / rpsAlvo);
using var limitador = new PeriodicTimer(intervaloEntreDisparos);

async Task DispararUmaAsync()
{
    var inicio = Stopwatch.StartNew();
    try
    {
        // A rota exercitada precisa refletir o mix real da campanha —
        // so leitura mede uma arquitetura diferente da que existe (a
        // hipotese declarada na abertura do modulo).
        var resp = await http.GetAsync($"{alvoUrl}/api/pedidos/recentes");
        if (!resp.IsSuccessStatusCode) Interlocked.Increment(ref erros);
    }
    catch (Exception)
    {
        Interlocked.Increment(ref erros);
    }
    latencias.Add(inicio.Elapsed.TotalMilliseconds);
}

while (cronometro.Elapsed < TimeSpan.FromSeconds(duracaoSegundos)
       && await limitador.WaitForNextTickAsync())
{
    emVoo.Add(DispararUmaAsync()); // dispara e segue — nao bloqueia o proximo tick
}
await Task.WhenAll(emVoo); // so aguarda o que ainda estiver em voo ao fim do degrau

var total = latencias.Count;
var ordenadas = latencias.OrderBy(l => l).ToList();
var p99 = ordenadas[(int)(ordenadas.Count * 0.99)];
var taxaErro = (double)erros / total;

// Publica o degrau. O ORQUESTRADOR le este dado para decidir o proximo
// passo — nao ha decisao humana no laco, so na configuracao do criterio.
await cw.PutMetricDataAsync(new PutMetricDataRequest
{
    Namespace = "Cadencia/TesteDeCarga",
    MetricData = new List<MetricDatum>
    {
        new() { MetricName = "P99Ms", Value = p99, Unit = StandardUnit.Milliseconds },
        new() { MetricName = "TaxaErro", Value = taxaErro, Unit = StandardUnit.None },
        new() { MetricName = "RpsAplicado", Value = total / (double)duracaoSegundos, Unit = StandardUnit.CountSecond },
    },
});

Console.WriteLine($"degrau={rpsAlvo}req/s p99={p99:F0}ms erro={taxaErro:P2}");

# Ordem: primeiro o aparato de TESTE, que so existe durante a rodada.
# O RDS Proxy NAO entra aqui — ele fica em producao, e essa e a decisao
# registrada na secao de decisoes.
terraform destroy -target=aws_sfn_state_machine.degraus
terraform destroy -target=aws_ecs_task_definition.executor_carga
terraform destroy -target=aws_iam_role.executor_carga

# Se o staging foi criado so para esta rodada (efemero), derrube tambem.
# Se e um staging permanente, mantenha e apenas zere os dados sinteticos.
terraform destroy -target=module.staging_efemero  # so se aplicavel