Terragrunt GCP MCP Tool

Gerencie a infraestrutura do Google Cloud Platform (GCP) usando Terragrunt, com suporte a recursos experimentais como AutoDevOps e gerenciamento de custos.

GitHub
1
Experimente este MCPPatrocinado

Documentação

Terragrunt GCP MCP Tool

Um servidor de ferramentas Model Context Protocol (MCP) para gerenciar infraestrutura do Google Cloud Platform usando Terragrunt. Esta ferramenta fornece automação inteligente e capacidades de gerenciamento para o codebase terragrunt-gcp-org-automation com suporte para Recursos Experimentais do Terragrunt.

Recursos

🧪 Suporte a Recursos Experimentais

  • Terragrunt Stacks: Gerenciamento aprimorado de dependências e execução paralela usando o recurso experimental de stacks
  • Resolução Aprimorada de Dependências: Análise melhorada de dependências e ordenação de execução
  • Operações em Nível de Stack: Executar comandos em múltiplas unidades com gerenciamento inteligente de dependências
  • Execução Paralela: Executar múltiplas unidades em paralelo dentro de stacks para implantações mais rápidas
  • Saídas de Stack: Agregar e gerenciar saídas no nível do stack

Gerenciamento de Recursos

  • Adicionar Novos Recursos: Criar novos recursos de infraestrutura com modelos
  • Consultar Recursos: Inspecionar configurações e estados de recursos existentes
  • Atualizar Recursos: Modificar configurações de recursos com segurança
  • Excluir Recursos: Remover recursos com verificação de dependências

Operações de Implantação

  • Verificar Status: Monitorar status de implantação e saúde
  • Acionar Implantações: Iniciar implantações de infraestrutura
  • Planejar Alterações: Gerar e revisar planos de infraestrutura
  • Rollback: Reverter alterações com falha ou indesejadas

Monitoramento e Notificações

  • Monitoramento de Status: Rastrear estado e alterações da infraestrutura
  • Notificações de Equipe: Enviar atualizações para canais do Slack
  • Gerenciamento de Alertas: Configurar e gerenciar alertas de infraestrutura
  • Registro de Auditoria: Rastrear todas as operações e alterações

Recursos Avançados

  • Análise de Dependências: Entender dependências de recursos
  • Gerenciamento de Ambientes: Lidar com ambientes dev/staging/produção
  • Gerenciamento de Modelos: Criar e gerenciar modelos de infraestrutura
  • Análise de Custos: Monitorar e otimizar custos de infraestrutura

Suporte ao Redesign da CLI do Terragrunt

  • Nova Estrutura de Comandos: Usa o redesign mais recente da CLI do Terragrunt com comandos run
  • Variáveis de Ambiente: Atualizado para usar variáveis de ambiente com prefixo TG_
  • Bootstrap de Backend: Provisionamento automático de recursos de backend com --backend-bootstrap
  • Descoberta de Dependências: Análise aprimorada do grafo de dependências com comandos find e list
  • Operações Run All: Suporte para comandos run --all em múltiplas unidades

🤖 Integração com Assistente AutoDevOps (Novo!)

Esta ferramenta agora inclui prompts de sistema abrangentes para criar assistentes AutoDevOps que podem ajudar a gerenciar, monitorar e manter infraestrutura em nuvem usando todas as capacidades da ferramenta.

Obtendo Prompts de Sistema AutoDevOps

# Get the compact system prompt (recommended for most use cases)
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt

# Get the extended prompt with full details
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --variant extended

# Get CLI-specific prompt for automation
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --variant cli

# Get prompt in JSON format for API integration
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --format json

# Save prompt to file for integration
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --output-file autodevops_prompt.txt

# Get full context including capabilities and tools
python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --format context

Acesso à Ferramenta MCP

# Get system prompt via MCP tool
result = get_autodevops_system_prompt(
    variant="compact",  # "compact", "extended", "cli"
    format="json"       # "text", "json", "context"
)

# Use in conversation systems
from terragrunt_gcp_mcp.autodevops_prompt import inject_system_prompt

conversation = [
    {"role": "user", "content": "Help me understand my infrastructure"}
]

# Inject AutoDevOps system prompt
conversation_with_prompt = inject_system_prompt(conversation, variant="compact")

