DEV Community

Cover image for Terraform MCP Server: tu AI ya sabe leer el Registry (y vos podés tomar mate)
Rossana Suarez #RoxsRoss
Rossana Suarez #RoxsRoss

Posted on

Terraform MCP Server: tu AI ya sabe leer el Registry (y vos podés tomar mate)

#ai #mcp #spanish #terraform

Acordate de la última vez que escribiste un recurso de Terraform que no usabas hace tres meses. Abriste el Registry. Buscaste el provider. Entraste a la doc. Chequeaste qué atributos eran requeridos en la versión actual. Volviste al editor. Escribiste mal el nombre. Volviste al Registry. Copiaste el snippet. El snippet estaba deprecado.

Eso se llama contexto switching. Y mata la productividad más silenciosamente que un merge conflict un viernes a las 6pm.

Hoy arrancamos una serie para erradicarlo. Y el primer episodio tiene protagonista: el Terraform MCP Server.

¿Qué es MCP y por qué te debería importar?

MCP son las siglas de Model Context Protocol — un estándar abierto que le permite a los modelos de AI conectarse de forma segura con herramientas externas, aplicaciones y fuentes de datos. La idea es simple y poderosa: en vez de que la AI trabaje solo con lo que aprendió hasta su fecha de corte, puede consultar información actualizada en tiempo real.

HashiCorp lanzó su propio MCP Server para Terraform y es exactamente lo que el nombre promete: un servidor que le da a tu AI acceso directo al Terraform Registry. Providers, módulos, políticas Sentinel, workspaces de HCP Terraform — todo disponible en el momento en que lo necesitás, desde tu IDE, sin cambiar de pantalla.

"En vez de que la AI adivine cómo se configura un aws_s3_bucket con la versión actual del provider, le pregunta al Registry directamente."

Está en beta (v0.5.x), pero ya funciona muy bien para el día a día.

Cómo funciona por dentro

El flujo es así:

Vos escribís un prompt en tu IDE
         ↓
    AI Agent (Copilot / Cursor / Claude)
         ↓
    Terraform MCP Server
         ↓
    Terraform Registry (docs actualizadas, en vivo)
         ↓
    HCL correcto en tu editor
Enter fullscreen mode Exit fullscreen mode

Los componentes clave que necesitás entender:

  • MCP Host: tu IDE (VS Code, Cursor) o app como Claude Desktop
  • MCP Client: el agente de AI que interpreta tus prompts
  • MCP Server: el servidor de Terraform que expone las herramientas
  • Transport: cómo se comunican — por defecto usa stdio (stdin/stdout), también soporta HTTP streamable para deployments remotos

El MCP Server tiene tres toolsets principales:

Toolset Para qué sirve
registry Registry público de Terraform
registry-private Registry privado de tu organización
terraform HCP Terraform y Terraform Enterprise

Y dentro de registry, los tools que vas a usar más seguido son:

  • search_providers — busca documentación por servicio
  • get_provider_details — documentación completa de un recurso
  • search_modules — encuentra módulos por nombre o funcionalidad
  • get_module_details — inputs, outputs, ejemplos, submódulos

Lo mejor: no los invocás manualmente. El agente los usa automáticamente cuando le hacés una pregunta relevante.

Setup en 5 minutos (en serio, 5 minutos)

Tenés tres opciones de instalación:

Método Cuándo usarlo
Docker La mayoría de los casos. Consistente en cualquier entorno
Binary compilado Si no querés Docker en el mix
Desde source Si querés tocar el código o contribuir

Vamos con Docker que es la más portable.

Prerequisitos

  • Docker corriendo
  • VS Code con la extensión GitHub Copilot en modo Agent, o Cursor con MCP habilitado
  • Ganas de dejar de abrir tabs

Paso 1: Pull de la imagen 

docker pull hashicorp/terraform-mcp-server:latest
Enter fullscreen mode Exit fullscreen mode

Paso 2: Configuración en VS Code

Creá la carpeta .vscode en tu proyecto y adentro el archivo mcp.json:

