Lab 09 — A conta no fim do mês desta arquitetura

# Rode ANTES de aplicar tag alguma. O que sair daqui e a linha de base, e e
# tambem a demonstracao do limite da ferramenta.
aws ce get-cost-and-usage --region us-east-1 \
  --time-period Start=2026-03-01,End=2026-07-01 \
  --granularity MONTHLY --metrics UnblendedCost \
  --group-by Type=DIMENSION,Key=SERVICE \
  --query 'ResultsByTime[].{Mes:TimePeriod.Start,Linhas:Groups[].{S:Keys[0],C:Metrics.UnblendedCost.Amount}}'

# Na Cadencia, o resultado foi este, em indice com marco = 1,00:
#   Elastic Container Service .... 1,00 -> 2,4   (producao + homologacao juntos)
#   EC2 - Other .................. 1,00 -> 4,1   (e AQUI que o NAT se esconde)
#   Relational Database Service .. 1,00 -> 2,0
#   CloudWatch ................... 1,00 -> 3,7
# Quatro serviços cresceram. Nenhuma linha diz QUAL PECA, e "EC2 - Other" nao e
# nem o nome de um servico que a equipe usa conscientemente.

# O mesmo dado, agora por TIPO DE USO, ja e bem mais util — e nao depende de tag:
aws ce get-cost-and-usage --region us-east-1 \
  --time-period Start=2026-06-01,End=2026-07-01 \
  --granularity MONTHLY --metrics UnblendedCost \
  --group-by Type=DIMENSION,Key=USAGE_TYPE \
  --query 'ResultsByTime[0].Groups[].{Uso:Keys[0],Custo:Metrics.UnblendedCost.Amount}' \
  --output table
# Aqui aparecem `USE1-NatGateway-Hours`, `USE1-NatGateway-Bytes`,
# `USE1-DataTransfer-Regional-Bytes` e `USE1-TimedStorage-ByteHrs` separados.
# Guarde esta lista: ela e a materia-prima da categoria de custo retroativa.

{
  "ResultsByTime": [
    {
      "TimePeriod": { "Start": "2026-08-01", "End": "2026-09-01" },
      "Total": {},
      "Groups": [
        {
          "Keys": ["Componente$api"],
          "Metrics": { "UnblendedCost": { "Amount": "104.7312", "Unit": "USD" } }
        },
        {
          "Keys": ["Componente$rede"],
          "Metrics": { "UnblendedCost": { "Amount": "82.4109", "Unit": "USD" } }
        },
        {
          "Keys": ["Componente$banco"],
          "Metrics": { "UnblendedCost": { "Amount": "61.9020", "Unit": "USD" } }
        },
        {
          "Keys": ["Componente$observabilidade"],
          "Metrics": { "UnblendedCost": { "Amount": "37.5511", "Unit": "USD" } }
        },
        {
          "Keys": ["Componente$"],
          "Metrics": { "UnblendedCost": { "Amount": "9.2884", "Unit": "USD" } }
        }
      ]
    }
  ],
  "DimensionValueAttributes": []
}

# provedor.tf — a taxonomia, e o unico lugar onde ela e escrita

# QUATRO chaves, e cada uma existe porque responde a UMA pergunta que alguem faz
# de verdade. Chave que nao tem pergunta associada nao entra: ela sera a que
# ninguem preenche, e uma tag opcional e uma tag ausente com boa intencao.
locals {
  tags = {
    # "quanto custa o ambiente que ninguem usa a noite?"
    Ambiente = var.ambiente # prod | homolog

    # "qual peca triplicou?" — e a chave central deste laboratorio
    Componente = "api" # api | banco | rede | borda | observabilidade

    # "quem decide sobre este gasto?"
    Dono = "time-pedidos"

    # "o que existe aqui fora do codigo?" — todo recurso do Terraform nasce com
    # terraform; o que aparecer sem esta chave foi criado a mao no console, e
    # desvio de infraestrutura e onde o custo surpresa costuma morar.
    Origem = "terraform"
  }
}