Integração com Claude Desktop

Adicione o prompt AutoDevOps à sua configuração do Claude Desktop:

{
  "mcpServers": {
    "terragrunt-gcp-autodevops": {
      "command": "python3",
      "args": [
        "/Users/spol/Desktop/GIT/INTI/terragrunt-gcp-tool-mcp/run_server.py",
        "/Users/spol/Desktop/GIT/INTI/terragrunt-gcp-tool-mcp/config/config.yaml"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/your/gcp-credentials.json"
      }
    }
  },
  "global": {
    "systemPrompt": "You are an AutoDevOps Infrastructure Assistant with expert knowledge in cloud infrastructure management. You have access to the Terragrunt GCP MCP Tool with comprehensive capabilities for managing Google Cloud Platform infrastructure. ROLE: Help users manage, monitor, and maintain cloud infrastructure efficiently and safely. Always start with visualization using draw_resource_tree or visualize_infrastructure, validate before deployment with validate_resource_config, and follow GitOps best practices."
  }
}

Exemplo de Integração com API

import openai
from terragrunt_gcp_mcp.autodevops_prompt import get_system_prompt

# Initialize with AutoDevOps system prompt
client = openai.OpenAI()

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {
            "role": "system", 
            "content": get_system_prompt("compact")
        },
        {
            "role": "user", 
            "content": "Show me the current state of our dev-99 environment and suggest optimizations"
        }
    ]
)

Integração de Automação

#!/bin/bash
# Get AutoDevOps prompt for automation scripts
PROMPT=$(python3 -m terragrunt_gcp_mcp.cli get-autodevops-prompt --variant cli --format text)

# Use in CI/CD pipelines, monitoring scripts, etc.
echo "AutoDevOps Assistant initialized with capabilities:"
echo "$PROMPT" | grep -A 20 "Available Commands"

O que o Assistente AutoDevOps Fornece

Capacidades Principais:

  • 🌳 Visualização de Infraestrutura: Árvores visuais e grafos de dependências
  • 🧪 Stacks Experimentais: Execução paralela e gerenciamento aprimorado de dependências
  • 🚀 Implantações Seguras: Validação, planejamento e capacidades de rollback
  • 🔧 Gerenciamento de Recursos: Gerenciamento completo do ciclo de vida com verificações de segurança
  • 📊 Monitoramento: Avaliação de saúde e otimização de desempenho
  • 🔐 Segurança: Conformidade e gerenciamento de trilha de auditoria

Diretrizes Operacionais:

  • Abordagem de Segurança em Primeiro Lugar: Sempre validar → visualizar → planejar → implantar
  • Visualização em Primeiro Lugar: Começar com visualização de árvore/grafo antes de fazer alterações
  • Melhores Práticas GitOps: Integração com controle de versão e testes automatizados
  • Proteção de Ambientes: Tratamento especial para ambientes de produção

Padrão de Resposta:

  1. Visualização do Estado Atual - Mostrar estado da infraestrutura com ferramentas de árvore/grafo
  2. Análise de Impacto - Analisar o que mudaria e o que poderia ser afetado
  3. Recomendações - Fornecer melhores práticas e ações sugeridas
  4. Etapas de Implementação - Etapas claras e acionáveis com comandos específicos da ferramenta
  5. Validação e Monitoramento - Como verificar o sucesso e monitoramento contínuo

🌳 Visualização de Árvore de Recursos

Instalação

# Clone the repository
git clone <repository-url>
cd terragrunt-gcp-tool-mcp

# Install dependencies
pip install -r requirements.txt

# Or install in development mode
pip install -e .

# Configure the MCP server
cp config/config.example.yaml config/config.yaml
# Edit config.yaml with your settings

Configuração

Crie um arquivo config/config.yaml com suas configurações:

# GCP Configuration
gcp:
  project_id: "your-project-id"
  credentials_path: "/path/to/credentials.json"
  default_region: "europe-west2"

