Lab 59 — FinOps: medir antes de comprar compromisso

{
  "version": "0",
  "id": "9f6a2b3c-...",
  "detail-type": "EC2 Spot Instance Interruption Warning",
  "source": "aws.ec2",
  "account": "111122223333",
  "time": "2026-08-08T03:14:00Z",
  "region": "us-east-1",
  "resources": ["arn:aws:ec2:us-east-1:111122223333:instance/i-0abc123def456789a"],
  "detail": {
    "instance-id": "i-0abc123def456789a",
    "instance-action": "terminate"
  }
}

# frotas.tf — duas frotas por tolerancia a interrupcao, dimensionadas pelo
# Compute Optimizer. Nenhum tipo de instancia aqui e escolhido a olho.

variable "tipo_sincrono_novo" {
  description = "Tipo recomendado pelo Compute Optimizer para a frota sincrona, apos 14+ dias de metrica real"
  type        = string
}

variable "tipos_lote" {
  description = "Tipos elegiveis para a frota Spot do lote — diversificar reduz a chance de interrupcao simultanea"
  type        = list(string)
}

# ── Frota sincrona: on-demand, e so ela vai receber compromisso ──────────────
resource "aws_launch_template" "sincrono" {
  name_prefix   = "${var.projeto}-sincrono-"
  image_id      = var.ami_dotnet8
  instance_type = var.tipo_sincrono_novo

  iam_instance_profile {
    name = aws_iam_instance_profile.sincrono.name
  }

  # IMDSv2 obrigatorio: token exigido, sem fallback para v1. E tambem o que
  # torna o polling de interrupcao do worker do lote seguro de replicar aqui,
  # caso a Rotamix decida um dia rodar rightsizing nesta frota tambem.
  metadata_options {
    http_tokens   = "required"
    http_endpoint = "enabled"
  }

  network_interfaces {
    security_groups = [aws_security_group.sincrono.id]
  }

  tag_specifications {
    resource_type = "instance"
    tags = { Perfil = "sincrono", Projeto = var.projeto, RightsizedEm = var.data_rightsizing }
  }
}

resource "aws_autoscaling_group" "sincrono" {
  name                = "${var.projeto}-sincrono"
  min_size            = 2
  max_size            = 4
  desired_capacity    = 2
  vpc_zone_identifier = aws_subnet.privada[*].id

  launch_template {
    id      = aws_launch_template.sincrono.id
    version = "$Latest"
  }

  target_group_arns = [aws_lb_target_group.sincrono.arn]

  tag {
    key                 = "Perfil"
    value               = "sincrono"
    propagate_at_launch = true
  }
}

# ── Frota do lote: politica de instancias mistas, majoritariamente Spot ──────
# `on_demand_base_capacity = 0` e `on_demand_percentage_above_base_capacity = 0`
# autorizam 100% Spot: o requisito de tolerancia a interrupcao ja foi validado
# na secao de requisitos, e e ele que justifica zero capacidade garantida aqui.
resource "aws_launch_template" "lote" {
  name_prefix   = "${var.projeto}-lote-"
  image_id      = var.ami_dotnet8

  iam_instance_profile {
    name = aws_iam_instance_profile.lote.name
  }

  metadata_options {
    http_tokens   = "required"
    http_endpoint = "enabled"
  }

  network_interfaces {
    security_groups = [aws_security_group.lote.id]
  }

  tag_specifications {
    resource_type = "instance"
    tags = { Perfil = "lote", Projeto = var.projeto }
  }
}

resource "aws_autoscaling_group" "lote" {
  name                = "${var.projeto}-lote"
  min_size            = 0
  max_size            = 20
  desired_capacity    = 4
  vpc_zone_identifier = aws_subnet.privada[*].id

  mixed_instances_policy {
    instances_distribution {
      on_demand_base_capacity                  = 0
      on_demand_percentage_above_base_capacity  = 0
      # capacity-optimized: a AWS escolhe o pool com mais capacidade
      # disponivel entre os tipos elegiveis, o que documentadamente reduz a
      # frequencia de interrupcao frente a alocacao so por preco mais baixo.
      spot_allocation_strategy = "capacity-optimized"
    }

    launch_template {
      launch_template_specification {
        launch_template_id = aws_launch_template.lote.id
        version             = "$Latest"
      }

      dynamic "override" {
        for_each = var.tipos_lote
        content {
          instance_type = override.value
        }
      }
    }
  }

  tag {
    key                 = "Perfil"
    value               = "lote"
    propagate_at_launch = true
  }
}