provider "aws" {
  region = var.regiao

  # `default_tags` aplica o mapa a quase todo recurso que aceita tag, no momento
  # da CRIACAO. Isto e o coracao do laboratorio: a tag so serve para o gasto de
  # uma hora se ela estiver no recurso NAQUELA hora. Aplicar depois conserta o
  # rateio do futuro, nunca o do mes que passou.
  #
  # Tres ressalvas que valem mais que a conveniencia:
  #  1. Recurso que nao aceita tag nao recebe nada (associacao de tabela de
  #     rotas, anexo de politica de IAM). Nao ha o que corrigir ali.
  #  2. Alguns recursos gerenciam tag por bloco proprio em vez de mapa — o grupo
  #     de auto scaling e o caso classico. A lista autoritativa e o guia de
  #     tagging do provedor; confira antes de assumir cobertura total.
  #  3. Tag aplicada a mao no console e removida no proximo `apply`, porque o
  #     provedor reconcilia. Etiquetar no console e trabalho que se perde.
  default_tags {
    tags = local.tags
  }
}

# Componente diferente, tag diferente. `merge` sobrescreve a chave do padrao, e e
# assim que a rede deixa de ser contada como se fosse a aplicacao.
resource "aws_nat_gateway" "saida" {
  count         = length(var.azs)
  allocation_id = aws_eip.nat[count.index].id
  subnet_id     = aws_subnet.publica[count.index].id

  tags = merge(local.tags, {
    Componente = "rede"
    Name       = "${var.projeto}-nat-${var.azs[count.index]}"
  })
}

