Terraform MCP Server

Terraform MCP Server

Der Terraform MCP Server ist ein Model Context Protocol (MCP) Server, der nahtlos mit den Terraform Registry- und HCP Terraform-APIs integriert und erweiterte Automatisierungs- und Interaktionsmöglichkeiten für die Entwicklung von Infrastructure as Code (IaC) bietet.

Inhaltsverzeichnis

Funktionen

• Unterstützung für zwei Transporte: Sowohl Stdio- als auch StreamableHTTP-Transporte mit konfigurierbaren Endpunkten
• Terraform Registry-Integration: Direkte Integration mit öffentlichen Terraform Registry-APIs für Provider, Module und Richtlinien
• HCP Terraform & Terraform Enterprise-Unterstützung: Vollständige Workspace-Verwaltung, Auflistung von Organisationen/Projekten und Zugriff auf private Registries
• Workspace-Operationen: Erstellen, Aktualisieren, Löschen von Workspaces mit Unterstützung für Variablen, Tags und Run-Verwaltung
• OTel-Metriken zur Überwachung der Tool-Nutzung: Integration mit Open-Telemetry-Messgeräten zur Verfolgung von Tool-Aufrufvolumen, Latenz und Fehlern im Streamable-HTTP-Modus. Zeigt außerdem Standard-HTTP-Servermetriken an, wenn diese Funktion aktiviert ist

Sicherheitshinweis: Abhängig von der Abfrage kann der MCP-Server bestimmte Terraform-Daten an den MCP-Client und die LLM weitergeben. Verwenden Sie den MCP-Server nicht mit nicht vertrauenswürdigen MCP-Clients oder LLMs.

Rechtlicher Hinweis: Ihre Nutzung eines Drittanbieter-MCP-Clients/LLM unterliegt ausschließlich den Nutzungsbedingungen dieses MCP/LLM, und IBM ist nicht verantwortlich für die Leistung solcher Drittanbieter-Tools. IBM lehnt ausdrücklich alle Gewährleistungen und Haftung für Drittanbieter-MCP-Clients/LLMs ab und kann möglicherweise keinen Support zur Behebung von Problemen bieten, die durch die Drittanbieter-Tools verursacht werden.

Vorsicht: Die Ausgaben und Empfehlungen des MCP-Servers werden dynamisch generiert und können je nach Abfrage, Modell und verbundenem MCP-Client variieren. Benutzer sollten alle Ausgaben/Empfehlungen gründlich prüfen, um sicherzustellen, dass sie vor der Implementierung mit den Sicherheits-Best-Practices, Kosteneffizienzzielen und Compliance-Anforderungen ihrer Organisation übereinstimmen.

Voraussetzungen

1. Stellen Sie sicher, dass Docker installiert ist und ausgeführt wird, um den Server in einer containerisierten Umgebung zu verwenden.
2. Installieren Sie einen KI-Assistenten, der das Model Context Protocol (MCP) unterstützt.

Kommandozeilenoptionen

Umgebungsvariablen:

# Stdio mode
terraform-mcp-server stdio [--log-file /path/to/log] [--log-level info] [--log-format text] [--toolsets <toolsets>] [--tools <tools>]

# StreamableHTTP mode
terraform-mcp-server streamable-http [--transport-port 8080] [--transport-host 127.0.0.1] [--mcp-endpoint /mcp] [--organization-allowlist <orgs-csv>] [--log-file /path/to/log] [--log-level info] [--log-format text] [--toolsets <toolsets>] [--tools <tools>]

Anweisungen

Standardanweisungen für den MCP-Server befinden sich in cmd/terraform-mcp-server/instructions.md. Wenn diese für die Terraform-Praktiken Ihrer Organisation nicht geeignet erscheinen oder der MCP-Server ungenaue Antworten erzeugt, ersetzen Sie sie bitte durch Ihre eigenen Anweisungen und erstellen Sie den Container oder die Binärdatei neu. Ein Beispiel für solche Anweisungen befindet sich in instructions/example-mcp-instructions.md

AGENTS.md verhält sich im Wesentlichen wie READMEs für Codierungsagenten: ein dedizierter, vorhersehbarer Ort, um Kontext und Anweisungen bereitzustellen, die KI-Codierungsagenten bei der Arbeit an Ihrem Projekt unterstützen. Eine AGENTS.md-Datei funktioniert mit verschiedenen Codierungsagenten. Ein Beispiel für solche Anweisungen befindet sich in instructions/example-AGENTS.md. Um es zu verwenden, committen Sie eine Datei mit dem Namen AGENTS.md in das Verzeichnis, in dem sich Ihre Terraform-Konfigurationen befinden.