{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Guardás el archivo. VS Code te va a mostrar un link start debajo de "servers". Lo clickeás. El container arranca.

⚠️ Tip de campo: No uses el botón "Add Server..." de la UI de VS Code. La experiencia guiada es confusa y no siempre funciona bien. Pegá el JSON directamente.

Paso 3: Verificar que el agente lo ve

Abrís GitHub Copilot Chat, te asegurás de estar en modo Agent, y clickeás el ícono de herramientas. Debería aparecerte terraform-mcp-server con todos sus tools habilitados.

Configuración para Cursor

En Cursor, editás tu settings.json de usuario:

{
  "mcp": {
    "servers": {
      "terraform": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "hashicorp/terraform-mcp-server"
        ]
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Después: Settings → MCP → verificar que Terraform MCP Server aparezca con tools activos.

¿Usás HCP Terraform o Terraform Enterprise?

Agregás las variables de entorno en el config:

{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "TFE_TOKEN=tu-token-aqui",
        "-e", "TFE_ADDRESS=https://app.terraform.io",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Con esto el MCP Server también puede listar tus workspaces, runs y módulos privados.

Demo: S3 con versioning y lifecycle policy, sin abrir el Registry

Este es el momento que justifica todo el setup.

Antes del MCP Server, el workflow era así:

  1. Abrir el Terraform Registry
  2. Buscar aws_s3_bucket
  3. Buscar aws_s3_bucket_versioning (porque ya no va en el mismo recurso, cambió en el provider v4)
  4. Buscar aws_s3_bucket_lifecycle_configuration
  5. Copiar snippets
  6. Pegar en el editor
  7. Descubrir que estás usando atributos deprecados
  8. Volver al Registry
  9. Rezar

Con el MCP Server, le escribís esto a tu agente:

How do I configure an AWS S3 bucket with versioning enabled and a 
lifecycle policy that moves objects to Glacier after 90 days?
Use the latest version of the AWS provider.
Enter fullscreen mode Exit fullscreen mode

El agente llama a search_providers para encontrar el provider de AWS, después a get_provider_details para cada recurso relevante, y te devuelve esto:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

resource "aws_s3_bucket" "example" {
  bucket = "mi-bucket-con-versioning"
}

resource "aws_s3_bucket_versioning" "example" {
  bucket = aws_s3_bucket.example.id

  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_s3_bucket_lifecycle_configuration" "example" {
  bucket = aws_s3_bucket.example.id

  rule {
    id     = "mover-a-glacier"
    status = "Enabled"

    transition {
      days          = 90
      storage_class = "GLACIER"
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

HCL correcto. Recursos separados según la estructura actual del provider v5. Sin atributos deprecados. Sin tabs extras abiertas.

¿La diferencia que más importa? Como el MCP consulta el Registry en tiempo real, no te va a devolver el esquema de la versión 3 del provider AWS que aprendió hace meses. Te da lo que está vigente hoy.

Laboratorio: hacelo vos ahora mismo

Ya tenés el MCP corriendo. Hora de probarlo con algo concreto y sin dependencias de nube — sin AWS, sin credenciales, sin nada. Solo Terraform y tu filesystem local.

Copiá este prompt exacto en tu agente:

Usa Terraform MCP para revisar el provider hashicorp/local 
y luego genera un ejemplo mínimo funcional en Terraform.
Enter fullscreen mode Exit fullscreen mode

El agente va a llamar a search_providers con hashicorp/local, después a get_provider_details para ver los recursos disponibles, y te va a devolver algo así:

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}

# Crea un archivo de texto en tu sistema local
resource "local_file" "ejemplo" {
  content  = "Hola desde Terraform MCP 🔥"
  filename = "${path.module}/output.txt"
}

# Lee un archivo existente (data source)
data "local_file" "leeme" {
  filename = "${path.module}/output.txt"
}

output "contenido" {
  value = local_file.ejemplo.content
}
Enter fullscreen mode Exit fullscreen mode

Guardás eso en un main.tf, y ejecutás:

terraform init
terraform apply -auto-approve
cat output.txt
Enter fullscreen mode Exit fullscreen mode

¿Qué acaba de pasar?

El agente no usó su memoria de entrenamiento para saber qué atributos acepta local_file. Consultó el Registry en tiempo real vía MCP, obtuvo la documentación actualizada del provider hashicorp/local v2.5, y generó HCL válido contra esa versión específica.

Resultado: un archivo output.txt en tu directorio con el contenido que le pediste. Sin abrir el Registry. Sin chequear si content o file_content era el atributo correcto en esta versión.

💡 Por qué este ejemplo importa: hashicorp/local es el provider más sencillo que existe en Terraform — no necesita credenciales de nube ni configuración extra. Si el MCP funciona acá, funciona en cualquier otro provider. Es el hello world perfecto para validar que el setup está bien antes de meterle AWS, GCP o Azure.

Una nota sobre seguridad (no la saltees)

El MCP Server es una herramienta poderosa. Algunas consideraciones antes de usarlo en un entorno de equipo:

Corrélo local. La recomendación oficial es correrlo en 127.0.0.1 vía STDIO o HTTP Streamable. No expongas el servidor directamente a internet.

Permisos mínimos para el TFE_TOKEN. Si lo configurás con HCP Terraform, dale al token solo los permisos que necesita. Nada más.

ENABLE_TF_OPERATIONS está OFF por defecto, y con razón. Esta variable habilita operaciones destructivas como auto_approve y is_destroy. No la toques hasta entender bien qué hace. Lo cubrimos en detalle en el Episodio 6.

Rate limiting. Si lo usás en equipo o de forma intensiva, configurá los límites de requests para no saturar el Registry:

MCP_RATE_LIMIT_GLOBAL=10:20   # 10 req/seg, burst de 20
MCP_RATE_LIMIT_SESSION=5:10   # por sesión
Enter fullscreen mode Exit fullscreen mode

Lo que acabás de conectar

Con este setup tenés un agente que:

✅ Sabe qué resources existen en cualquier provider de Terraform, en la versión actual

✅ Puede buscar y recomendar módulos del Registry según lo que necesitás

✅ Genera HCL válido sin depender de datos de entrenamiento desactualizados

✅ Puede hablar con tus workspaces de HCP Terraform si lo configurás

Y todo desde tu IDE. Sin cambiar de pantalla. Sin abrir el Registry manualmente.

Próximo episodio

Episodio 2 → Escribí módulos de Terraform sin acordarte de la sintaxis

Workflow completo con MCP + Cursor en modo Agent para crear módulos reutilizables desde cero. Inputs, outputs, variables — todo generado y validado contra el Registry en tiempo real. Y lo más importante: qué pasa cuando el agente se equivoca y cómo corregirlo sin perder el hilo.

¿Te resultó útil? Compartilo con ese colega que todavía tiene 20 tabs del Registry abiertas.

Seguime en 295devops.com para el resto de la serie.

Recursos

Top comments (0)