# O servico ECS precisa de DUAS linhas a mais do que o L01 tinha. Sem elas, o
# servico esta etiquetado e as TASKS nao — e a cobranca de Fargate e da task.
resource "aws_ecs_service" "api" {
  name            = "api"
  cluster         = aws_ecs_cluster.principal.id
  task_definition = aws_ecs_task_definition.api.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  # Liga as tags gerenciadas do ECS: cada task nova nasce com o nome do cluster e
  # do servico, o que da rateio por servico sem depender de disciplina humana.
  enable_ecs_managed_tags = true

  # Escolhe a ORIGEM da propagacao. Com SERVICE, a task herda as tags do servico
  # — inclusive as que vieram de `default_tags`. Vale para task LANCADA DEPOIS:
  # as que ja estao rodando continuam sem etiqueta, e e por isso que este
  # laboratorio termina com um novo deploy em vez de so um `apply`.
  propagate_tags = "SERVICE"

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

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

# custo-tags.tf — ativar a chave, que e o passo que quase todo mundo esquece

# A tag no recurso NAO e uma dimensao de custo. Ela passa a ser depois de
# ativada, e o relogio disto e documentado: ate 24 h para a chave APARECER na
# pagina de tags de alocacao e ate outras 24 h para ela FICAR ATIVA. Nesse
# intervalo, filtro por tag no Cost Explorer e orcamento por tag devolvem vazio
# sem erro nenhum — e o diagnostico errado obvio e "a tag nao funciona".
resource "aws_ce_cost_allocation_tag" "taxonomia" {
  for_each = toset(["Ambiente", "Componente", "Dono", "Origem"])

  tag_key = each.value
  status  = "Active"
}

# Ativar tag NAO cria recurso cobrado, mas consome cota: existe um maximo de
# chaves ativas para os relatorios de faturamento. Veja o valor atual em
# Service Quotas / Quotas and restrictions em vez de decorar um numero.

# Categoria de custo: a saida honesta para explicar o PASSADO.
#
# Tag nao retroage no recurso. Categoria de custo, sim: a data efetiva pode ser
# o primeiro dia de um mes de ate 12 meses atras, e a regra e aplicada
# retroativamente. E ela nao depende de tag — as dimensoes que ela usa (servico,
# tipo de uso, regiao, conta) sempre existiram no dado.
#
# Por isso a Cadencia consegue reconstruir marco a junho por PECA, mesmo sem
# nenhuma tag naquele periodo. E a unica reconstrucao possivel, e ela chega ao
# nivel de tipo de uso — nao ao de "qual dos dois ambientes".
resource "aws_ce_cost_category" "peca" {
  name          = "Peca"
  rule_version  = "CostCategoryExpression.v1"
  effective_start = var.mes_inicial_retroativo # ex.: "2026-03-01T00:00:00Z"

  # O tipo de uso vem prefixado pela regiao (`USE1-NatGateway-Bytes`), e e por
  # isso que o casamento e por sufixo. Quais `match_options` cada dimensao aceita
  # varia: confira na referencia de expressao de categoria de custo antes de
  # assumir, porque opcao invalida falha no `apply` e opcao valida que casa com
  # nada falha em silencio — o segundo e o caro.
  rule {
    value = "rede"
    rule {
      dimension {
        key           = "USAGE_TYPE"
        values        = ["NatGateway-Hours", "NatGateway-Bytes", "VpcEndpoint-Hours", "VpcEndpoint-Bytes"]
        match_options = ["ENDS_WITH"]
      }
    }
  }

  rule {
    value = "observabilidade"
    rule {
      dimension {
        key    = "SERVICE"
        values = ["AmazonCloudWatch"]
      }
    }
  }

  rule {
    value = "banco"
    rule {
      dimension {
        key    = "SERVICE"
        values = ["Amazon Relational Database Service"]
      }
    }
  }

  # Sem esta linha, tudo o que nao casou com regra alguma fica como nao
  # categorizado — que e informacao, nao defeito: mede o quanto do gasto o seu
  # recorte ainda nao explica.
  default_value = "nao-classificado"
}

# Retroage o STATUS DE ATIVACAO das chaves por ate 12 meses. A data tem de ser o
# primeiro dia de um mes, nao pode ser anterior aos 12 meses e nao pode ser futura.
aws ce start-cost-allocation-tag-backfill \
  --backfill-from 2025-09-01T00:00:00Z

# Uma requisicao a cada 24 h, e nao se pode iniciar outra com uma em andamento.
aws ce list-cost-allocation-tag-backfill-history --output table

# O QUE ELE DEVOLVE, e o que nao devolve — a distincao inteira do modulo:
#   · mes em que a tag ESTAVA no recurso -> o valor de tag aparece agora
#   · mes em que a tag NAO ESTAVA        -> continua sem valor, para sempre
#
# Na Cadencia, as chaves definidas por nos so passaram a existir em agosto, entao o
# backfill nao devolveu nada delas. Vale rodar de todo modo por causa das geradas
# pela AWS: se `aws:ecs:serviceName` estiver na lista de AWSGenerated, ela pode ter
# estado nas tasks desde antes, e ai a separacao entre os dois servicos aparece
# retroativamente. CONFIRA na sua conta em vez de supor: se as tags gerenciadas do
# ECS estavam desligadas no periodo, nao ha nada a recuperar por esse caminho.

# Depois de qualquer backfill, o dado ainda precisa de um ciclo para refletir:
# Cost Explorer, Data Exports e o relatorio de custo e uso atualizam uma vez ao dia.

# orcamento.tf — o alerta que chega ANTES, e o topico que costuma nao entregar

resource "aws_sns_topic" "custo" {
  name = "${var.projeto}-alerta-custo"
}

# A falha silenciosa numero um de toda esta montagem. O Budgets publica no topico
# como um SERVICO, nao como voce: sem esta politica, o orcamento estoura, a
# notificacao e tentada, falha, e ninguem e avisado de nada. O sintoma e "criei o
# orcamento e nunca recebi e-mail" — e o orcamento esta correto.
data "aws_iam_policy_document" "topico_custo" {
  statement {
    effect = "Allow"
    principals {
      type        = "Service"
      identifiers = ["budgets.amazonaws.com"]
    }
    actions   = ["SNS:Publish"]
    resources = [aws_sns_topic.custo.arn]

    # Confused deputy: sem esta condicao, o principal de servico do Budgets de
    # QUALQUER conta poderia publicar no seu topico.
    condition {
      test     = "StringEquals"
      variable = "aws:SourceAccount"
      values   = [data.aws_caller_identity.atual.account_id]
    }
  }
}

resource "aws_sns_topic_policy" "custo" {
  arn    = aws_sns_topic.custo.arn
  policy = data.aws_iam_policy_document.topico_custo.json
}

# ── Orcamento 1: a conta inteira, como rede de seguranca ─────────────────────
resource "aws_budgets_budget" "conta" {
  name         = "${var.projeto}-conta"
  budget_type  = "COST"
  limit_amount = var.limite_conta # valor definido por VOCE, no seu contexto
  limit_unit   = var.moeda
  time_unit    = "MONTHLY"

  # Realizado em 80%: registro historico, chega depois do gasto.
  notification {
    comparison_operator        = "GREATER_THAN"
    threshold                  = 80
    threshold_type             = "PERCENTAGE"
    notification_type          = "ACTUAL"
    subscriber_sns_topic_arns  = [aws_sns_topic.custo.arn]
  }

  # PREVISTO em 100%: o unico limiar que avisa enquanto ainda ha mes para reagir.
  # O Budgets reavalia ate tres vezes ao dia, entao "tempo para reagir" e da
  # ordem de horas — nao de minutos.
  notification {
    comparison_operator       = "GREATER_THAN"
    threshold                 = 100
    threshold_type            = "PERCENTAGE"
    notification_type         = "FORECASTED"
    subscriber_sns_topic_arns = [aws_sns_topic.custo.arn]
  }
}

# ── Orcamento 2: por VALOR DE TAG — o entregavel do laboratorio ──────────────
resource "aws_budgets_budget" "por_componente" {
  for_each = var.limite_por_componente # { api = "...", banco = "...", rede = "..." }

  name         = "${var.projeto}-componente-${each.key}"
  budget_type  = "COST"
  limit_amount = each.value
  limit_unit   = var.moeda
  time_unit    = "MONTHLY"

  # O formato e `user:<chave>$<valor>`. O prefixo `user:` nao e enfeite: a
  # documentacao de filtros de orcamento e explicita ao dizer que chave definida
  # por usuario usa esse prefixo no dado de faturamento — e que a tag precisa
  # estar ATIVADA para servir de filtro. Filtro sobre chave inativa nao da erro:
  # da zero.
  # `format` em vez de interpolacao direta porque o `$` do formato colide com a
  # sintaxe `${...}` do HCL: escrever `"...$${each.key}"` produziria o literal
  # `${each.key}`, e o filtro casaria com nada — em silencio, devolvendo zero.
  cost_filter {
    name   = "TagKeyValue"
    values = [format("user:Componente$%s", each.key)]
  }

  notification {
    comparison_operator       = "GREATER_THAN"
    threshold                 = 100
    threshold_type            = "PERCENTAGE"
    notification_type         = "FORECASTED"
    subscriber_sns_topic_arns = [aws_sns_topic.custo.arn]
  }

  depends_on = [aws_ce_cost_allocation_tag.taxonomia]
}

# ── Orcamento 3: de USO, nao de custo — para a dimensao que engana ───────────
# Orcamento de uso limita a QUANTIDADE de uma unidade de medida. Aqui ele vigia
# GB processados pelo NAT: se esse numero dispara, houve mudanca de comportamento
# da aplicacao, e isso e informacao diferente de "gastei mais".
resource "aws_budgets_budget" "nat_gb" {
  name         = "${var.projeto}-nat-gb"
  budget_type  = "USAGE"
  limit_amount = var.limite_nat_gb
  limit_unit   = "GB"
  time_unit    = "MONTHLY"

  cost_filter {
    name   = "UsageType"
    values = ["${var.prefixo_regiao}-NatGateway-Bytes"]
  }

  notification {
    comparison_operator       = "GREATER_THAN"
    threshold                 = 100
    threshold_type            = "PERCENTAGE"
    notification_type         = "FORECASTED"
    subscriber_sns_topic_arns = [aws_sns_topic.custo.arn]
  }
}

# ── Deteccao de anomalia: pega o que nenhum limite previu ────────────────────
resource "aws_ce_anomaly_monitor" "servicos" {
  name              = "${var.projeto}-por-servico"
  monitor_type      = "DIMENSIONAL"
  monitor_dimension = "SERVICE"
}

resource "aws_ce_anomaly_subscription" "servicos" {
  name      = "${var.projeto}-anomalia"
  frequency = "DAILY"
  monitor_arn_list = [aws_ce_anomaly_monitor.servicos.arn]

  subscriber {
    type    = "SNS"
    address = aws_sns_topic.custo.arn
  }

  # O limiar por EXPRESSAO evita ruido: so avisa quando o impacto absoluto do
  # desvio passa do valor que VOCE considera relevante.
  threshold_expression {
    dimension {
      key           = "ANOMALY_TOTAL_IMPACT_ABSOLUTE"
      match_options = ["GREATER_THAN_OR_EQUAL"]
      values        = [var.impacto_minimo_anomalia]
    }
  }
}

// Servicos/RateioPorTag.cs — le o custo agrupado por valor de tag.
//
// Por que isto vive na aplicacao e nao num script: o numero que importa nao e o
// custo, e o custo POR PEDIDO. O denominador esta no banco desta aplicacao, e
// juntar as duas metades em qualquer outro lugar exigiria copiar dado de negocio
// para fora.

using Amazon;
using Amazon.CostExplorer;
using Amazon.CostExplorer.Model;
using Microsoft.Extensions.Caching.Memory;

namespace Pedidos.Servicos;

public sealed record FatiaDeCusto(string Valor, decimal Custo);

public sealed record Rateio(
    IReadOnlyList<FatiaDeCusto> Fatias,
    decimal Total,
    decimal SemValorDeTag,
    double PercentualSemDono);

public sealed class RateioPorTag(
    IAmazonCostExplorer ce,
    IMemoryCache cache,
    ILogger<RateioPorTag> log)
{
    // O dado de faturamento e atualizado no maximo uma vez por dia. Consultar de
    // novo antes disso gasta requisicao paga e devolve o MESMO numero: o cache
    // aqui nao e otimizacao, e coerencia com a taxa de atualizacao da fonte.
    private static readonly TimeSpan Janela = TimeSpan.FromHours(6);

    public async Task<Rateio> DoMesAsync(string chave, CancellationToken ct)
    {
        var hoje = DateTime.UtcNow.Date;
        var inicio = new DateTime(hoje.Year, hoje.Month, 1);

        return (await cache.GetOrCreateAsync($"rateio:{chave}:{inicio:yyyy-MM}", async entrada =>
        {
            entrada.AbsoluteExpirationRelativeToNow = Janela;
            return await ConsultarAsync(chave, inicio, hoje.AddDays(1), ct);
        }))!;
    }

    private async Task<Rateio> ConsultarAsync(
        string chave, DateTime de, DateTime ate, CancellationToken ct)
    {
        var pedido = new GetCostAndUsageRequest
        {
            TimePeriod = new DateInterval
            {
                Start = de.ToString("yyyy-MM-dd"),
                End = ate.ToString("yyyy-MM-dd") // fim EXCLUSIVO
            },
            Granularity = Granularity.MONTHLY,

            // UnblendedCost e a taxa que a conta pagou pelo uso. Em conta unica sem
            // compromisso comprado, ele coincide com o amortizado; a distincao passa
            // a importar quando houver Savings Plans, e ai o assunto e o L59.
            Metrics = ["UnblendedCost"],

            GroupBy =
            [
                new GroupDefinition { Type = GroupDefinitionType.TAG, Key = chave }
            ]
        };

        var fatias = new List<FatiaDeCusto>();
        decimal semDono = 0m;

        // Paginacao explicita: cada requisicao paginada da API do Cost Explorer e
        // cobrada. Vale saber disso antes de colocar a chamada num laco de painel
        // que atualiza a cada 30 segundos.
        string? proxima = null;
        do
        {
            pedido.NextPageToken = proxima;
            var r = await ce.GetCostAndUsageAsync(pedido, ct);

            foreach (var grupo in r.ResultsByTime.SelectMany(t => t.Groups))
            {
                // A chave do grupo vem como "Componente$api". Quando o recurso nao
                // tinha a tag na hora do gasto, ela vem como "Componente$" — o
                // valor vazio. Este e o balde sem dono, e ele e a medida mais
                // honesta da qualidade da sua instrumentacao.
                var bruto = grupo.Keys[0];
                var valor = bruto.Contains('$') ? bruto[(bruto.IndexOf('$') + 1)..] : bruto;
                var custo = decimal.Parse(
                    grupo.Metrics["UnblendedCost"].Amount,
                    System.Globalization.CultureInfo.InvariantCulture);

                if (string.IsNullOrEmpty(valor)) semDono += custo;
                else fatias.Add(new FatiaDeCusto(valor, custo));
            }

            proxima = r.NextPageToken;
        } while (!string.IsNullOrEmpty(proxima));

        var total = fatias.Sum(f => f.Custo) + semDono;
        var percentual = total == 0 ? 0 : (double)(semDono / total) * 100;

        if (percentual > 5)
        {
            // Acima disto o rateio nao e confiavel e o orcamento por tag mente para
            // baixo. Registrar como aviso e o que impede alguem apresentar o grafico
            // como se ele fechasse.
            log.LogWarning(
                "Rateio por {Chave} com {Percentual:F1}% sem valor de tag: o orcamento por tag esta subestimado",
                chave, percentual);
        }

        return new Rateio(
            fatias.OrderByDescending(f => f.Custo).ToList(), total, semDono, percentual);
    }
}

// Program.cs — o cliente, a rota interna e o custo por pedido

using Amazon;
using Amazon.CostExplorer;
using Pedidos.Servicos;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMemoryCache();

// O endpoint do Cost Explorer e GLOBAL e atendido em us-east-1: o dado de
// faturamento nao e regional. Configurar o cliente com a regiao da aplicacao faz
// a chamada falhar por endpoint inexistente, e o erro nao menciona faturamento.
builder.Services.AddSingleton<IAmazonCostExplorer>(_ =>
    new AmazonCostExplorerClient(new AmazonCostExplorerConfig
    {
        RegionEndpoint = RegionEndpoint.USEast1
    }));

builder.Services.AddSingleton<RateioPorTag>();

var app = builder.Build();

// Rota INTERNA. Custo e dado sensivel de negocio: ela nao vai para o CloudFront,
// e o caminho fica atras da autenticacao que o L12 constroi. Enquanto isso, ela
// so responde na rede privada.
app.MapGet("/interno/rateio", async (
        RateioPorTag rateio, IContagemDePedidos pedidos, CancellationToken ct) =>
    {
        var r = await rateio.DoMesAsync("Componente", ct);
        var quantidade = await pedidos.DoMesAtualAsync(ct);

        return Results.Ok(new
        {
            porComponente = r.Fatias,
            total = r.Total,
            semDono = r.SemValorDeTag,
            percentualSemDono = Math.Round(r.PercentualSemDono, 1),

            // O indicador que sobe ou desce independente do total. Ele e o unico
            // numero desta resposta que serve para decidir alguma coisa.
            custoPorMilPedidos = quantidade == 0
                ? (decimal?)null
                : Math.Round(r.Total / quantidade * 1000, 4),

            // Sem esta linha, alguem vai ler o numero de hoje como sendo de hoje.
            atualizadoAte = "o dado de faturamento e atualizado ao menos uma vez por dia"
        });
    })
    .WithName("RateioInterno");

app.Run();

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "LerCustoDaContaEmQueRodo",
      "Effect": "Allow",
      "Action": [
        "ce:GetCostAndUsage",
        "ce:GetDimensionValues",
        "ce:GetTags"
      ],
      "Resource": "*"
    }
  ]
}