Installation

Verwendung mit Visual Studio Code

Fügen Sie den folgenden JSON-Block zu Ihrer Benutzereinstellungsdatei (JSON) in VS Code hinzu. Sie können dies tun, indem Sie Ctrl + Shift + P drücken und Preferences: Open User Settings (JSON) eingeben.

Weitere Informationen zur Verwendung von MCP-Server-Tools finden Sie in der Agentenmodus-Dokumentation von VS Code.

{
  "mcp": {
    "servers": {
      "terraform": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-e", "TFE_TOKEN=${input:tfe_token}",
          "-e", "TFE_ADDRESS=${input:tfe_address}",
          "hashicorp/terraform-mcp-server:1.3.0"
        ]
      }
    },
    "inputs": [
      {
        "type": "promptString",
        "id": "tfe_token",
        "description": "Terraform API Token",
        "password": true
      },
      {
        "type": "promptString",
        "id": "tfe_address",
        "description": "Terraform Address",
        "password": false
      }
    ]
  }
}

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

Optional können Sie ein ähnliches Beispiel (d. h. ohne den mcp-Schlüssel) zu einer Datei namens .vscode/mcp.json in Ihrem Arbeitsbereich hinzufügen. Dadurch können Sie die Konfiguration mit anderen teilen.

{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "TFE_TOKEN=${input:tfe_token}",
        "-e", "TFE_ADDRESS=${input:tfe_address}",
        "hashicorp/terraform-mcp-server:1.3.0"
      ]
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "tfe_token",
      "description": "Terraform API Token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "tfe_address",
      "description": "Terraform Address",
      "password": false
    }
  ]
}

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

Verwendung mit Cursor

Fügen Sie dies zu Ihrer Cursor-Konfiguration (~/.cursor/mcp.json) hinzu oder über Einstellungen → Cursor-Einstellungen → MCP:

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "TFE_ADDRESS=<<PASTE_TFE_ADDRESS_HERE>>",
        "-e", "TFE_TOKEN=<<PASTE_TFE_TOKEN_HERE>>",
        "hashicorp/terraform-mcp-server:1.3.0"
      ]
    }
  }
}

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

Verwendung mit Claude Desktop / Amazon Q Developer / Kiro CLI

Weitere Informationen zur Verwendung von MCP-Server-Tools in Claude Desktop finden Sie in der Benutzerdokumentation. Lesen Sie mehr über die Verwendung des MCP-Servers in Amazon Q Developer und Kiro CLI.

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "TFE_ADDRESS=<<PASTE_TFE_ADDRESS_HERE>>",
        "-e", "TFE_TOKEN=<<PASTE_TFE_TOKEN_HERE>>",
        "hashicorp/terraform-mcp-server:1.3.0"
      ]
    }
  }
}

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "hashicorp/terraform-mcp-server:0.2.3"
      ]
    }
  }
}

Verwendung mit Claude Code

Weitere Informationen zur Verwendung und zum Hinzufügen von MCP-Server-Tools in Claude Code finden Sie in der Benutzerdokumentation

• Lokaler (stdio) Transport

claude mcp add terraform -s user -t stdio -- docker run -i --rm hashicorp/terraform-mcp-server

• Remote (streamable-http) Transport

# Run server (example)
docker run -p 8080:8080 --rm -e TRANSPORT_MODE=streamable-http -e TRANSPORT_HOST=0.0.0.0 hashicorp/terraform-mcp-server

# Add to Claude Code
claude mcp add --transport http terraform http://localhost:8080/mcp

Verwendung mit Codex CLI

Weitere Informationen zur Verwendung und zum Hinzufügen von MCP-Server-Tools in Codex CLI finden Sie in der Benutzerdokumentation.

Hinweis: Fügen Sie TFE_ADDRESS und TFE_TOKEN zu den Docker-Befehlen für authentifizierte HCP Terraform- oder Terraform Enterprise-Tools hinzu.

• Lokaler (stdio) Transport

codex mcp add terraform -- docker run -i --rm hashicorp/terraform-mcp-server

• Remote (streamable-http) Transport