# Terragrunt Configuration
terragrunt:
  root_path: "/path/to/terragrunt-gcp-org-automation"
  binary_path: "terragrunt"
  terraform_binary: "tofu"
  
  # Experimental features configuration
  experimental:
    # Stacks feature (experimental)
    stacks_enabled: true                    # Enable Terragrunt stacks experimental feature
    enhanced_dependency_resolution: true    # Use enhanced dependency resolution
    parallel_execution: true                # Enable parallel execution within stacks
    stack_outputs: true                     # Enable stack-level outputs
    recursive_stacks: false                 # Enable recursive stacks (not yet stable)
    
    # Stack execution settings
    max_parallel_units: 10                  # Maximum number of units to execute in parallel
    stack_timeout: 7200                     # Timeout for stack operations in seconds (2 hours)
    continue_on_error: false                # Continue stack execution on unit errors

# Slack Configuration (optional)
slack:
  webhook_url: "https://hooks.slack.com/..."
  default_channel: "#infrastructure"

# Monitoring Configuration
monitoring:
  enabled: true
  check_interval: 300  # seconds

Uso

Executando como Servidor MCP

Existem várias maneiras de iniciar o servidor MCP:

Opção 1: Usando o script de inicialização (Recomendado)

# Start the MCP server with default config
python3 run_server.py

# Start with custom config file
python3 run_server.py config/config.yaml

Opção 2: Usando o módulo diretamente

# Start the MCP server
python3 -m terragrunt_gcp_mcp.server

# With custom config
python3 -m terragrunt_gcp_mcp.server config/config.yaml

Opção 3: Usando a CLI

# Initialize configuration first
python3 -m terragrunt_gcp_mcp.cli init

# Start the server
python3 -m terragrunt_gcp_mcp.cli server

# Other CLI commands
python3 -m terragrunt_gcp_mcp.cli list-resources
python3 -m terragrunt_gcp_mcp.cli status

O servidor estará disponível para clientes MCP se conectarem via stdio.

Usando com Claude Desktop

Adicione à sua configuração MCP do Claude Desktop:

{
  "mcpServers": {
    "terragrunt-gcp": {
      "command": "python3",
      "args": ["-m", "terragrunt_gcp_mcp.server"],
      "cwd": "/path/to/terragrunt-gcp-tool-mcp"
    }
  }
}

Ferramentas Disponíveis

O servidor MCP fornece estas ferramentas:

🧪 Ferramentas de Stacks Experimentais

  • list_stacks - Listar todos os stacks do Terragrunt usando recursos experimentais
  • get_stack_details - Obter informações detalhadas sobre um stack específico, incluindo unidades e ordem de execução
  • execute_stack_command - Executar comandos em stacks com execução paralela e gerenciamento de dependências
  • get_stack_outputs - Obter saídas agregadas de operações em nível de stack
  • get_enhanced_infrastructure_status - Obter status abrangente incluindo recursos tradicionais e stacks

Gerenciamento de Recursos

  • list_resources - Listar todos os recursos na infraestrutura
  • get_resource - Obter informações detalhadas sobre um recurso específico (obsoleto, use get_resource_details)
  • get_resource_details - Obter informações abrangentes sobre um recurso específico, incluindo atributos, estado e configuração
  • validate_resource_config - Validar uma configuração de recurso do Terragrunt com verificação de dependências
  • create_resource - Criar um novo recurso de infraestrutura
  • update_resource - Atualizar uma configuração de recurso existente
  • delete_resource - Excluir um recurso (com verificação de dependências)

Visualização e Desenho de Árvores (Novo!)

  • draw_resource_tree - Desenhar uma árvore visual de recursos usando comandos do redesign da CLI do Terragrunt
  • get_dependency_graph - Gerar grafos de dependências em formato DOT, Mermaid ou JSON
  • visualize_infrastructure - Visualização abrangente de infraestrutura combinando árvores e grafos

Integração com Assistente AutoDevOps (Novo!)

  • get_autodevops_system_prompt - Obter prompts de sistema para integração com LLM para criar assistentes AutoDevOps
  • Suporte para variantes de prompt compactas, estendidas e específicas de CLI
  • Formatos de saída JSON, texto e contexto para diferentes cenários de integração
  • Guias de integração integrados para Claude Desktop, APIs e ferramentas de automação

