Terragrunt GCP MCP Tool

Gestiona infraestructura de Google Cloud Platform (GCP) usando Terragrunt, con soporte para funciones experimentales como AutoDevOps y gestión de costos.

GitHub
1
Prueba este MCPPatrocinado

Documentación

Terragrunt GCP MCP Tool

Una herramienta de servidor del Protocolo de Contexto de Modelos (MCP) para gestionar la infraestructura de Google Cloud Platform utilizando Terragrunt. Esta herramienta proporciona capacidades inteligentes de automatización y gestión para el código base terragrunt-gcp-org-automation, con soporte para Funciones Experimentales de Terragrunt.

Características

🧪 Soporte de Funciones Experimentales

  • Terragrunt Stacks: Gestión de dependencias mejorada y ejecución paralela utilizando la función experimental de stacks
  • Resolución de Dependencias Mejorada: Análisis de dependencias y orden de ejecución mejorados
  • Operaciones a Nivel de Stack: Ejecutar comandos en múltiples unidades con manejo inteligente de dependencias
  • Ejecución Paralela: Ejecutar múltiples unidades en paralelo dentro de los stacks para implementaciones más rápidas
  • Salidas de Stack: Agregar y gestionar salidas a nivel de stack

Gestión de Recursos

  • Añadir Nuevos Recursos: Crear nuevos recursos de infraestructura con plantillas
  • Consultar Recursos: Inspeccionar configuraciones y estados de recursos existentes
  • Actualizar Recursos: Modificar configuraciones de recursos de forma segura
  • Eliminar Recursos: Eliminar recursos con verificación de dependencias

Operaciones de Implementación

  • Verificar Estado: Supervisar el estado y la salud de las implementaciones
  • Activar Implementaciones: Iniciar implementaciones de infraestructura
  • Planificar Cambios: Generar y revisar planes de infraestructura
  • Rollback: Revertir cambios fallidos o no deseados

Supervisión y Notificaciones

  • Supervisión de Estado: Realizar seguimiento del estado de la infraestructura y sus cambios
  • Notificaciones de Equipo: Enviar actualizaciones a canales de Slack
  • Gestión de Alertas: Configurar y gestionar alertas de infraestructura
  • Registro de Auditoría: Realizar seguimiento de todas las operaciones y cambios

Características Avanzadas

  • Análisis de Dependencias: Comprender las dependencias de los recursos
  • Gestión de Entornos: Manejar entornos de dev/staging/producción
  • Gestión de Plantillas: Crear y gestionar plantillas de infraestructura
  • Análisis de Costos: Supervisar y optimizar los costos de infraestructura

Soporte del Rediseño de la CLI de Terragrunt

  • Nueva Estructura de Comandos: Utiliza el rediseño más reciente de la CLI de Terragrunt con comandos run
  • Variables de Entorno: Actualizado para usar variables de entorno con prefijo TG_
  • Bootstrap de Backend: Aprovisionamiento automático de recursos backend con --backend-bootstrap
  • Descubrimiento de Dependencias: Análisis mejorado del grafo de dependencias con comandos find y list
  • Operaciones Run All: Soporte para comandos run --all en múltiples unidades

🤖 Integración del Asistente AutoDevOps (¡Nuevo!)

Esta herramienta ahora incluye prompts de sistema integrales para crear asistentes AutoDevOps que pueden ayudar a gestionar, supervisar y mantener la infraestructura en la nube utilizando todas las capacidades de la herramienta.

Obtención de 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

Acceso a Herramientas 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")

Integración con Claude Desktop

Agrega el prompt de AutoDevOps a tu configuración de 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."
  }
}

Ejemplo de Integración 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"
        }
    ]
)

Integración de Automatización

#!/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"

Lo que Proporciona el Asistente AutoDevOps

Capacidades Principales:

  • 🌳 Visualización de Infraestructura: Árboles visuales y grafos de dependencias
  • 🧪 Stacks Experimentales: Ejecución paralela y gestión de dependencias mejorada
  • 🚀 Implementaciones Seguras: Capacidades de validación, planificación y rollback
  • 🔧 Gestión de Recursos: Gestión completa del ciclo de vida con verificaciones de seguridad
  • 📊 Supervisión: Evaluación de salud y optimización del rendimiento
  • 🔐 Seguridad: Gestión de cumplimiento y registros de auditoría