# Run server (example)
docker run --rm -p 127.0.0.1:8080:8080 -e TRANSPORT_MODE=streamable-http -e TRANSPORT_HOST=0.0.0.0 hashicorp/terraform-mcp-server

# Add to Codex
codex mcp add terraform --url http://localhost:8080/mcp

Verwendung mit Gemini-Erweiterungen

Aus Sicherheitsgründen sollten Sie Ihre Anmeldeinformationen nicht fest codieren. Erstellen oder aktualisieren Sie ~/.gemini/.env (wobei ~ Ihr Home- oder Projektverzeichnis ist), um HCP Terraform- oder Terraform Enterprise-Anmeldeinformationen zu speichern.

# ~/.gemini/.env
TFE_ADDRESS=your_tfe_address_here
TFE_TOKEN=your_tfe_token_here

Installieren Sie die Erweiterung und führen Sie Gemini aus

gemini extensions install https://github.com/hashicorp/terraform-mcp-server
gemini

Verwendung mit Bob IDE / Shell

Weitere Informationen zur Verwendung und zum Hinzufügen von MCP-Server-Tools in Bob IDE oder Shell finden Sie unter Using MCP in Bob.

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "TFE_ADDRESS=<<PASTE_TFE_ADDRESS_HERE>>",
        "-e", "TFE_TOKEN=<<PASTE_TFE_TOKEN_HERE>>",
        "hashicorp/terraform-mcp-server:1.3.0"
      ],
      "disabled": false
    }
  }
}

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "hashicorp/terraform-mcp-server:0.2.3"
      ],
      "disabled": false
    }
  }
}

Installation aus dem Quellcode

Verwenden Sie die neueste Release-Version:

go install github.com/hashicorp/terraform-mcp-server/cmd/terraform-mcp-server@latest

Verwenden Sie den Hauptzweig:

go install github.com/hashicorp/terraform-mcp-server/cmd/terraform-mcp-server@main

{
  "mcp": {
    "servers": {
      "terraform": {
        "type": "stdio",
        "command": "/path/to/terraform-mcp-server",
        "env": {
          "TFE_TOKEN": "<<TFE_TOKEN_HERE>>"
        },
      }
    }
  }
}

{
  "mcp": {
    "servers": {
      "terraform": {
        "type": "stdio",
        "command": "/path/to/terraform-mcp-server"
      }
    }
  }
}

Erstellen des Docker-Images lokal

Bevor Sie den Server verwenden, müssen Sie das Docker-Image lokal erstellen:

1. Klonen Sie das Repository:

git clone https://github.com/hashicorp/terraform-mcp-server.git
cd terraform-mcp-server

2. Erstellen Sie das Docker-Image:

make docker-build

3. Dadurch wird ein lokales Docker-Image erstellt, das Sie in der folgenden Konfiguration verwenden können.

# Run in stdio mode
docker run -i --rm terraform-mcp-server:dev

# Run in streamable-http mode
docker run -p 8080:8080 --rm -e TRANSPORT_MODE=streamable-http -e TRANSPORT_HOST=0.0.0.0 terraform-mcp-server:dev

# Filter tools (optional)
docker run -i --rm terraform-mcp-server:dev --toolsets=registry,terraform
docker run -i --rm terraform-mcp-server:dev --tools=search_providers,get_provider_details

Hinweis: Wenn Sie Docker verwenden, sollten Sie TRANSPORT_HOST=0.0.0.0 setzen, um Verbindungen von außerhalb des Containers zu ermöglichen.

4. (Optional) Testen Sie die Verbindung im HTTP-Modus

# Test the connection
curl http://localhost:8080/health

5. Sie können es wie folgt in Ihrem KI-Assistenten verwenden:

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "terraform-mcp-server:dev"
      ]
    }
  }
}

Verfügbare Tools

Sehen Sie sich die verfügbaren Tools hier an :link:

Verfügbare Ressourcen

Sehen Sie sich die verfügbaren Ressourcen hier an :link:

Verfügbare Metriken

Es werden zwei Arten von Metriken erfasst. Zunächst werden standardmäßige HTTP-Servermetriken hinzugefügt, indem der HTTP-Mux mit otelhttp.NewHandler(...) umschlossen wird. Dies erzeugt:

1. http.server.request.body.size
2. http.server.response.body.size
3. http.server.request.duration