Gerenciamento e Análise de Custos (Novo!)

  • get_cost_analysis - Análise abrangente de custos com previsão e recomendações de otimização
  • get_cost_alerts - Alertas de custos baseados em limites de orçamento e padrões de gastos
  • get_cost_optimization_score - Pontuação de otimização de custos de infraestrutura e recomendações
  • get_cost_status - Painel completo de status de custos com análise, alertas e insights de otimização
  • Suporte para filtragem por ambiente, múltiplos períodos de tempo e detalhamentos detalhados de custos
  • Integração com a API de Cobrança do Google Cloud para dados precisos de custos

Operações de Implantação

  • plan_deployment - Gerar plano de implantação para alterações (obsoleto, use plan_resource_deployment)
  • plan_resource_deployment - Gerar um plano de implantação abrangente para um recurso do Terragrunt
  • deploy_resources - Implantar alterações de infraestrutura (obsoleto, use apply_resource_deployment)
  • apply_resource_deployment - Aplicar alterações a um recurso do Terragrunt com verificações de segurança
  • check_deployment_status - Verificar status de implantações em andamento
  • rollback_deployment - Reverter uma implantação com falha

Monitoramento e Análise

  • get_infrastructure_status - Obter saúde geral da infraestrutura
  • analyze_dependencies - Analisar dependências de recursos
  • get_cost_analysis - Obter detalhamento de custos da infraestrutura
  • check_drift - Detectar desvio de configuração

Colaboração de Equipe

  • send_slack_notification - Enviar notificações para a equipe
  • create_deployment_summary - Gerar relatórios de implantação
  • get_audit_log - Recuperar registros de auditoria

Exemplos

🧪 Usando Recursos Experimentais de Stacks

Uso via CLI

# List all stacks
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml list-stacks

# Get detailed information about a specific stack
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-stack-details "live/dev-account/test-dev/dev-99"

# Execute a command on a stack (with parallel execution)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml execute-stack-command "live/dev-account/test-dev/dev-99" plan --dry-run

# Get stack outputs
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-stack-outputs "live/dev-account/test-dev/dev-99"

# Get enhanced infrastructure status including stacks
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml status --include-stacks

🌳 Visualização de Árvore de Recursos (Novo!)

Uso via CLI

# Draw a basic resource tree
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml draw-tree

# Draw tree for specific environment
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml draw-tree --environment dev-99

# Draw tree with limited depth
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml draw-tree --max-depth 3

# Generate dependency graph in DOT format (for Graphviz)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml dependency-graph --format dot

# Generate dependency graph in Mermaid format
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml dependency-graph --format mermaid

# Comprehensive visualization
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml visualize --type tree --format ascii
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml visualize --type dag --format mermaid

# Get tree data in JSON format
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml draw-tree --format json

Uso via MCP

# Example: Draw a resource tree
result = draw_resource_tree(
    environment="dev-99",
    format="tree",
    include_dependencies=True,
    max_depth=4
)

# Example: Generate dependency graph
result = get_dependency_graph(
    environment="dev-99",
    output_format="mermaid"
)

# Example: Comprehensive visualization
result = visualize_infrastructure(
    environment="dev-99",
    visualization_type="tree",
    include_dependencies=True,
    output_format="ascii"
)

# Example: List all stacks (experimental)
result = list_stacks(environment="dev-99")

# Example: Get stack details with units and execution order (experimental)
result = get_stack_details(stack_path="live/dev-account/test-dev/dev-99")

# Example: Execute a plan command on a stack (experimental)
result = execute_stack_command(
    stack_path="live/dev-account/test-dev/dev-99",
    command="plan",
    dry_run=True
)

# Example: Get enhanced status including stacks (experimental)
result = get_enhanced_infrastructure_status(
    environment="dev-99",
    include_stacks=True,
    include_costs=False
)

Exemplo de Saída de Árvore

Infrastructure
├── dev-account
│   └── test-dev
│       └── dev-99 (folder)
│           ├── project (project)
│           ├── europe-west2 (folder)
│           │   ├── vpc (vpc-network) [deps: 1]
│           │   ├── compute (folder)
│           │   │   ├── web-server-01 (compute) [deps: 2]
│           │   │   └── sftp-worker-01 (compute) [deps: 2]
│           │   └── secrets (folder)
│           │       └── sftp-sshfs-host (secrets) [deps: 1]
│           └── bigquery (folder)
│               └── dataset-01 (bigquery) [deps: 1]

Exemplo de Grafo de Dependências (Mermaid)

