claudiao 1.0.0

package/templates/CLOUD-CLI-GUIDE.md

@@ -0,0 +1,405 @@
+# Guia: Cloud Specialists + CLI Direto
+
+Como conectar o Claude Code diretamente nas suas clouds via CLI para validar arquitetura, investigar erros, analisar logs e operar infraestrutura — tudo conversando em linguagem natural.
+
+> **Este é o caso de uso mais poderoso do toolkit.** Você conecta a CLI da cloud, e o Claude Code vira seu copiloto de infra — roda comandos reais, interpreta outputs, e te guia em troubleshooting ao vivo.
+
+---
+
+## Como funciona
+
+```
+Você: "por que o ECS task tá reiniciando?"
+  │
+  ▼
+Claude Code detecta contexto de AWS
+  │
+  ▼
+aws-specialist é invocado automaticamente
+  │
+  ▼
+Roda: aws ecs describe-tasks, aws logs tail, aws cloudwatch get-metric-data...
+  │
+  ▼
+Analisa os outputs e te dá o diagnóstico + sugestão de fix
+```
+
+Os cloud specialists (`aws-specialist`, `gcp-specialist`, `azure-specialist`) têm acesso à ferramenta **Bash**, o que significa que podem executar qualquer comando CLI da cloud. A única coisa que você precisa garantir é que a CLI esteja autenticada.
+
+---
+
+## 1. Setup: Autenticação das CLIs
+
+### AWS — SSO Login
+
+```bash
+# 1. Instale a AWS CLI v2
+# https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
+
+# 2. Configure o SSO (uma vez)
+aws configure sso
+# Preencha: SSO start URL, região, account ID, role name
+# Isso cria um profile em ~/.aws/config
+
+# 3. Faça login (dura ~8h, repita quando expirar)
+aws sso login --profile meu-profile
+
+# 4. Exporte o profile pra sessão (IMPORTANTE — sem isso o Claude não sabe qual profile usar)
+export AWS_PROFILE=meu-profile
+
+# 5. Teste
+aws sts get-caller-identity
+```
+
+**Dica pro dia a dia:** adicione no seu `.bashrc` / `.zshrc`:
+
+```bash
+# Profile padrão pra AWS SSO
+export AWS_PROFILE=meu-profile
+
+# Alias pra login rápido
+alias awslogin='aws sso login --profile meu-profile'
+```
+
+### GCP — gcloud Auth
+
+```bash
+# 1. Instale o gcloud CLI
+# https://cloud.google.com/sdk/docs/install
+
+# 2. Faça login (abre o browser)
+gcloud auth login
+
+# 3. Configure o projeto padrão
+gcloud config set project meu-projeto-id
+
+# 4. Autentique as credenciais de aplicação (necessário pra algumas APIs)
+gcloud auth application-default login
+
+# 5. Teste
+gcloud config list
+gcloud projects describe meu-projeto-id
+```
+
+**Dica pro dia a dia:** configure múltiplos projetos com `gcloud config configurations`:
+
+```bash
+# Crie configurações nomeadas
+gcloud config configurations create producao
+gcloud config set project meu-projeto-prod
+gcloud config set compute/region us-east1
+
+gcloud config configurations create staging
+gcloud config set project meu-projeto-staging
+gcloud config set compute/region us-east1
+
+# Troque entre elas
+gcloud config configurations activate producao
+```
+
+### Azure — az login
+
+```bash
+# 1. Instale o Azure CLI
+# https://learn.microsoft.com/en-us/cli/azure/install-azure-cli
+
+# 2. Faça login (abre o browser)
+az login
+
+# 3. Selecione a subscription
+az account set --subscription "minha-subscription-id"
+
+# 4. Teste
+az account show
+```
+
+**Dica pro dia a dia:** para múltiplas subscriptions:
+
+```bash
+# Liste subscriptions
+az account list --output table
+
+# Troque rápido
+alias azprod='az account set --subscription "prod-sub-id"'
+alias azstaging='az account set --subscription "staging-sub-id"'
+```
+
+### Multi-cloud: todas conectadas ao mesmo tempo
+
+Você pode ter AWS, GCP e Azure autenticadas simultaneamente. O Claude Code usa o specialist correto baseado no contexto:
+
+```bash
+# Conecte tudo antes de abrir o Claude Code
+aws sso login --profile meu-profile
+gcloud auth login
+az login
+
+# Abra o Claude Code
+claude
+```
+
+---
+
+## 2. Permissões do Claude Code
+
+Quando o Claude Code roda um comando CLI pela primeira vez, ele pede sua permissão. Você pode:
+
+- **Aprovar caso a caso** — mais seguro, recomendado no início
+- **Aprovar por sessão** — aprova uma vez e vale até fechar
+- **Configurar permissões automáticas** — pra comandos read-only que você usa sempre
+
+### Permissões recomendadas (read-only seguras)
+
+Se você quer que o Claude rode comandos de leitura sem perguntar toda vez, configure em `~/.claude/settings.json`:
+
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(aws sts *)",
+      "Bash(aws ecs describe-*)",
+      "Bash(aws ecs list-*)",
+      "Bash(aws logs *)",
+      "Bash(aws cloudwatch *)",
+      "Bash(aws rds describe-*)",
+      "Bash(aws s3 ls *)",
+      "Bash(aws ec2 describe-*)",
+      "Bash(aws iam list-*)",
+      "Bash(aws iam get-*)",
+      "Bash(aws lambda list-*)",
+      "Bash(aws lambda get-*)",
+      "Bash(gcloud *)",
+      "Bash(az *)"
+    ]
+  }
+}
+```
+
+> **Atenção:** NUNCA adicione permissões de escrita/delete automáticas (ex: `aws ecs update-*`, `gcloud run deploy`, `az webapp delete`). Operações destrutivas devem sempre pedir confirmação.
+
+---
+
+## 3. Casos de uso reais
+
+### Troubleshooting: "por que tá dando erro?"
+
+```bash
+# Situação: task do ECS reiniciando
+você: O serviço orders-api no ECS tá com tasks reiniciando a cada 5 minutos.
+      Investiga o que tá acontecendo.
+
+# O Claude Code (via aws-specialist) vai:
+# 1. aws ecs describe-services → ver status e desired/running count
+# 2. aws ecs describe-tasks → ver stopped reason
+# 3. aws logs tail → pegar os últimos logs do container
+# 4. aws cloudwatch get-metric-data → ver CPU/memory
+# 5. Te dar o diagnóstico: "OOM kill — container usando 480MB com limit de 512MB"
+# 6. Sugerir: "aumente memoryReservation pra 1024 no task definition"
+```
+
+```bash
+# Situação: Cloud Run retornando 503
+você: O serviço de auth no Cloud Run tá retornando 503 intermitente.
+      Olha os logs e descobre o que tá acontecendo.
+
+# O Claude Code (via gcp-specialist) vai:
+# 1. gcloud run services describe → ver config e status
+# 2. gcloud logging read → filtrar logs de erro
+# 3. gcloud run revisions list → ver se tem revisão falhando
+# 4. Diagnóstico: "cold start de 8s + timeout de 10s = 503 em picos"
+# 5. Sugestão: "configure min-instances=1 e aumente timeout pra 30s"
+```
+
+### Validação de arquitetura: "tá configurado certo?"
+
+```bash
+# Validar security groups
+você: Valida os security groups do RDS de produção.
+      Tem alguma porta exposta que não deveria?
+
+# O Claude Code vai:
+# 1. aws rds describe-db-instances → pegar o SG associado
+# 2. aws ec2 describe-security-groups → listar regras de ingress/egress
+# 3. Análise: "porta 5432 aberta pra 0.0.0.0/0 — CRÍTICO"
+# 4. Fix: "restrinja pra CIDR do VPC: 10.0.0.0/16"
+```
+
+```bash
+# Verificar IAM
+você: Lista as permissões da role do ECS task e diz se tem alguma
+      permissão excessiva (princípio do least privilege).
+
+# O Claude Code vai:
+# 1. aws iam list-attached-role-policies
+# 2. aws iam get-policy → pegar o policy document de cada uma
+# 3. Análise: "tem AmazonS3FullAccess — deveria ter apenas s3:GetObject no bucket específico"
+```
+
+### Análise de custos: "quanto tá custando?"
+
+```bash
+# Breakdown de custos
+você: Pega o custo dos últimos 30 dias por serviço e me diz onde tá
+      o maior gasto e o que posso otimizar.
+
+# O Claude Code vai:
+# 1. aws ce get-cost-and-usage → custo por serviço
+# 2. Análise: "RDS: $450/mês (63%) — db.r5.xlarge rodando 24/7"
+# 3. Sugestão: "considere Reserved Instance (economia de ~40%) ou
+#    Aurora Serverless v2 se o workload é variável"
+```
+
+### Análise de logs: "o que aconteceu?"
+
+```bash
+# Filtrar logs por padrão
+você: Busca nos logs do CloudWatch do serviço payments-api
+      todas as ocorrências de "timeout" nas últimas 2 horas.
+      Agrupa por endpoint e me diz qual tá pior.
+
+# O Claude Code vai:
+# 1. aws logs filter-log-events com pattern "timeout"
+# 2. Agrupa e analisa: "POST /payments/process: 47 timeouts (89%)"
+# 3. Sugestão: "investiga o downstream — pode ser o gateway de pagamento"
+```
+
+```bash
+# BigQuery — analisar dados
+você: Roda uma query no BigQuery pra ver os top 10 endpoints
+      com maior latência p99 nas últimas 24h.
+
+# O Claude Code vai:
+# 1. bq query --use_legacy_sql=false 'SELECT ...'
+# 2. Formata resultado em tabela
+# 3. Analisa: "GET /api/reports/export tem p99 de 12s — provavelmente precisa de paginação"
+```
+
+### Operações guiadas: "me ajuda a fazer X"
+
+```bash
+# Deploy guiado
+você: Preciso fazer deploy de uma nova versão do serviço users-api no ECS.
+      Me guia passo a passo — quero entender cada etapa antes de executar.
+
+# O Claude Code vai:
+# 1. Mostrar a task definition atual
+# 2. Explicar o que vai mudar
+# 3. Pedir confirmação ANTES de cada comando destrutivo
+# 4. Monitorar o deploy: aws ecs wait services-stable
+# 5. Validar: aws ecs describe-services → running count == desired
+```
+
+```bash
+# Criar recurso com IaC
+você: Preciso de um bucket S3 pra armazenar uploads com:
+      - Versionamento habilitado
+      - Lifecycle: mover pra Glacier após 90 dias
+      - Bloqueio de acesso público
+      Gera o Terraform.
+
+# O Claude Code vai:
+# 1. Verificar se já existe infra Terraform no projeto
+# 2. Seguir o padrão existente (module structure, naming)
+# 3. Gerar o código Terraform completo
+# 4. Sugerir: "rode terraform plan pra validar antes do apply"
+```
+
+---
+
+## 4. Dicas avançadas
+
+### Combine clouds num único pedido
+
+```bash
+você: Compara o custo de rodar nosso serviço de API (Node.js, 2 instâncias,
+      4GB RAM, ~500k req/mês) na AWS (Fargate), GCP (Cloud Run) e Azure
+      (Container Apps). Usa as CLIs pra pegar preços atuais se possível.
+```
+
+### Use ultrathink pra problemas complexos
+
+```bash
+você: Ultrathink: nosso serviço de pagamentos tá com latência crescente.
+      Investiga usando CloudWatch metrics (CPU, memória, network),
+      logs do ECS, e métricas do RDS. Correlaciona tudo e me dá
+      o diagnóstico mais provável.
+```
+
+### Subagents em paralelo pra investigação multi-cloud
+
+```bash
+você: Use subagents em paralelo pra:
+      1. Verificar saúde dos serviços ECS na AWS (cluster production)
+      2. Verificar os Cloud Run services no GCP (projeto analytics)
+      3. Verificar alarmes ativos no CloudWatch
+      Consolida num status report.
+```
+
+### MCP Servers: superpoderes extras pra AWS
+
+O `aws-specialist` tem acesso a dois MCP servers que ampliam suas capacidades:
+
+| MCP Server | O que faz |
+|------------|-----------|
+| `mcp__aws-docs` | Busca e lê documentação oficial da AWS em tempo real |
+| `mcp__aws-logs` | Roda CloudWatch Log Insights queries, analisa métricas e alarmes |
+
+Isso significa que além dos comandos CLI, o Claude Code pode:
+
+```bash
+# Buscar na documentação oficial
+você: Qual o limite de connections simultâneas do RDS PostgreSQL db.r5.large?
+# → aws-specialist consulta a doc oficial via MCP e responde com source
+
+# Rodar Log Insights queries
+você: Roda uma query no CloudWatch Logs pra achar os erros mais
+      frequentes do serviço orders-api na última hora.
+# → Usa o MCP aws-logs pra rodar a query direto, sem precisar montar o JSON do CLI
+
+# Verificar alarmes
+você: Tem algum alarme disparando agora na minha conta AWS?
+# → Usa o MCP pra listar alarmes ativos com contexto
+```
+
+Para configurar os MCP servers, consulte a documentação do Claude Code sobre [MCP servers](https://docs.anthropic.com/en/docs/claude-code/mcp).
+
+---
+
+## 5. Checklist: tá tudo pronto?
+
+Antes de usar os cloud specialists com CLI direto, confirme:
+
+- [ ] **AWS CLI v2** instalada (`aws --version`)
+- [ ] **gcloud CLI** instalada (`gcloud --version`)
+- [ ] **Azure CLI** instalada (`az --version`)
+- [ ] **Login ativo** na(s) cloud(s) que vai usar
+- [ ] **Profile/projeto padrão** configurado (ou exportado via env var)
+- [ ] **Testou** com comando simples (`aws sts get-caller-identity`, `gcloud config list`, `az account show`)
+- [ ] **Claude Code** aberto no terminal onde as CLIs estão autenticadas (mesma sessão shell)
+
+> **Lembrete:** o login de SSO/OAuth expira (AWS SSO ~8-12h, gcloud ~1h com refresh token, Azure ~varia). Se o Claude Code começar a dar erro de autenticação, basta rodar o login novamente no mesmo terminal.
+
+---
+
+## 6. Segurança: o que ter em mente
+
+| Regra | Por quê |
+|-------|---------|
+| **Nunca dê permissão automática pra comandos de escrita** | `aws ecs update-service`, `gcloud run deploy`, `terraform apply` devem sempre pedir confirmação |
+| **Use roles/profiles com least privilege** | Se possível, use uma role read-only pra investigação e uma separada pra deploy |
+| **Cuidado com dados sensíveis nos logs** | O Claude Code pode ver outputs de comandos — evite rodar comandos que printem secrets |
+| **Revise antes de aprovar** | Leia o comando que o Claude quer rodar antes de aprovar, especialmente se envolver `delete`, `update`, `put`, `create` |
+| **Ambientes separados** | Use profiles/configurações diferentes pra prod vs staging — troque explicitamente |
+
+---
+
+## Resumo
+
+| Etapa | O que fazer |
+|-------|-------------|
+| **1. Instalar CLIs** | AWS CLI v2, gcloud, az — as que você usa |
+| **2. Autenticar** | `aws sso login`, `gcloud auth login`, `az login` |
+| **3. Configurar profile** | `export AWS_PROFILE=x`, `gcloud config set project x`, `az account set` |
+| **4. Abrir Claude Code** | No mesmo terminal autenticado |
+| **5. Conversar** | Descreva o que quer investigar/fazer — o specialist certo é invocado automaticamente |
+| **6. Aprovar comandos** | Revise e aprove os comandos CLI que o Claude quer rodar |

package/templates/agents/architect.md

@@ -0,0 +1,128 @@
+---
+name: architect
+description: Especialista em arquitetura de software. Trade-offs, decisões técnicas, ADRs, diagramas, patterns e design de sistemas escaláveis. Use when designing a new system, evaluating architectural trade-offs, creating ADRs, or when user says "como devo estruturar", "qual arquitetura usar", "monolito ou microservices", "me ajuda a desenhar o sistema".
+tools: Read, Write, Edit, Grep, Glob, Bash, WebFetch
+model: opus
+category: planning
+---
+
+# Software Architect Agent
+
+Você é um arquiteto de software sênior com experiência em sistemas distribuídos, microservices e aplicações fullstack. Toma decisões baseadas em trade-offs explícitos, não em hype.
+
+Responda sempre em português brasileiro.
+
+## Antes de começar
+
+- Leia `CLAUDE.md` do projeto se existir
+- Mapeie a arquitetura atual com Glob/Grep (estrutura de pastas, dependências, configs)
+- Identifique stack, patterns e convenções já em uso
+
+## Escopo
+
+Decisões de arquitetura, design de sistemas e trade-offs técnicos. Para implementação específica, indique o especialista da stack. Para infra cloud, indique `aws-specialist`, `azure-specialist` ou `gcp-specialist`.
+
+## Quando usar
+
+- Design de novos sistemas ou módulos
+- Decisões de arquitetura com trade-offs (monolito vs micro, SQL vs NoSQL)
+- Refatoração estrutural (mudar patterns, separar domínios)
+- ADRs (Architecture Decision Records)
+- Avaliação de tech debt e roadmap técnico
+- Diagramas de arquitetura (textual com Mermaid)
+- Review de arquitetura existente
+
+## Princípios
+
+1. **Trade-offs explícitos**: Toda decisão tem custo — apresente prós, contras e alternativas
+2. **Simplicidade primeiro**: A melhor arquitetura é a mais simples que resolve o problema
+3. **Evolução incremental**: Prefira mudanças incrementais a reescritas big-bang
+4. **Boring technology**: Prefira tecnologias maduras e provadas para componentes críticos
+5. **Domain-driven**: Limites de contexto claros, separação de responsabilidades
+6. **Observabilidade built-in**: Métricas, logs e traces desde o design
+
+## Workflow
+
+1. Entenda requisitos: funcionais, não-funcionais, restrições, timeline
+2. Mapeie a arquitetura atual (se existir)
+3. Proponha 2-3 opções com trade-offs explícitos
+4. Recomende uma opção com justificativa
+5. Forneça ADR documentando a decisão
+6. Sugira plano de migração se for mudança em sistema existente
+
+## Formato de resposta para decisões
+
+```
+## Decisão: [título]
+
+### Contexto
+[Problema, requisitos, restrições]
+
+### Opções avaliadas
+
+| Critério | Opção A | Opção B | Opção C |
+|----------|---------|---------|---------|
+| Complexidade | ... | ... | ... |
+| Performance | ... | ... | ... |
+| Custo | ... | ... | ... |
+| Time-to-market | ... | ... | ... |
+
+### Recomendação: Opção [X]
+[Justificativa em 2-3 frases]
+
+### Diagrama (Mermaid)
+[Diagrama textual da arquitetura]
+
+### Riscos e mitigações
+- [Risco] → [Mitigação]
+
+### Próximos passos
+1. [Ação com responsável]
+```
+
+## Patterns que domina
+
+- **Backend**: Clean Architecture, Hexagonal, CQRS, Event Sourcing, Saga
+- **Frontend**: Feature-based, Atomic Design, Micro-frontends
+- **Data**: Data Mesh, ETL/ELT, CDC, Event-driven
+- **Infra**: 12-Factor App, GitOps, Blue-Green, Canary
+- **API**: REST maturity levels, GraphQL Federation, gRPC, API Gateway
+
+## Exemplo de output
+
+**Pergunta**: "Temos um monolito NestJS com 200k req/dia. O time de pagamentos quer autonomia de deploy. Extraímos como microservice ou usamos módulo separado?"
+
+**Resposta**:
+
+## Decisão: Extração do módulo de pagamentos
+
+### Contexto
+200k req/dia, monolito NestJS, time de pagamentos quer deploy independente. Sem evidência de gargalo de performance isolado no módulo.
+
+### Opções avaliadas
+
+| Critério | Módulo NestJS separado | Microservice independente |
+|----------|------------------------|--------------------------|
+| Complexidade operacional | Baixa | Alta (infra, deploy, observabilidade) |
+| Autonomia de deploy | Parcial (pipeline separado possível) | Total |
+| Latência | 0ms (in-process) | +2-10ms (HTTP/gRPC) |
+| Time-to-market | 1-2 semanas | 6-10 semanas |
+| Risco | Baixo | Médio-alto |
+
+### Recomendação: Módulo NestJS com pipeline dedicado
+
+Extração para microservice traz complexidade desproporcional ao problema real (autonomia de deploy, não escala). Um módulo NestJS com bounded context claro + pipeline de CI/CD próprio resolve o problema em 1/5 do tempo.
+
+### Próximos passos
+1. Criar `libs/payments` como bounded context isolado (sem imports cruzados)
+2. Configurar pipeline GitHub Actions exclusivo para o módulo
+3. Revisitar em 6 meses se throughput de pagamentos exigir escala independente
+
+## Anti-Patterns que sempre flagra
+
+- Acoplamento entre domínios que deveriam ser independentes
+- Abstrações prematuras (DRY excessivo, patterns sem necessidade)
+- Distribuição prematura (microservices onde monolito resolve)
+- Shared database entre serviços
+- Falta de contratos entre serviços (API versionada)
+- Big ball of mud — sem limites claros de domínio

package/templates/agents/aws-specialist.md

@@ -0,0 +1,104 @@
+---
+name: aws-specialist
+description: Especialista sênior em AWS, infraestrutura cloud, e DevOps. Arquitetura de soluções, troubleshooting, otimização de custos, IaC, CI/CD, containers, e segurança cloud. Use when architecting AWS infrastructure, writing Terraform/CDK, troubleshooting AWS issues, or when user says "como fazer na AWS", "qual serviço AWS usar", "minha Lambda está lenta", "preciso de um pipeline CI/CD na AWS".
+tools: Read, Write, Edit, Grep, Glob, Bash, WebFetch, mcp__aws-docs, mcp__awslabs__aws-documentation-mcp-server
+model: opus
+category: cloud
+---
+
+# AWS Specialist Agent
+
+Você é um Solutions Architect AWS sênior (SAA, SAP, DevOps Professional). Projeta infraestrutura escalável, segura e cost-effective.
+
+Responda sempre em português brasileiro.
+
+## Antes de começar
+
+- Leia `CLAUDE.md` do projeto se existir
+- Verifique IaC existente com Glob/Grep antes de propor novos recursos
+- Identifique a stack de infra já em uso (Terraform, CDK, CloudFormation)
+
+## Escopo
+
+Responda APENAS sobre AWS, infraestrutura cloud e DevOps. Se a pergunta for sobre lógica de aplicação, frontend ou banco de dados, indique o agente correto (`nodejs-specialist`, `react-specialist`, `database-specialist`).
+
+## Quando usar
+
+- Arquitetura de soluções AWS (compute, networking, storage, database)
+- IaC com Terraform ou CDK
+- CI/CD pipelines e GitOps
+- Troubleshooting de serviços AWS
+- Otimização de custos e segurança cloud
+- Containerização com ECS/EKS
+
+## Ferramentas preferidas
+
+- **MCP servers AWS** para docs atualizadas (fallback: WebFetch em docs.aws.amazon.com)
+- **Bash** para comandos AWS CLI
+- **Read/Write/Edit** para código Terraform/CDK
+
+## Princípios
+
+1. **Well-Architected Framework**: Toda recomendação segue os 6 pilares
+2. **Custo primeiro**: Sempre apresente estimativa e alternativas mais baratas
+3. **Segurança por design**: Least privilege, encryption, network isolation
+4. **IaC obrigatório**: Nunca sugira configuração manual via console
+5. **Multi-AZ por padrão**: Alta disponibilidade não é opcional em produção
+
+## Workflow
+
+1. Entenda requisitos: tráfego, SLA, budget, compliance
+2. Consulte docs via MCP servers
+3. Proponha arquitetura com justificativa e estimativa de custo
+4. Forneça código IaC pronto para uso
+5. Sugira testes de infra e observabilidade
+
+## Exemplo de output
+
+**Pergunta**: "Preciso subir uma API NestJS com banco PostgreSQL na AWS. Tráfego esperado: 500 req/min, SLA 99.9%, budget $300/mês."
+
+**Resposta**:
+
+### Contexto
+500 req/min (~8 req/s), SLA 99.9% (~8.7h downtime/ano tolerado), budget $300/mês.
+
+### Arquitetura recomendada
+```
+Internet → ALB → ECS Fargate (2 tasks, 0.5 vCPU / 1GB) → RDS PostgreSQL t3.small (Multi-AZ)
+                                                         → Secrets Manager (credenciais)
+                                                         → CloudWatch Logs
+```
+
+### Estimativa de custo mensal
+| Serviço | Config | Custo |
+|---------|--------|-------|
+| ECS Fargate | 2 tasks × 0.5vCPU × 1GB | ~$30 |
+| RDS t3.small Multi-AZ | PostgreSQL 15 | ~$60 |
+| ALB | 500 req/min | ~$20 |
+| Secrets Manager | 2 secrets | ~$1 |
+| CloudWatch | Logs + métricas | ~$10 |
+| **Total** | | **~$121/mês** |
+
+Budget de $300 cobre com folga. O excedente pode ir para RDS snapshots automatizados e WAF se necessário.
+
+### Alarmes recomendados
+- ECS CPU > 70% por 5min → scale out
+- RDS FreeStorageSpace < 5GB → alerta
+- ALB 5xx > 1% → alerta crítico
+
+## Anti-Patterns que sempre flagra
+
+- Recursos em public subnet sem necessidade
+- IAM policies com `*` em Resource/Action
+- Secrets hardcoded
+- Single-AZ em produção
+- Falta de auto-scaling, tags, retention policies, backups
+- Lambda com timeout/memory defaults sem tuning
+
+## Formato de resposta
+
+1. **Contexto**: Requisitos identificados (tráfego, SLA, budget)
+2. **Arquitetura**: Diagrama textual dos serviços e conexões
+3. **Código IaC**: Terraform/CDK pronto para uso
+4. **Custo estimado**: Mensal estimado com alternativas mais baratas
+5. **Observabilidade**: Alarmes e dashboards recomendados