Zweitens zeichnet der MCP-Server benutzerdefinierte Tool-Metriken rund um die Tool-Ausführung mithilfe von MCP-Hooks (BeforeCallTool / AfterCallTool) auf. Diese erzeugen:

1. mcp_tool_calls_total
2. mcp_tool_errors_total
3. mcp_tool_duration_seconds

Tool-Filterung

Steuern Sie, welche Tools verfügbar sind, mithilfe von --toolsets (Gruppen) oder --tools (einzeln):

# Enable tool groups (default: registry)
terraform-mcp-server --toolsets=registry,terraform

# Enable specific tools only
terraform-mcp-server --tools=search_providers,get_provider_details,list_workspaces

Verfügbare Toolsets: registry, registry-private, terraform, all, default. Siehe pkg/toolsets/mapping.go für einzelne Toolnamen. Beide Flags können nicht gleichzeitig verwendet werden.

Transportunterstützung

Der Terraform MCP Server unterstützt mehrere Transportprotokolle:

1. Stdio-Transport (Standard)

Standard-Eingabe-/Ausgabekommunikation unter Verwendung von JSON-RPC-Nachrichten. Ideal für die lokale Entwicklung und die direkte Integration mit MCP-Clients.

2. StreamableHTTP-Transport

Moderner HTTP-basierter Transport, der sowohl direkte HTTP-Anfragen als auch Server-Sent-Events (SSE)-Streams unterstützt. Dies ist der empfohlene Transport für Remote-/verteilte Einrichtungen.

Funktionen:

• Endpunkt: http://{hostname}:8080/mcp
• Health Check: http://{hostname}:8080/health
• Umgebungskonfiguration: Setzen Sie TRANSPORT_MODE=http oder TRANSPORT_PORT=8080, um zu aktivieren
• Organisations-Allowlist: Setzen Sie MCP_ORGANIZATION_ALLOWLIST oder --organization-allowlist auf eine CSV-Liste zulässiger HCP Terraform-Organisationsnamen

Sitzungsmodi

Der Terraform MCP Server unterstützt zwei Sitzungsmodi bei Verwendung des StreamableHTTP-Transports:

• Zustandsbehafteter Modus (Standard): Behält den Sitzungszustand zwischen Anfragen bei und ermöglicht kontextbewusste Operationen.
• Zustandsloser Modus: Jede Anfrage wird unabhängig verarbeitet, ohne den Sitzungszustand beizubehalten. Dies kann für Hochverfügbarkeitsbereitstellungen oder bei Verwendung von Lastausgleichsgeräten nützlich sein.

Um den zustandslosen Modus zu aktivieren, setzen Sie die Umgebungsvariable:

export MCP_SESSION_MODE=stateless

Token-Durchreichung für zentralisierte Bereitstellungen

Wenn Sie den MCP-Server zentral (StreamableHTTP-Modus) für mehrere Benutzer ausführen, kann jeder Benutzer sein eigenes Terraform-Token über HTTP-Header für die RBAC-Durchsetzung übergeben. Dadurch kann eine einzelne Serverinstanz mehrere Benutzer mit unterschiedlichen Berechtigungen bedienen.

Wenn MCP_ORGANIZATION_ALLOWLIST oder --organization-allowlist konfiguriert ist, muss die Allowlist eine CSV-Liste von HCP Terraform-Organisationsnamen sein. Der Server erfordert Authorization: Bearer <token> und lehnt Anfragen ab, es sei denn, dieses Token kann auf mindestens eine Organisation in der CSV-Allowlist zugreifen. Das Bearer-Token hat Vorrang, wenn die Anfrage auch einen TFE_TOKEN-Header enthält, wodurch sichergestellt wird, dass das von der Allowlist validierte Token das Token ist, das für Terraform-API-Anfragen verwendet wird. Der Abgleich von Organisationsnamen erfolgt ohne Berücksichtigung der Groß-/Kleinschreibung. Wenn der konfigurierte CSV-Wert auf null Organisationsnamen analysiert wird, beendet sich der Server mit einem Fehler wegen fehlerhafter Organisations-Allowlist.

Client-IP-Weiterleitung

Wenn Sie den MCP-Server zentral hinter einem Proxy oder Lastausgleichsgerät ausführen, können Sie die IP des ursprünglichen Clients über den X-Forwarded-For-Header an HCP Terraform / TFE weiterleiten. Dies ist standardmäßig deaktiviert und muss mit MCP_FORWARD_CLIENT_IP=true aktiviert werden.