# Prova 1: nao existe recurso sem as quatro chaves.
# O rateio so fecha se a etiqueta estiver em TODO recurso. Este e o unico teste
# que se roda ANTES de esperar 24 h por qualquer coisa.

REGIAO=$(terraform output -raw regiao)

total=$(aws resourcegroupstaggingapi get-resources --region "$REGIAO" \
  --query 'length(ResourceTagMappingList)' --output text)

com_tag=$(aws resourcegroupstaggingapi get-resources --region "$REGIAO" \
  --tag-filters Key=Componente \
  --query 'length(ResourceTagMappingList)' --output text)

echo "recursos: $total · com Componente: $com_tag"

# APROVA: os dois numeros iguais. Na Cadencia: 47 e 47.
# REPROVA: diferenca. Liste os culpados por ARN antes de discutir causa:
aws resourcegroupstaggingapi get-resources --region "$REGIAO" \
  --query 'ResourceTagMappingList[?!(Tags[?Key==`Componente`])].ResourceARN' \
  --output table

# RESSALVA HONESTA: esta API cobre os servicos que ela suporta, nao 100% do que
# existe na conta. Recurso de servico nao suportado nao aparece aqui e ainda
# assim cobra — a checagem que fecha o buraco e o balde sem dono da prova 3.

# Prova 2: as quatro chaves estao ATIVAS como tag de alocacao de custo.
# Esta prova tem relogio: ate 24 h para a chave APARECER e ate outras 24 h para
# ela ATIVAR. Rodar logo depois do apply e ver vazio nao e defeito.

