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

• Duale Transportunterstützung: 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 und 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 das LLM weitergeben. Verwenden Sie den MCP-Server nicht mit nicht vertrauenswürdigen MCP-Clients oder LLMs.

Rechtlicher Hinweis: Ihre Nutzung eines Drittanbieter-MCP-Clients/LLMs 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 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

Die 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 hartcodieren. 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
    }
  }
}

Kubernetes (Helm)

Ein Helm-Chart für die Bereitstellung des Servers auf Kubernetes ist unter helm/terraform-mcp-server verfügbar.

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_provider_docs,get_provider_details

Hinweis: Wenn Sie in Docker ausführen, 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_provider_docs,get_provider_details,list_workspaces

Verfügbare Toolsets: registry, registry-private, terraform, all, default. Siehe pkg/toolsets/mapping.go für einzelne Tool-Namen. 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 mit JSON-RPC-Nachrichten. Ideal für lokale Entwicklung und 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 Setups.

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 der MCP-Server zentral (StreamableHTTP-Modus) für mehrere Benutzer ausgeführt wird, kann jeder Benutzer sein eigenes Terraform-Token über HTTP-Header für die RBAC-Durchsetzung übergeben. Dies ermöglicht einer einzelnen Serverinstanz, mehrere Benutzer mit unterschiedlichen Berechtigungen zu 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, um sicherzustellen, dass das durch die Allowlist validierte Token auch das für Terraform-API-Anfragen verwendete Token ist. Der Abgleich von Organisationsnamen erfolgt ohne Berücksichtigung der Groß-/Kleinschreibung. Wenn der konfigurierte CSV-Wert zu null Organisationsnamen führt, beendet sich der Server mit einem Fehler zur fehlerhaften Organisations-Allowlist.

Client-IP-Weiterleitung

Wenn der MCP-Server zentral hinter einem Proxy oder Lastausgleichsgerät ausgeführt wird, 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 den Wert 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 aus. Wenn die Hop-Anzahl größer als die Anzahl der Einträge ist oder der ausgewählte Eintrag keine gültige IP ist, greift der Server auf RemoteAddr zurück.

Wenn die Hop-Anzahl zu niedrig eingestellt ist, wird ein vom Client gelieferter Wert vertraut; wenn sie zu hoch eingestellt ist, wird eine Adresse weiter in Ihrer eigenen Infrastruktur vertraut. Setzen Sie sie auf die genaue Anzahl der Proxys, 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 Go-Standardbibliothek 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 greift 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",...}'

Sicherheitshinweise

• TFE_ADDRESS kann nicht von Clients gesetzt 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 zu setzen, werden mit 403 abgelehnt. Dies verhindert, dass ein Client Anfragen und das Authorization-Token an einen böswilligen Server umleitet.
• Identifizierung gehosteter Bereitstellungen: Das Setzen 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. zur Anwendung von IP-Allowlists). Es ist ein statisches Geheimnis, das in einem Header gesendet wird. Verwenden Sie es daher nur über TLS und behandeln Sie den Wert wie eine Anmeldeinformation.
• Übergeben Sie niemals Token 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 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 benutzerbezogene 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 dann 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 eröffnen Sie eine GitHub-Diskussion.