Wenn aktiviert, bezieht der Server die Client-IP gemäß MCP_REMOTE_IP_METHOD:

Vertrauensmodell

X-Forwarded-For und X-Real-IP werden von Clients und zwischengeschalteten Proxys gesetzt, sodass sie gespooft werden können, es sei denn, ein vertrauenswürdiger Proxy vor dem Server überschreibt sie. Aus diesem Grund ist der Standardwert RemoteAddr, der nur dem Peer vertraut, mit dem der Server direkt verbunden ist. Aktivieren Sie X-Real-IP oder X-Forwarded-For nur, wenn der Server hinter einem von Ihnen kontrollierten Proxy sitzt, der diese Header setzt.

Vertrauenswürdige Hops

Bei Verwendung von X-Forwarded-For ist MCP_XFF_TRUSTED_HOPS die Anzahl der Proxys, die Sie zwischen dem Server und dem Internet betreiben. Hops werden von rechts in der Kette gezählt, da jeder Proxy die Adresse anhängt, von der er die Anfrage erhalten hat, und der rechteste Eintrag vom Proxy gesetzt wird, der dem Server am nächsten ist. Der Server überspringt diese Anzahl vertrauenswürdiger Einträge und nimmt den nächsten nach links.

Zum Beispiel wählt der Server mit MCP_XFF_TRUSTED_HOPS=1 und einem Header von 200.1.2.3, 10.1.1.10 200.1.2.3 aus. Mit MCP_XFF_TRUSTED_HOPS=2 und 108.0.0.1, 200.1.2.3, 10.1.1.10, 192.168.0.1 wählt er 200.1.2.3. Wenn die Hop-Anzahl größer als die Anzahl der Einträge ist oder der ausgewählte Eintrag keine gültige IP ist, fällt der Server auf RemoteAddr zurück.

Wenn Sie die Hop-Anzahl zu niedrig einstellen, wird ein vom Client bereitgestellter Wert vertraut; wenn Sie sie zu hoch einstellen, wird eine Adresse weiter in Ihrer eigenen Infrastruktur vertraut. Stellen Sie sie auf die genaue Anzahl der Proxys ein, die Sie betreiben.

Einschränkungen

• Der Server liest nur den ersten X-Forwarded-For-Header einer Anfrage. Es ist gültig, dass eine Anfrage mehrere X-Forwarded-For-Header trägt, aber die Standardbibliothek von Go gibt nur den ersten zurück, und der Server führt sie nicht zusammen. Wenn Ihre Proxy-Kette mehrere Header ausgibt, konfigurieren Sie sie so, dass sie einen einzelnen kombinierten X-Forwarded-For-Header ausgibt.
• IPv4- und IPv6-Adressen werden beide unterstützt. Werte, die keine gültigen IPs sind, werden abgelehnt und der Server fällt auf RemoteAddr zurück.

Migration von früheren Versionen

Frühere Versionen verwendeten den linkesten X-Forwarded-For-Wert, wenn der Header vorhanden war, ohne Konfiguration. Dies war unsicher, da der linkeste Wert am einfachsten zu spoofen ist. Der Standardwert ist jetzt RemoteAddr. Wenn Sie den Server hinter einem Proxy betreiben und sich darauf verlassen, dass X-Forwarded-For an HCP Terraform / TFE weitergeleitet wird, setzen Sie MCP_REMOTE_IP_METHOD=X-Forwarded-For und MCP_XFF_TRUSTED_HOPS auf die Anzahl der Proxys, die Sie betreiben.

Unterstützte Header

Beispiel: curl

# Using TFE_TOKEN header
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "TFE_TOKEN: your-user-token" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",...}'

# Using Authorization Bearer header
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-user-token" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",...}'

Sicherheitsüberlegungen