aws ce list-cost-allocation-tags --status Active \
  --query 'CostAllocationTags[].{Chave:TagKey,Tipo:Type,Status:Status}' \
  --output table

# APROVA: as 4 chaves definidas por usuario com Status=Active. Na Cadencia, no
# dia seguinte: 4 de 4.
# REPROVA de dois modos distintos, e a diferenca importa:
#   · chave AUSENTE da lista  -> ela ainda nao foi vista no dado de faturamento;
#     confirme que existe algum recurso com ela e espere o ciclo.
#   · chave presente e Inactive -> a ativacao nao foi aplicada. Confira o estado
#     do recurso `aws_ce_cost_allocation_tag` no Terraform.

# As geradas pela AWS aparecem separadas, e vale olhar: elas podem ter estado nos
# recursos desde sempre, o que muda o que o backfill consegue recuperar.
aws ce list-cost-allocation-tags --type AWSGenerated --output table

# Prova 3: o rateio fecha, e o balde sem dono e pequeno.
# Esta e a prova central do laboratorio: ela mede a QUALIDADE da instrumentacao,
# nao a existencia dela.

INICIO=$(date -u +%Y-%m-01)
FIM=$(date -u -v+1d +%Y-%m-%d 2>/dev/null || date -u -d "+1 day" +%Y-%m-%d)