graph TD
  project[project] --> vpc[vpc]
  vpc[vpc] --> web_server_01[web-server-01]
  vpc[vpc] --> sftp_worker_01[sftp-worker-01]
  project[project] --> secrets[secrets]

Validando Recursos

Uso via CLI

# Validate a resource with dependency checking
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml validate-resource "web-server-01"

# Validate without checking dependencies
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml validate-resource "web-server-01" --no-check-dependencies

# Get validation results in JSON format
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml validate-resource "web-server-01" --format json

# New CLI redesign commands
# Find and discover Terragrunt configurations (replaces output-module-groups)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml find --dag --json --dependencies

# List units with dependency information (replaces graph-dependencies)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml list-units --dag --tree

# Generate dependency graph
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml dag-graph --format json

# Run commands across all units (uses 'run --all' internally)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml run-all plan --environment test-dev
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml run-all apply --dry-run

Uso via MCP

# Example: Validate a resource configuration
result = validate_resource_config(
    resource_path="live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-01",
    check_dependencies=True
)

Planejando Implantações

Uso via CLI

# Generate a deployment plan (dry-run by default)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml plan-deployment "web-server-01"

# Generate a plan and save it for later use
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml plan-deployment "web-server-01" --save-plan

# Get plan results in JSON format
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml plan-deployment "web-server-01" --format json

Uso via MCP

# Example: Generate a deployment plan
result = plan_resource_deployment(
    resource_path="live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-01",
    dry_run=True,
    save_plan=True
)

Aplicando Implantações

Uso via CLI

# Apply deployment with confirmation prompt
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml apply-deployment "web-server-01"

# Apply deployment with auto-approval (bypasses validation)
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml apply-deployment "web-server-01" --auto-approve

# Apply using a specific plan file
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml apply-deployment "web-server-01" --plan-file "tfplan"

# Apply without notifications
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml apply-deployment "web-server-01" --no-notify

Uso via MCP

# Example: Apply deployment with safety checks
result = apply_resource_deployment(
    resource_path="live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-01",
    auto_approve=False,
    plan_file=None,
    notify_on_completion=True
)

Exemplo de Fluxo de Trabalho Completo

Fluxo de Trabalho via CLI

# 1. Validate the resource first
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml validate-resource "web-server-01"

# 2. Generate and review the deployment plan
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml plan-deployment "web-server-01" --save-plan

# 3. Apply the deployment
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml apply-deployment "web-server-01"

🧪 Fluxo de Trabalho com Stacks Experimentais

# 1. List available stacks
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml list-stacks

# 2. Get stack details and execution order
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-stack-details "dev-99"

# 3. Plan the entire stack
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml execute-stack-command "dev-99" plan --dry-run

# 4. Apply the stack with parallel execution
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml execute-stack-command "dev-99" apply

Fluxo de Trabalho via MCP

# Complete deployment workflow via MCP
# 1. Validate
validation = validate_resource_config("web-server-01", check_dependencies=True)

# 2. Plan
if validation.success:
    plan = plan_resource_deployment("web-server-01", dry_run=True, save_plan=True)
    
    # 3. Apply
    if plan.success and plan.data["plan"]["changes_summary"]["has_changes"]:
        deployment = apply_resource_deployment(
            "web-server-01", 
            auto_approve=False, 
            notify_on_completion=True
        )

Consultando Recursos Individuais

# Get detailed information about a specific resource
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-resource "web-server-01"

# Get resource info with full configuration
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-resource "live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-01" --include-config

# Get resource info in JSON format
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml get-resource "sftp-worker-01" --format json

Criando uma Nova Instância de Computação

# Example: Create a new compute instance
result = create_resource(
    resource_type="compute",
    resource_name="web-server-02",
    environment="dev-99",
    region="europe-west2",
    configuration={
        "machine_type": "e2-medium",
        "disk_size_gb": 50,
        "tags": ["web-server", "api"]
    }
)

Obtendo Detalhes de Recursos via MCP

# Example: Get detailed resource information
result = get_resource_details(
    resource_path="live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-01",
    include_configuration=True
)

Implantando Alterações