Pautas Operativas:

  • Enfoque de Seguridad Primero: Siempre validar → visualizar → planificar → implementar
  • Visualización Primero: Comenzar con visualización de árbol/grafo antes de realizar cambios
  • Mejores Prácticas de GitOps: Integración con control de versiones y pruebas automatizadas
  • Protección del Entorno: Manejo especial para entornos de producción

Patrón de Respuesta:

  1. Visualización del Estado Actual - Mostrar el estado de la infraestructura con herramientas de árbol/grafo
  2. Análisis de Impacto - Analizar qué cambiaría y qué podría verse afectado
  3. Recomendaciones - Proporcionar mejores prácticas y acciones sugeridas
  4. Pasos de Implementación - Pasos claros y accionables con comandos específicos de la herramienta
  5. Validación y Supervisión - Cómo verificar el éxito y la supervisión continua

🌳 Visualización de Árbol de Recursos

Instalación

# 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

Configuración

Crea un archivo config/config.yaml con tus ajustes:

# 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

Ejecución como Servidor MCP

Hay varias formas de iniciar el servidor MCP:

Opción 1: Usando el script de inicio (Recomendado)

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

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

Opción 2: Usando el módulo directamente

# Start the MCP server
python3 -m terragrunt_gcp_mcp.server

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

Opción 3: Usando la 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

El servidor estará disponible para que los clientes MCP se conecten a través de stdio.

Uso con Claude Desktop

Agrega a tu configuración MCP de Claude Desktop:

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

Herramientas Disponibles

El servidor MCP proporciona estas herramientas:

🧪 Herramientas de Stacks Experimentales

  • list_stacks - Listar todos los stacks de Terragrunt utilizando funciones experimentales
  • get_stack_details - Obtener información detallada sobre un stack específico, incluyendo unidades y orden de ejecución
  • execute_stack_command - Ejecutar comandos en stacks con ejecución paralela y gestión de dependencias
  • get_stack_outputs - Obtener salidas agregadas de operaciones a nivel de stack
  • get_enhanced_infrastructure_status - Obtener estado integral que incluye tanto recursos tradicionales como stacks

Gestión de Recursos

  • list_resources - Listar todos los recursos de la infraestructura
  • get_resource - Obtener información detallada sobre un recurso específico (obsoleto, usar get_resource_details)
  • get_resource_details - Obtener información integral sobre un recurso específico, incluyendo atributos, estado y configuración
  • validate_resource_config - Validar una configuración de recurso de Terragrunt con verificación de dependencias
  • create_resource - Crear un nuevo recurso de infraestructura
  • update_resource - Actualizar una configuración de recurso existente
  • delete_resource - Eliminar un recurso (con verificación de dependencias)

Visualización y Dibujo de Árboles (¡Nuevo!)

  • draw_resource_tree - Dibujar un árbol visual de recursos usando comandos del rediseño de la CLI de Terragrunt
  • get_dependency_graph - Generar grafos de dependencias en formato DOT, Mermaid o JSON
  • visualize_infrastructure - Visualización integral de infraestructura que combina árboles y grafos

Integración del Asistente AutoDevOps (¡Nuevo!)

  • get_autodevops_system_prompt - Obtener prompts de sistema para integración de LLM y crear asistentes AutoDevOps
  • Soporte para variantes de prompts compactas, extendidas y específicas de CLI
  • Formatos de salida JSON, texto y contexto para diferentes escenarios de integración
  • Guías de integración integradas para Claude Desktop, APIs y herramientas de automatización

Gestión y Análisis de Costos (¡Nuevo!)

  • get_cost_analysis - Análisis integral de costos con pronósticos y recomendaciones de optimización
  • get_cost_alerts - Alertas de costos basadas en umbrales de presupuesto y patrones de gasto
  • get_cost_optimization_score - Puntuación de optimización de costos de infraestructura y recomendaciones
  • get_cost_status - Panel de estado de costos completo con análisis, alertas e información de optimización
  • Soporte para filtrado por entorno, múltiples períodos de tiempo y desgloses detallados de costos
  • Integración con la API de Facturación de Google Cloud para datos de costos precisos