aws ce get-cost-and-usage --region us-east-1 \
  --time-period Start=$INICIO,End=$FIM \
  --granularity MONTHLY --metrics UnblendedCost \
  --group-by Type=TAG,Key=Componente \
  --query 'ResultsByTime[0].Groups[].{Valor:Keys[0],Custo:Metrics.UnblendedCost.Amount}' \
  --output table

# APROVA: a linha `Componente$` (valor VAZIO) fica abaixo de 5% do total.
# Na Cadencia, no primeiro mes completo: 3,2%.
# O que legitimamente sobra nesse balde: taxa de suporte, imposto e algumas
# linhas de transferencia que nao carregam tag de recurso. Zerar e impossivel, e
# perseguir zero e desperdicio de atencao.
# REPROVA acima de 5%: o orcamento por tag esta subestimado NA MESMA PROPORCAO.
# Volte a prova 1 antes de olhar mais nada.

# Prova 4: as tasks carregam a etiqueta — nao so o servico.
# O gasto de Fargate e cobrado pela TASK. Servico etiquetado com task sem
# etiqueta produz uma fatura de computacao inteira dentro do balde sem dono, e o
# grafico continua parecendo correto.

CLUSTER=$(terraform output -raw cluster)

for arn in $(aws ecs list-tasks --cluster "$CLUSTER" --query 'taskArns[]' --output text); do
  aws ecs describe-tasks --cluster "$CLUSTER" --tasks "$arn" --include TAGS \
    --query 'tasks[0].tags[?key==`Componente` || key==`Ambiente`].[key,value]' \
    --output text