# Example: Deploy specific resources
result = deploy_resources(
    resources=["live/dev-account/test-dev/dev-99/europe-west2/compute/web-server-02"],
    dry_run=False,
    notify_slack=True
)

Monitorando Status

# Example: Check infrastructure status
status = get_infrastructure_status(
    environment="dev-99",
    include_costs=True,
    include_health=True
)

💰 Gerenciamento e Análise de Custos (Novo!)

Análise abrangente de custos, monitoramento e otimização para sua infraestrutura GCP.

Uso via CLI

# Get comprehensive cost analysis
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-analysis

# Get cost analysis for specific environment with 60-day period
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-analysis --environment dev-99 --period-days 60

# Get cost analysis in JSON format without forecasting
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-analysis --format json --no-forecasting

# Check cost alerts with custom threshold
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-alerts --threshold 75.0

# Get cost optimization score
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-optimization-score

# Get comprehensive cost status
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-status --environment dev-99

# Get cost status without optimization score
python3 -m terragrunt_gcp_mcp.cli --config config/config.yaml cost-status --no-optimization

Uso via MCP

# Example: Get comprehensive cost analysis
result = get_cost_analysis(
    environment="dev-99",
    period_days=30,
    include_forecasting=True,
    include_recommendations=True
)

# Example: Get cost alerts
result = get_cost_alerts(threshold_percentage=80.0)

# Example: Get cost optimization score
result = get_cost_optimization_score()

# Example: Get complete cost status
result = get_cost_status(
    environment="dev-99",
    include_alerts=True,
    include_optimization_score=True
)

Recursos de Análise de Custos

  • Detalhamento por Serviço: Custos por serviço GCP (Compute, Storage, Networking, etc.)
  • Detalhamento por Ambiente: Custos por ambiente (dev, staging, produção)
  • Custos em Nível de Recurso: Rastreamento de custos de recursos individuais
  • Tendências de Custos: Dados históricos de custos e análise de tendências
  • Previsão: Modelagem preditiva de custos para planejamento de orçamento
  • Recomendações de Otimização: Sugestões acionáveis de redução de custos
  • Alertas de Orçamento: Notificações proativas para limites de orçamento
  • Pontuação de Otimização: Pontuação de eficiência da infraestrutura (nota A-F)

live/ ├── dev-account/ │ └── test-dev/ │ └── dev-99/ │ ├── stack.hcl # Definição do stack │ ├── project/ │ │ └── terragrunt.hcl # Unidade 1 │ ├── compute/ │ │ └── terragrunt.hcl # Unidade 2 │ └── secrets/ │ └── terragrunt.hcl # Unidade 3


#### Benefits

1. **Faster Deployments**: Parallel execution of independent units
2. **Better Dependency Management**: Automatic dependency resolution
3. **Improved Reliability**: Enhanced error handling and retry mechanisms
4. **Stack-Level Visibility**: Aggregate status and outputs
5. **Simplified Operations**: Single commands for complex deployments

## Architecture

┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ MCP Client │ │ MCP Server │ │ Terragrunt │ │ (Claude) │◄──►│ (This Tool) │◄──►│ Infrastructure│ └─────────────────┘ └──────────────────┘ └─────────────────┘ │ │ ▼ ▼ ┌──────────────────┐ ┌─────────────────┐ │ External APIs │ │ 🧪 Experimental │ │ • GCP APIs │ │ Stacks │ │ • Slack API │ │ • Enhanced │ │ • GitHub API │ │ Dependencies│ └──────────────────┘ │ • Parallel │ │ Execution │ └─────────────────┘


## Segurança

- **Gerenciamento de Credenciais**: Suporta múltiplos métodos de autenticação GCP
- **Validação de Permissões**: Verifica permissões antes das operações
- **Registro de Auditoria**: Todas as operações são registradas para auditoria de segurança
- **Operações Seguras**: Modo de simulação (dry-run) para testar alterações

## Contribuindo

1. Faça um fork do repositório
2. Crie um branch de funcionalidade
3. Faça suas alterações
4. Adicione testes para novas funcionalidades
5. Envie um pull request

## Licença

GNU General Public License v3.0 - consulte LICENSE.md para detalhes.

## Suporte

Para problemas e perguntas:
- Crie um issue no repositório
- Consulte a documentação em `/docs`
- Revise os exemplos em `/examples`