Operaciones de Implementación

  • plan_deployment - Generar plan de implementación para cambios (obsoleto, usar plan_resource_deployment)
  • plan_resource_deployment - Generar un plan de implementación integral para un recurso de Terragrunt
  • deploy_resources - Implementar cambios de infraestructura (obsoleto, usar apply_resource_deployment)
  • apply_resource_deployment - Aplicar cambios a un recurso de Terragrunt con verificaciones de seguridad
  • check_deployment_status - Verificar el estado de implementaciones en curso
  • rollback_deployment - Revertir una implementación fallida

Supervisión y Análisis

  • get_infrastructure_status - Obtener la salud general de la infraestructura
  • analyze_dependencies - Analizar dependencias de recursos
  • get_cost_analysis - Obtener desglose de costos de infraestructura
  • check_drift - Detectar desviación de configuración

Colaboración en Equipo

  • send_slack_notification - Enviar notificaciones al equipo
  • create_deployment_summary - Generar informes de implementación
  • get_audit_log - Recuperar registros de auditoría

Ejemplos

🧪 Uso de Funciones de Stacks Experimentales

Uso 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

🌳 Visualización de Árbol de Recursos (¡Nuevo!)

Uso 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 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
)

Ejemplo de Salida de Árbol

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]

Ejemplo de Grafo de Dependencias (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]

Validación de Recursos

Uso 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 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
)

Planificación de Implementaciones

Uso 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 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
)

Aplicación de Implementaciones

Uso 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 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
)

Ejemplo de Flujo de Trabajo Completo

Flujo de Trabajo 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"

🧪 Flujo de Trabajo con Stacks Experimentales

# 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

Flujo de Trabajo 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
        )

Consulta de Recursos Individuales

# 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

Creación de una Nueva Instancia de Compute

# 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"]
    }
)

Obtención de Detalles de Recursos vía 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
)

Implementación de Cambios

# 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
)

Supervisión de Estado

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

💰 Gestión y Análisis de Costos (¡Nuevo!)

Análisis integral de costos, supervisión y optimización para tu infraestructura GCP.

Uso 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 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
)

Funciones de Análisis de Costos

  • Desglose por Servicio: Costos por servicio de GCP (Compute, Storage, Networking, etc.)
  • Desglose por Entorno: Costos por entorno (dev, staging, producción)
  • Costos a Nivel de Recurso: Seguimiento de costos de recursos individuales
  • Tendencias de Costos: Datos históricos de costos y análisis de tendencias
  • Pronósticos: Modelado predictivo de costos para planificación de presupuestos
  • Recomendaciones de Optimización: Sugerencias accionables para reducción de costos
  • Alertas de Presupuesto: Notificaciones proactivas para umbrales de presupuesto
  • Puntuación de Optimización: Evaluación de eficiencia de infraestructura (calificación A-F)

live/ ├── dev-account/ │ └── test-dev/ │ └── dev-99/ │ ├── stack.hcl # Definición del stack │ ├── project/ │ │ └── terragrunt.hcl # Unidad 1 │ ├── compute/ │ │ └── terragrunt.hcl # Unidad 2 │ └── secrets/ │ └── terragrunt.hcl # Unidad 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 │ └─────────────────┘


## Seguridad

- **Gestión de Credenciales**: Soporta múltiples métodos de autenticación de GCP
- **Validación de Permisos**: Verifica permisos antes de las operaciones
- **Registro de Auditoría**: Todas las operaciones se registran para auditoría de seguridad
- **Operaciones Seguras**: Modo de prueba (dry-run) para probar cambios

## Contribución

1. Haz un fork del repositorio
2. Crea una rama de características
3. Realiza tus cambios
4. Agrega pruebas para la nueva funcionalidad
5. Envía una solicitud de pull (pull request)

## Licencia

Licencia Pública General de GNU v3.0 - consulta LICENSE.md para más detalles.

## Soporte

Para problemas y preguntas:
- Crea un issue en el repositorio
- Consulta la documentación en `/docs`
- Revisa los ejemplos en `/examples`