resource "aws_sqs_queue" "lote" {
  name = "${var.projeto}-lote"

  # Cobre a duracao normal de um job (media medida: ~12 min). Curto demais
  # reprocessaria job em andamento como se tivesse falhado; longo demais
  # atrasa a recuperacao de um job genuinamente perdido.
  visibility_timeout_seconds = 900

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

resource "aws_sqs_queue" "lote_dlq" {
  name                      = "${var.projeto}-lote-dlq"
  message_retention_seconds = 1209600 # 14 dias — tempo para investigar antes de expirar
}

# observabilidade.tf — o evento de interrupcao vira metrica, e o compromisso
# vira alarme quando comeca a sobrar

# O EventBridge aqui NAO protege o job — quem protege e o polling local do
# worker, no proprio processo. Este caminho existe para a frota ser
# observavel: quantas interrupcoes por hora, e se a taxa esta subindo.
resource "aws_cloudwatch_log_group" "interrupcoes_spot" {
  name              = "/${var.projeto}/interrupcoes-spot"
  retention_in_days = 30
}

resource "aws_cloudwatch_event_rule" "interrupcao_spot" {
  name = "${var.projeto}-interrupcao-spot"

  event_pattern = jsonencode({
    source      = ["aws.ec2"]
    detail-type = ["EC2 Spot Instance Interruption Warning"]
  })
}

resource "aws_cloudwatch_event_target" "para_log" {
  rule = aws_cloudwatch_event_rule.interrupcao_spot.name
  arn  = aws_cloudwatch_log_group.interrupcoes_spot.arn
}

resource "aws_cloudwatch_log_metric_filter" "taxa_interrupcao" {
  name           = "taxa-interrupcao-spot"
  log_group_name = aws_cloudwatch_log_group.interrupcoes_spot.name
  pattern        = "{ $.detail-type = \"EC2 Spot Instance Interruption Warning\" }"

  metric_transformation {
    name      = "InterrupcoesSpot"
    namespace = "${var.projeto}/FinOps"
    value     = "1"
  }
}

# Orcamento do TIPO de compromisso, nao do gasto total: alarma quando o
# compromisso comprado esta sendo usado abaixo de um limiar — e e exatamente
# o sintoma de ter comprado sobre o numero errado. O limite deste tipo de
# orcamento e sempre 100 (percentual de utilizacao), por exigencia da API.
resource "aws_budgets_budget" "utilizacao_savings_plan" {
  name         = "${var.projeto}-utilizacao-savings-plan"
  budget_type  = "SAVINGS_PLANS_UTILIZATION"
  limit_amount = "100"
  limit_unit   = "PERCENTAGE"
  time_unit    = "MONTHLY"

  cost_types {
    include_credit             = false
    include_refund             = false
    include_subscription       = true
  }

  notification {
    comparison_operator       = "LESS_THAN"
    threshold                 = 90
    threshold_type            = "PERCENTAGE"
    notification_type         = "ACTUAL"
    subscriber_email_addresses = [var.email_finops]
  }
}

# iam.tf — quem le recomendacao, quem compra, e quem processa a fila
#
# ComputeOptimizer e SavingsPlans nao aceitam Resource especifico nas acoes
# de leitura/criacao usadas aqui: sao operacoes de conta, sem ARN de recurso
# individual antes de existirem. E por isso — e so por isso — que o "*"
# aparece nessas duas policies, com o motivo escrito ao lado de cada uma.
data "aws_iam_policy_document" "revisao_finops" {
  statement {
    sid     = "LerRecomendacoes"
    effect  = "Allow"
    actions = [
      "compute-optimizer:GetEC2InstanceRecommendations",
      "compute-optimizer:GetAutoScalingGroupRecommendations",
      "compute-optimizer:GetEnrollmentStatus",
    ]
    # Operacao de conta: nao existe ARN de "recomendacao" antes dela ser
    # calculada, entao nenhuma API do Compute Optimizer aceita Resource.
    resources = ["*"]
  }

  statement {
    sid     = "ConsultarOfertasDeCompromisso"
    effect  = "Allow"
    actions = [
      "savingsplans:DescribeSavingsPlansOfferings",
      "savingsplans:DescribeSavingsPlans",
    ]
    resources = ["*"] # descoberta de ofertas nao e escopada por recurso
  }

  statement {
    sid       = "ComprarCompromisso"
    effect    = "Allow"
    actions   = ["savingsplans:CreateSavingsPlan"]
    resources = ["*"] # a compra cria o recurso; nao existe ARN anterior a ela

    # Quem assume este papel tem de ser humano, nao a role de execucao do
    # pipeline: a acao e irreversivel, e nenhuma esteira automatizada deveria
    # ter permissao de assinar 1 a 3 anos de compromisso sozinha.
    condition {
      test     = "Bool"
      variable = "aws:MultiFactorAuthPresent"
      values   = ["true"]
    }
  }
}

# Papel do worker do lote: SQS e S3 escopados a recursos especificos — nada
# de "*" aqui, porque as duas acoes suportam Resource e a fila e o prefixo
# de checkpoint sao conhecidos com antecedencia.
data "aws_iam_policy_document" "worker_lote" {
  statement {
    effect  = "Allow"
    actions = [
      "sqs:ReceiveMessage",
      "sqs:DeleteMessage",
      "sqs:ChangeMessageVisibility",
    ]
    resources = [aws_sqs_queue.lote.arn]
  }

  statement {
    effect    = "Allow"
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.checkpoints.arn}/lote/*"]
  }
}

#!/usr/bin/env bash
# comprar-savings-plan.sh — a compra e uma decisao humana, nao um `apply`
#
# Este script NAO e Terraform, de proposito. O provedor da AWS ja expoe um
# recurso para Savings Plans, mas uma compra assinada por 1 a 3 anos nao tem
# operacao inversa: nao existe `destroy` que devolva o compromisso. Modelar
# uma decisao financeira irreversivel como estado gerenciavel ensina o habito
# errado — o de tratar "posso reverter com terraform destroy" como verdade
# geral sobre todo recurso do provedor. Aqui, a compra pede confirmacao
# explicita de quem tem mandato para assinar, fora do ciclo de CI/CD.
set -euo pipefail

PROJETO="${PROJETO:?defina PROJETO}"
DIAS_MEDINDO_TAMANHO_NOVO="${DIAS_MEDINDO_TAMANHO_NOVO:-7}"

# ── Passo 1: confirmar que o rightsizing ja foi aplicado ha dias suficientes ──
RIGHTSIZED_EM="$(aws ec2 describe-instances \
  --filters "Name=tag:Perfil,Values=sincrono" \
  --query 'Reservations[0].Instances[0].Tags[?Key==`RightsizedEm`].Value' --output text)"

if [[ -z "$RIGHTSIZED_EM" ]]; then
  echo "ABORTA: a frota sincrona nao tem a tag RightsizedEm — rightsizing nao confirmado." >&2
  exit 1
fi

# ── Passo 2: pedir a recomendacao mais recente, para comparar com o que sera comprado ──
aws compute-optimizer get-ec2-instance-recommendations \
  --instance-arns "$(aws ec2 describe-instances --filters "Name=tag:Perfil,Values=sincrono" \
    --query 'Reservations[].Instances[].InstanceId' --output text | tr '\t' '\n' | \
    xargs -I{} echo "arn:aws:ec2:${AWS_REGION:-us-east-1}:$(aws sts get-caller-identity --query Account --output text):instance/{}")" \
  --query 'instanceRecommendations[].{achado:finding,recomendado:recommendationOptions[0].instanceType}' \
  --output table

echo "Confira: o achado deve ser OPTIMIZED para o tipo atual antes de prosseguir."
read -r -p "O achado confirma OPTIMIZED para ${DIAS_MEDINDO_TAMANHO_NOVO} dias de medicao? (digite SIM) " confirmacao
[[ "$confirmacao" == "SIM" ]] || { echo "ABORTA: confirmacao nao recebida."; exit 1; }

# ── Passo 3: ofertas disponiveis, para o tamanho JA medido ───────────────────
aws savingsplans describe-savings-plans-offerings \
  --plan-types "Compute" \
  --query 'searchResults[].{oferta:offeringId,taxa:paymentOption}' \
  --output table

read -r -p "ID da oferta escolhida (Compute, 1 ano, Partial Upfront recomendado neste estagio): " OFERTA_ID
read -r -p "Compromisso em USD/hora (baseado no consumo medido, NAO no historico): " COMPROMISSO_HORA

echo "Revisao final — compromisso de ${COMPROMISSO_HORA} USD/hora, oferta ${OFERTA_ID}."
read -r -p "Confirma a COMPRA IRREVERSIVEL? (digite CONFIRMO) " confirmacao_final
[[ "$confirmacao_final" == "CONFIRMO" ]] || { echo "ABORTA: compra nao confirmada."; exit 1; }

aws savingsplans create-savings-plan \
  --savings-plan-offering-id "$OFERTA_ID" \
  --commitment "$COMPROMISSO_HORA" \
  --upfront-payment-amount 0

echo "Savings Plan assinado. Agende a revisao trimestral — ela nao acontece sozinha."

// SpotAwareWorker.cs — le a fila do lote, e reage a interrupcao Spot sozinho,
// sem depender de nenhum outro servico responder a tempo.

public sealed class SpotAwareWorker : BackgroundService
{
    private static readonly Uri EndpointAcao =
        new("http://169.254.169.254/latest/meta-data/spot/instance-action");
    private static readonly Uri EndpointToken =
        new("http://169.254.169.254/latest/api/token");

    private readonly IAmazonSQS _sqs;
    private readonly string _urlFila;
    private readonly HttpClient _http;
    private readonly ILogger<SpotAwareWorker> _log;

    public SpotAwareWorker(IAmazonSQS sqs, IOptions<FilaOptions> opcoes,
        HttpClient http, ILogger<SpotAwareWorker> log)
    {
        _sqs = sqs;
        _urlFila = opcoes.Value.UrlFila;
        _http = http;
        _log = log;
    }

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            var resposta = await _sqs.ReceiveMessageAsync(new ReceiveMessageRequest
            {
                QueueUrl = _urlFila,
                MaxNumberOfMessages = 1,
                WaitTimeSeconds = 10,
            }, ct);

            if (resposta.Messages.Count == 0) continue;
            var mensagem = resposta.Messages[0];

            // Processa o job em fatias curtas, com checkpoint entre elas — e
            // a CADA fatia consulta o endpoint local de metadados. Isso e o
            // que faz o worker perceber a interrupcao sozinho, sem esperar
            // nenhum evento externo chegar dentro dos 2 minutos de aviso.
            var job = JsonSerializer.Deserialize<JobDeRota>(mensagem.Body)!;
            await ProcessarComCheckpointAsync(job, mensagem, ct);
        }
    }

    private async Task ProcessarComCheckpointAsync(
        JobDeRota job, Message mensagem, CancellationToken ct)
    {
        foreach (var fatia in job.Fatias)
        {
            if (await InterrupcaoIminenteAsync(ct))
            {
                _log.LogWarning(
                    "Interrupcao Spot detectada localmente; checkpoint salvo em {Fatia}, "
                    + "devolvendo job {JobId} a fila", fatia.Indice, job.Id);

                await SalvarCheckpointAsync(job, fatia, ct);

                // Zera a visibilidade: a mensagem fica disponivel para outra
                // instancia AGORA, em vez de esperar o timeout padrao de 15
                // minutos. E o mecanismo que evita o job dobrar de duracao a
                // cada interrupcao.
                await _sqs.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest
                {
                    QueueUrl = _urlFila,
                    ReceiptHandle = mensagem.ReceiptHandle,
                    VisibilityTimeout = 0,
                }, ct);
                return; // nao apaga a mensagem: outra instancia reprocessa
            }

            await ProcessarFatiaAsync(job, fatia, ct);
        }

        // Escrita idempotente por Id do job — se a mesma fatia for
        // processada duas vezes por uma corrida entre a checagem local e a
        // interrupcao real, a segunda escrita nao duplica resultado.
        await GravarResultadoIdempotenteAsync(job, ct);
        await _sqs.DeleteMessageAsync(_urlFila, mensagem.ReceiptHandle, ct);
    }

    private async Task<bool> InterrupcaoIminenteAsync(CancellationToken ct)
    {
        try
        {
            var tokenResposta = await _http.PutAsync(EndpointToken,
                new StringContent(""), ct);
            tokenResposta.EnsureSuccessStatusCode();
            var token = await tokenResposta.Content.ReadAsStringAsync(ct);

            using var pedido = new HttpRequestMessage(HttpMethod.Get, EndpointAcao);
            pedido.Headers.Add("X-aws-ec2-metadata-token", token);
            var resposta = await _http.SendAsync(pedido, ct);

            // 200 com corpo = interrupcao agendada. 404 = nenhuma pendente.
            // Qualquer outro erro NAO deve ser tratado como "sem interrupcao"
            // — se o endpoint estiver instavel, o worker segue conservador e
            // volta a checar na proxima fatia, curta o bastante para caber
            // na janela de 2 minutos mesmo perdendo uma leitura.
            return resposta.StatusCode == HttpStatusCode.OK;
        }
        catch (HttpRequestException)
        {
            return false; // ver comentario acima: conservador, nao otimista
        }
    }

    private Task SalvarCheckpointAsync(JobDeRota job, Fatia fatia, CancellationToken ct) =>
        Task.CompletedTask; // grava em S3/DynamoDB o progresso ate a fatia atual

    private Task ProcessarFatiaAsync(JobDeRota job, Fatia fatia, CancellationToken ct) =>
        Task.CompletedTask; // o calculo de reotimizacao em si

    private Task GravarResultadoIdempotenteAsync(JobDeRota job, CancellationToken ct) =>
        Task.CompletedTask; // upsert condicional por Id do job
}

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

PROJETO=rotamix; REGIAO=us-east-1

# ── Prova 1: a frota sincrona tinha folga ANTES do rightsizing ───────────────
# Rode antes de aplicar qualquer mudanca. Esperado: achado = OVER_PROVISIONED
# e utilizacao media de CPU medida abaixo de 40% no periodo de 14 dias — o
# valor exato depende da sua carga; o que importa e o achado nao ser OPTIMIZED.
aws compute-optimizer get-ec2-instance-recommendations \
  --instance-arns "$(terraform output -raw arns_frota_sincrona_antiga)" \
  --query 'instanceRecommendations[].{achado:finding,cpu_media:utilizationMetrics[?name==`CPU`].value|[0]}' \
  --output table

# ── Prova 2: o compromisso comprado bate com o tamanho medido, nao o antigo ──
# Compara o $/hora do plano assinado com o preco on-demand do tipo NOVO
# multiplicado pela contagem da frota. Esperado: diferenca abaixo de 5%.
COMPROMISSO=$(aws savingsplans describe-savings-plans \
  --query 'savingsPlans[0].commitment' --output text)
TAXA_TIPO_NOVO=$(aws pricing get-products --service-code AmazonEC2 \
  --filters "Type=TERM_MATCH,Field=instanceType,Value=$(terraform output -raw tipo_sincrono_novo)" \
  --query 'PriceList[0]' --output text | python3 -c \
  "import json,sys; print(json.load(sys.stdin)['terms']['OnDemand'])")
echo "compromisso=$COMPROMISSO taxa_esperada≈$TAXA_TIPO_NOVO"

# ── Prova 3: o SLO da rota sincrona nao regrediu ──────────────────────────────
# Compara p99 e taxa de erro de 7 dias antes e 7 dias depois da migracao.
# Esperado: p99 dentro do orcamento de erro definido no L52; se subir acima
# do limiar declarado, a migracao reprova mesmo com custo menor.
aws cloudwatch get-metric-statistics \
  --namespace "AWS/ApplicationELB" --metric-name TargetResponseTime \
  --dimensions Name=TargetGroup,Value="$(terraform output -raw tg_sincrono_suffix)" \
  --start-time "$(date -u -d '7 days ago' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 3600 --statistics p99 --output table

# ── Prova 4: nenhum job do lote se perde numa interrupcao ────────────────────
# Conta mensagens que caíram na fila de mortas (DLQ) na janela do teste.
# Esperado: zero. Mensagem na DLQ significa que o checkpoint nao salvou a
# tempo, ou que a visibilidade nao foi zerada antes da instancia sumir.
aws sqs get-queue-attributes \
  --queue-url "$(terraform output -raw url_dlq_lote)" \
  --attribute-names ApproximateNumberOfMessages --output table

# ── Prova 5: o compromisso nao esta sendo desperdicado ───────────────────────
# Esperado: utilizacao >= 90% nas primeiras semanas apos a compra. Abaixo
# disso, parte do que foi comprometido nao esta cobrindo uso nenhum — o
# proprio sintoma que este laboratorio existe para evitar.
aws ce get-savings-plans-utilization \
  --time-period Start=$(date -u -d '14 days ago' +%F),End=$(date -u +%F) \
  --query 'Total.Utilization.UtilizationPercentage' --output text

#!/usr/bin/env bash
# limpeza.sh — o que o destroy leva, e o que continua cobrando de qualquer jeito
set -euo pipefail

PROJETO="${PROJETO:?defina PROJETO}"

# Esvaziar a fila antes do destroy: mensagem em voo durante a destruicao vira
# job perdido sem passar pela DLQ, porque a fila deixa de existir com ela.
aws sqs purge-queue --queue-url "$(terraform output -raw url_fila_lote)"

terraform destroy -auto-approve

echo "Recursos do Terraform removidos. O Savings Plan NAO foi tocado — nada"
echo "no destroy alcanca um compromisso assinado. Ele continua cobrando pelo"
echo "prazo inteiro, com ou sem instancia rodando."