done

# APROVA: cada task devolve as duas linhas. Na Cadencia: 2 tasks, 4 linhas.
# REPROVA com saida vazia, e ha DUAS causas com correcoes diferentes:
#   · propagacao ausente -> falta `enable_ecs_managed_tags` e `propagate_tags`.
#   · propagacao presente e task ANTIGA -> a propagacao vale para task lancada
#     depois. Force um novo lancamento; nada retroage aqui tambem:
#     aws ecs update-service --cluster "$CLUSTER" --service api --force-new-deployment

# Prova 5: o alerta chega, e chega pelo PREVISTO.
# Nao existe como forcar o Budgets a notificar na hora: ele reavalia ate tres
# vezes ao dia. O que se prova aqui e que o caminho inteiro funciona.

# a) o orcamento ja calcula realizado E previsto
aws budgets describe-budget --region us-east-1 \
  --account-id "$(aws sts get-caller-identity --query Account --output text)" \
  --budget-name "pedidos-componente-rede" \
  --query 'Budget.{Limite:BudgetLimit.Amount,Realizado:CalculatedSpend.ActualSpend.Amount,Previsto:CalculatedSpend.ForecastedSpend.Amount}'

# APROVA: `Previsto` preenchido e MAIOR que `Realizado`. Na Cadencia, no dia 9:
# realizado em 31% do limite e previsto em 104% — o alerta que interessa e este,
# e o de realizado nao teria dito nada ainda.
# REPROVA com `Previsto` nulo: o orcamento e novo demais para haver serie, ou o
# filtro nao casa com nada (volte a prova 2: chave inativa devolve zero).