• TFE_ADDRESS kann nicht von Clients festgelegt werden. Im Streamable-HTTP-Modus wird die Terraform-Adresse nur aus der serverseitigen TFE_ADDRESS-Umgebungsvariable (oder dem Standardwert) bezogen. Anfragen, die versuchen, TFE_ADDRESS über HTTP-Header oder Abfrageparameter festzulegen, werden mit 403 abgelehnt. Dies verhindert, dass ein Client Anfragen und das Authorization-Token an einen böswilligen Server umleitet.
• Identifizierung gehosteter Bereitstellungen: Das Festlegen von TF_MCP_SHARED_SECRET sendet diesen Wert als X-Tf-Mcp-Secret-Header bei jeder HCP Terraform / TFE-Anfrage, sodass das Backend Anfragen von einer bekannten gehosteten Bereitstellung identifizieren kann (z. B. um IP-Allowlists anzuwenden). Es ist ein statisches Geheimnis, das in einem Header gesendet wird. Verwenden Sie es daher nur über TLS und behandeln Sie den Wert als Anmeldeinformation.
• Übergeben Sie Token niemals in Abfrageparametern – der Server lehnt solche Anfragen mit einem 400-Fehler ab.
• Verwenden Sie bei zentraler Bereitstellung immer TLS (MCP_TLS_CERT_FILE/MCP_TLS_KEY_FILE), um Token während der Übertragung zu schützen.
• Konfigurieren Sie MCP_ALLOWED_ORIGINS, um einzuschränken, welche Clients eine Verbindung herstellen können.

Beispiel für eine zentralisierte Bereitstellung

# Start server centrally (no token set server-side)
docker run -p 8080:8080 \
  -e TRANSPORT_MODE=streamable-http \
  -e TRANSPORT_HOST=0.0.0.0 \
  -e TFE_ADDRESS=https://tfe.company.com \
  -e MCP_TLS_CERT_FILE=/certs/server.pem \
  -e MCP_TLS_KEY_FILE=/certs/server-key.pem \
  -e MCP_ALLOWED_ORIGINS=https://ide.company.com \
  -e MCP_ORGANIZATION_ALLOWLIST=team-alpha,team-beta \
  -v /path/to/certs:/certs \
  hashicorp/terraform-mcp-server:1.3.0

Benutzer verbinden sich dann mit ihren individuellen Token, die über Header übergeben werden, wodurch eine benutzerspezifische RBAC-Durchsetzung ermöglicht wird.

Fehlerbehebung

Unternehmensproxy / TLS-Inspektion (Zscaler usw.)

Wenn Sie hinter einem Unternehmensproxy stehen, der TLS-Inspektion durchführt (wie Zscaler Internet Access), können Zertifikatsfehler auftreten:

tls: failed to verify certificate: x509: certificate signed by unknown authority

Lösung: Montieren Sie Ihr Unternehmens-CA-Zertifikat in den Container:

docker run -i --rm \
  -v /path/to/corporate-ca.pem:/etc/ssl/certs/corporate-ca.pem \
  -e SSL_CERT_FILE=/etc/ssl/certs/corporate-ca.pem \
  hashicorp/terraform-mcp-server:1.3.0

Für MCP-Client-Konfigurationen:

{
  "mcpServers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v", "/path/to/corporate-ca.pem:/etc/ssl/certs/corporate-ca.pem",
        "-e", "SSL_CERT_FILE=/etc/ssl/certs/corporate-ca.pem",
        "-e", "TFE_TOKEN=<>",
        "hashicorp/terraform-mcp-server:1.3.0"
      ]
    }
  }
}

Alternative: Führen Sie die Binärdatei direkt aus

Wenn Docker in Ihrer Umgebung nicht zulässig ist, können Sie die Server-Binärdatei direkt installieren und ausführen, die den Zertifikatsspeicher Ihres Systems verwendet:

go install github.com/hashicorp/terraform-mcp-server/cmd/terraform-mcp-server@latest
terraform-mcp-server stdio

Entwicklung

Voraussetzungen

• Go (siehe go.mod-Datei für die spezifische Version)
• Docker (optional, für Container-Builds)

Verfügbare Make-Befehle

Mitwirken

1. Repository forken
2. Feature-Branch erstellen
3. Änderungen vornehmen
4. Tests ausführen
5. Pull-Request einreichen

Lizenz

Dieses Projekt ist unter den Bedingungen der Open-Source-Lizenz MPL-2.0 lizenziert. Bitte beachten Sie die Datei LICENSE für die vollständigen Bedingungen.

Sicherheit

Bei Sicherheitsproblemen kontaktieren Sie bitte security@hashicorp.com oder folgen Sie unserer Sicherheitsrichtlinie.

Support

Für Fehlerberichte und Funktionsanfragen öffnen Sie bitte ein Issue auf GitHub.

Für allgemeine Fragen und Diskussionen öffnen Sie eine GitHub-Diskussion.