# b) o topico entrega de verdade — teste a POLITICA, nao o orcamento
aws sns publish --topic-arn "$(terraform output -raw topico_custo)" \
  --subject "teste de caminho" --message "se isto nao chegar, o alerta real tambem nao chega"

# APROVA: mensagem recebida no canal e no e-mail inscrito.
# REPROVA: revise a politica do topico. Sem o principal `budgets.amazonaws.com`
# autorizado, o orcamento estoura e a notificacao falha em silencio — e o
# sintoma e indistinguivel de "nao estourei nada".

# 1. Desativa a chave central
aws ce update-cost-allocation-tags-status \
  --cost-allocation-tags-status TagKey=Componente,Status=Inactive

# 2. Consulta o orcamento por componente. Ele responde, sem erro, com zero.
aws budgets describe-budget --region us-east-1 \
  --account-id "$(aws sts get-caller-identity --query Account --output text)" \
  --budget-name "pedidos-componente-rede" \
  --query 'Budget.CalculatedSpend'

# O erro de raciocinio que isto treina contra: interpretar zero como "nao gastei".
# Zero e a resposta correta para a pergunta "quanto custou o que casa com este
# filtro", e o filtro nao casa com nada porque a dimensao nao existe mais.

# 3. Reativa, e aceite o relogio: pode levar ate 24 h para voltar a valer.
aws ce update-cost-allocation-tags-status \
  --cost-allocation-tags-status TagKey=Componente,Status=Active

# 1. Orcamentos e assinatura de anomalia primeiro: eles referenciam o topico.
terraform destroy \
  -target=aws_budgets_budget.conta \
  -target=aws_budgets_budget.por_componente \
  -target=aws_budgets_budget.nat_gb \
  -target=aws_ce_anomaly_subscription.servicos \
  -target=aws_ce_anomaly_monitor.servicos

# 2. Gravador de configuracao e a regra — o que cobra parado nesta montagem.
terraform destroy \
  -target=aws_config_config_rule.tags_obrigatorias \
  -target=aws_config_configuration_recorder.principal

# 3. Topico e politica.
terraform destroy -target=aws_sns_topic_policy.custo -target=aws_sns_topic.custo

# 4. As tags de alocacao: DECIDA em vez de destruir por reflexo. Manter ativado nao
#    cobra nada e preserva a serie historica; desativar interrompe a coluna a partir
#    de agora, e a religacao passa pelos mesmos dois relogios de 24 h.
#    Se for desativar mesmo:
# aws ce update-cost-allocation-tags-status \
#   --cost-allocation-tags-status TagKey=Componente,Status=Inactive

# 5. Confirme que nada de faturamento ficou de pe alem do que voce decidiu manter.
aws budgets describe-budgets --region us-east-1 \
  --account-id "$(aws sts get-caller-identity --query Account --output text)" \
  --query 'Budgets[].BudgetName'
aws ce get-anomaly-monitors --query 'AnomalyMonitors[].MonitorName'
aws configservice describe-configuration-recorders --query 'ConfigurationRecorders[].name'

# 6. E a checagem que este laboratorio existe para ensinar a fazer: o que dos
#    laboratorios ANTERIORES continua cobrando parado. Elastic IP sem associacao
#    cobra hora ligada por estar ocioso — mas desde fev/2024 TODO IPv4 publico
#    cobra por hora, associado ou nao (o EIP do NAT Gateway em uso tambem), entao
#    esta lista e so o excedente facil de esquecer, nao o total do IPv4 publico:
aws ec2 describe-addresses \
  --query 'Addresses[?AssociationId==null].{IP:PublicIp,Alocacao:AllocationId}' \
  --output table   # APROVA vazio; endereco ocioso paga a mesma hora que o associado

aws ec2 describe-nat-gateways \
  --filter Name=state,Values=available \
  --query 'NatGateways[].{Id:NatGatewayId,AZ:SubnetId}' --output table

aws logs describe-log-groups \
  --query 'logGroups[?retentionInDays==null].logGroupName' --output table
  # Cada nome que sair aqui retem log para sempre. E a correcao de uma linha.