Terraform MCP Server

Terraform MCP Server

Terraform MCP Server คือ Model Context Protocol (MCP) เซิร์ฟเวอร์ที่ผสานรวมกับ Terraform Registry และ HCP Terraform APIs ได้อย่างราบรื่น ช่วยให้สามารถทำงานอัตโนมัติและโต้ตอบขั้นสูงสำหรับการพัฒนา Infrastructure as Code (IaC)

สารบัญ

คุณสมบัติ

• รองรับ Transport แบบคู่: รองรับทั้ง Stdio และ StreamableHTTP transports พร้อม endpoint ที่กำหนดค่าได้
• การผสานรวม Terraform Registry: การผสานรวมโดยตรงกับ Terraform Registry APIs สาธารณะสำหรับ providers, modules และ policies
• รองรับ HCP Terraform และ Terraform Enterprise: การจัดการ workspace อย่างครบถ้วน การแสดงรายการองค์กร/โปรเจกต์ และการเข้าถึง registry ส่วนตัว
• การดำเนินการกับ Workspace: สร้าง อัปเดต ลบ workspaces พร้อมรองรับ variables, tags และการจัดการ run
• เมตริก OTel สำหรับการตรวจสอบการใช้งานเครื่องมือ: การผสานรวมกับ open telemetry meters เพื่อติดตามปริมาณการเรียกใช้เครื่องมือ เวลาแฝง และความล้มเหลวในโหมด Streamable HTTP นอกจากนี้ยังแสดงเมตริกเซิร์ฟเวอร์ HTTP เริ่มต้นเมื่อเปิดใช้คุณสมบัตินี้

หมายเหตุด้านความปลอดภัย: ขึ้นอยู่กับคำค้นหา MCP server อาจเปิดเผยข้อมูล Terraform บางอย่างให้กับ MCP client และ LLM อย่าใช้ MCP server กับ MCP clients หรือ LLMs ที่ไม่น่าเชื่อถือ

หมายเหตุทางกฎหมาย: การใช้ MCP Client/LLM ของบุคคลที่สามของคุณอยู่ภายใต้ข้อกำหนดการใช้งานของ MCP/LLM นั้นเท่านั้น และ IBM ไม่รับผิดชอบต่อประสิทธิภาพของเครื่องมือบุคคลที่สามดังกล่าว IBM ขอปฏิเสธการรับประกันและความรับผิดใดๆ ทั้งสิ้นสำหรับ MCP Clients/LLMs ของบุคคลที่สาม และอาจไม่สามารถให้การสนับสนุนเพื่อแก้ไขปัญหาที่เกิดจากเครื่องมือบุคคลที่สามได้

ข้อควรระวัง: ผลลัพธ์และคำแนะนำที่ให้โดย MCP server ถูกสร้างขึ้นแบบไดนามิกและอาจแตกต่างกันไปตามคำค้นหา โมเดล และ MCP client ที่เชื่อมต่อ ผู้ใช้ควรตรวจสอบผลลัพธ์/คำแนะนำทั้งหมดอย่างละเอียดเพื่อให้แน่ใจว่าสอดคล้องกับแนวทางปฏิบัติด้านความปลอดภัย เป้าหมายด้านความคุ้มค่า และข้อกำหนดการปฏิบัติตามข้อกำหนดขององค์กรก่อนนำไปใช้งาน

ข้อกำหนดเบื้องต้น

1. ตรวจสอบให้แน่ใจว่าได้ติดตั้งและรัน Docker เพื่อใช้เซิร์ฟเวอร์ในสภาพแวดล้อมแบบ containerized
2. ติดตั้งผู้ช่วย AI ที่รองรับ Model Context Protocol (MCP)

ตัวเลือกบรรทัดคำสั่ง

ตัวแปรสภาพแวดล้อม:

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

คำแนะนำ

คำแนะนำเริ่มต้นสำหรับ MCP server อยู่ใน cmd/terraform-mcp-server/instructions.md หากไม่เหมาะสมกับแนวทางปฏิบัติ Terraform ขององค์กรของคุณ หรือหาก MCP server ให้คำตอบที่ไม่ถูกต้อง โปรดแทนที่ด้วยคำแนะนำของคุณเองและสร้าง container หรือ binary ใหม่ ตัวอย่างของคำแนะนำดังกล่าวอยู่ใน instructions/example-mcp-instructions.md

AGENTS.md ทำหน้าที่เหมือน README สำหรับ coding agents: เป็นสถานที่เฉพาะและคาดเดาได้สำหรับให้บริบทและคำแนะนำเพื่อช่วยให้ AI coding agents ทำงานในโปรเจกต์ของคุณ ไฟล์ AGENTS.md หนึ่งไฟล์ทำงานร่วมกับ coding agents ต่างๆ ได้ ตัวอย่างของคำแนะนำดังกล่าวอยู่ใน instructions/example-AGENTS.md เพื่อใช้งาน ให้ commit ไฟล์ชื่อ AGENTS.md ไปยังไดเรกทอรีที่เก็บการกำหนดค่า Terraform ของคุณ

การติดตั้ง

การใช้งานกับ Visual Studio Code

เพิ่มบล็อก JSON ต่อไปนี้ลงในไฟล์ User Settings (JSON) ของคุณใน VS Code คุณสามารถทำได้โดยกด Ctrl + Shift + P และพิมพ์ Preferences: Open User Settings (JSON)

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้เครื่องมือ MCP server ใน เอกสารโหมด agent ของ 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"
        ]
      }
    }
  }
}

คุณสามารถเพิ่มตัวอย่างที่คล้ายกัน (เช่น ไม่มีคีย์ mcp) ลงในไฟล์ชื่อ .vscode/mcp.json ใน workspace ของคุณได้ ซึ่งจะช่วยให้คุณสามารถแชร์การกำหนดค่ากับผู้อื่นได้

{
  "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"
      ]
    }
  }
}

การใช้งานกับ Cursor

เพิ่มสิ่งนี้ลงในการกำหนดค่า Cursor ของคุณ (~/.cursor/mcp.json) หรือผ่าน Settings → Cursor Settings → 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"
      ]
    }
  }
}

การใช้งานกับ Claude Desktop / Amazon Q Developer / Kiro CLI

อ่านเพิ่มเติมเกี่ยวกับการใช้เครื่องมือ MCP server ใน Claude Desktop ได้ที่ เอกสารผู้ใช้ อ่านเพิ่มเติมเกี่ยวกับการใช้ MCP server ใน Amazon Q Developer และ 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"
      ]
    }
  }
}

การใช้งานกับ Claude Code

อ่านเพิ่มเติมเกี่ยวกับการใช้และการเพิ่มเครื่องมือ MCP server ใน Claude Code ได้ที่ เอกสารผู้ใช้

• Local (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

การใช้งานกับ Codex CLI

อ่านเพิ่มเติมเกี่ยวกับการใช้และการเพิ่มเครื่องมือ MCP server ใน Codex CLI ได้ที่ เอกสารผู้ใช้

หมายเหตุ: เพิ่ม TFE_ADDRESS และ TFE_TOKEN ในคำสั่ง Docker สำหรับเครื่องมือ HCP Terraform หรือ Terraform Enterprise ที่ผ่านการรับรองความถูกต้อง

• Local (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

การใช้งานกับส่วนขยาย Gemini

เพื่อความปลอดภัย หลีกเลี่ยงการเขียนข้อมูลรับรองแบบตายตัว ให้สร้างหรืออัปเดต ~/.gemini/.env (โดยที่ ~ คือโฮมไดเรกทอรีหรือไดเรกทอรีโปรเจกต์ของคุณ) สำหรับจัดเก็บข้อมูลรับรอง HCP Terraform หรือ Terraform Enterprise

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

ติดตั้งส่วนขยายและรัน Gemini

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

การใช้งานกับ Bob IDE / Shell

อ่านเพิ่มเติมเกี่ยวกับการใช้และการเพิ่มเครื่องมือ MCP servers ใน Bob IDE หรือ Shell ได้ที่ การใช้ MCP ใน 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
    }
  }
}

ติดตั้งจากซอร์ส

ใช้เวอร์ชันรีลีสล่าสุด:

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

ใช้ branch หลัก:

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"
      }
    }
  }
}

สร้าง Docker Image ในเครื่อง

ก่อนใช้ server คุณต้องสร้าง Docker image ในเครื่องก่อน:

1. โคลน repository:

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

2. สร้าง Docker image:

make docker-build

3. ขั้นตอนนี้จะสร้าง Docker image ในเครื่องที่คุณสามารถใช้ในการกำหนดค่าต่อไปนี้

# 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

หมายเหตุ: เมื่อรันใน Docker คุณควรตั้งค่า TRANSPORT_HOST=0.0.0.0 เพื่ออนุญาตการเชื่อมต่อจากภายนอกคอนเทนเนอร์

4. (ไม่บังคับ) ทดสอบการเชื่อมต่อในโหมด http

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

5. คุณสามารถใช้กับผู้ช่วย AI ของคุณได้ดังนี้:

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

เครื่องมือที่มีให้ใช้งาน

ดูเครื่องมือที่มีให้ใช้งานที่นี่ :link:

ทรัพยากรที่มีให้ใช้งาน

ดูทรัพยากรที่มีให้ใช้งานที่นี่ :link:

เมตริกที่มีให้ใช้งาน

มีการเก็บเมตริกสองประเภท ประการแรก เมตริกมาตรฐานของ HTTP server จะถูกเพิ่มโดยการครอบ HTTP mux ด้วย otelhttp.NewHandler(...) ซึ่งจะส่งออก:

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

ประการที่สอง MCP server จะบันทึกเมตริกเครื่องมือแบบกำหนดเองรอบการทำงานของเครื่องมือโดยใช้ MCP hooks (BeforeCallTool / AfterCallTool) ซึ่งจะส่งออก:

1. mcp_tool_calls_total
2. mcp_tool_errors_total
3. mcp_tool_duration_seconds

การกรองเครื่องมือ

ควบคุมว่าเครื่องมือใดบ้างที่พร้อมใช้งานโดยใช้ --toolsets (กลุ่ม) หรือ --tools (รายบุคคล):

# 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

ชุดเครื่องมือที่มีให้ใช้งาน: registry, registry-private, terraform, all, default ดู pkg/toolsets/mapping.go สำหรับชื่อเครื่องมือแต่ละรายการ ไม่สามารถใช้ทั้งสอง flag พร้อมกันได้

การรองรับ Transport

Terraform MCP Server รองรับโปรโตคอล transport หลายแบบ:

1. Stdio Transport (ค่าเริ่มต้น)

การสื่อสารผ่าน standard input/output โดยใช้ข้อความ JSON-RPC เหมาะสำหรับการพัฒนาท้องถิ่นและการเชื่อมต่อโดยตรงกับ MCP clients

2. StreamableHTTP Transport

Transport ที่ใช้ HTTP สมัยใหม่ รองรับทั้งคำขอ HTTP โดยตรงและสตรีม Server-Sent Events (SSE) นี่คือ transport ที่แนะนำสำหรับการตั้งค่าระยะไกล/แบบกระจาย

คุณสมบัติ:

• Endpoint: http://{hostname}:8080/mcp
• Health Check: http://{hostname}:8080/health
• การกำหนดค่าสภาพแวดล้อม: ตั้งค่า TRANSPORT_MODE=http หรือ TRANSPORT_PORT=8080 เพื่อเปิดใช้งาน
• รายการอนุญาตองค์กร: ตั้งค่า MCP_ORGANIZATION_ALLOWLIST หรือ --organization-allowlist เป็นรายการ CSV ของชื่อองค์กร HCP Terraform ที่อนุญาต

โหมดเซสชัน

Terraform MCP Server รองรับสองโหมดเซสชันเมื่อใช้ StreamableHTTP transport:

• Stateful Mode (ค่าเริ่มต้น): รักษาสถานะเซสชันระหว่างคำขอ ทำให้สามารถดำเนินการที่คำนึงถึงบริบทได้
• Stateless Mode: แต่ละคำขอจะถูกประมวลผลอย่างอิสระโดยไม่รักษาสถานะเซสชัน ซึ่งมีประโยชน์สำหรับการปรับใช้ที่มีความพร้อมใช้งานสูงหรือเมื่อใช้ load balancers

เพื่อเปิดใช้งาน stateless mode ให้ตั้งค่าตัวแปรสภาพแวดล้อม:

export MCP_SESSION_MODE=stateless

Token Passthrough สำหรับการปรับใช้แบบรวมศูนย์

เมื่อรัน MCP server แบบรวมศูนย์ (โหมด StreamableHTTP) สำหรับผู้ใช้หลายคน ผู้ใช้แต่ละคนสามารถส่ง token Terraform ของตนเองผ่าน HTTP headers สำหรับการบังคับใช้ RBAC ซึ่งช่วยให้อินสแตนซ์ server เดียวสามารถให้บริการผู้ใช้หลายคนที่มีสิทธิ์ต่างกันได้

เมื่อกำหนดค่า MCP_ORGANIZATION_ALLOWLIST หรือ --organization-allowlist รายการอนุญาตต้องเป็นรายการ CSV ของชื่อองค์กร HCP Terraform server ต้องการ Authorization: Bearer <token> และปฏิเสธคำขอเว้นแต่ token นั้นจะสามารถเข้าถึงองค์กรอย่างน้อยหนึ่งองค์กรในรายการอนุญาต CSV bearer token จะมีความสำคัญกว่า หากคำขอยังมี header TFE_TOKEN ด้วย เพื่อให้แน่ใจว่า token ที่ตรวจสอบโดยรายการอนุญาตคือ token ที่ใช้สำหรับคำขอ Terraform API การจับคู่ชื่อองค์กรไม่คำนึงถึงตัวพิมพ์เล็กใหญ่ หากค่า CSV ที่กำหนดค่าไว้แยกวิเคราะห์เป็นชื่อองค์กรศูนย์ชื่อ server จะออกจากระบบด้วยข้อผิดพลาดรายการอนุญาตองค์กรที่ไม่ถูกต้อง

การส่งต่อ IP ของไคลเอ็นต์

เมื่อรัน MCP server แบบรวมศูนย์หลัง proxy หรือ load balancer คุณสามารถส่งต่อ IP ของไคลเอ็นต์ต้นทางไปยัง HCP Terraform / TFE ผ่าน header X-Forwarded-For ได้ โดยค่าเริ่มต้นปิดอยู่และต้องเปิดใช้งานด้วย MCP_FORWARD_CLIENT_IP=true

เมื่อเปิดใช้งาน server จะใช้ IP ของไคลเอ็นต์ตาม MCP_REMOTE_IP_METHOD:

โมเดลความเชื่อถือ

X-Forwarded-For และ X-Real-IP ถูกตั้งค่าโดยไคลเอ็นต์และ proxy ตัวกลาง ดังนั้นจึงสามารถปลอมแปลงได้ เว้นแต่ proxy ที่เชื่อถือได้หน้า server จะเขียนทับ ค่านี้ด้วยเหตุนี้ค่าเริ่มต้นคือ RemoteAddr ซึ่งเชื่อถือเฉพาะ peer ที่ server เชื่อมต่อโดยตรงเท่านั้น เปิดใช้งาน X-Real-IP หรือ X-Forwarded-For เฉพาะเมื่อ server อยู่หลัง proxy ที่คุณควบคุมซึ่งตั้งค่า headers เหล่านี้

จำนวน hop ที่เชื่อถือได้

เมื่อใช้ X-Forwarded-For ค่า MCP_XFF_TRUSTED_HOPS คือจำนวน proxy ที่คุณดำเนินการระหว่าง server และอินเทอร์เน็ต นับ hop จากทางขวาของ chain เนื่องจากแต่ละ proxy จะเพิ่มที่อยู่ที่ได้รับคำขอ และรายการขวาสุดถูกตั้งค่าโดย proxy ที่ใกล้กับ server มากที่สุด server จะข้ามรายการที่เชื่อถือได้จำนวนนั้นและใช้รายการถัดไปทางซ้าย

ตัวอย่างเช่น ด้วย MCP_XFF_TRUSTED_HOPS=1 และ header เป็น 200.1.2.3, 10.1.1.10 server จะเลือก 200.1.2.3 ด้วย MCP_XFF_TRUSTED_HOPS=2 และ 108.0.0.1, 200.1.2.3, 10.1.1.10, 192.168.0.1 จะเลือก 200.1.2.3 หากจำนวน hop มากกว่าจำนวนรายการ หรือรายการที่เลือกไม่ใช่ IP ที่ถูกต้อง server จะใช้ RemoteAddr แทน

การตั้งค่าจำนวน hop ต่ำเกินไปจะเชื่อถือค่าที่ไคลเอ็นต์ส่งมา การตั้งค่าสูงเกินไปจะเชื่อถือที่อยู่ที่ลึกเข้าไปในโครงสร้างพื้นฐานของคุณเอง ตั้งค่าเป็นจำนวน proxy ที่คุณรันอย่างแน่นอน

ข้อจำกัด

• server อ่านเฉพาะ header X-Forwarded-For แรกบนคำขอเท่านั้น การที่คำขอมีหลาย header X-Forwarded-For นั้นถูกต้อง แต่ไลบรารีมาตรฐานของ Go จะคืนค่าเฉพาะค่าแรก และ server จะไม่รวมเข้าด้วยกัน หาก chain proxy ของคุณส่งหลาย headers ให้กำหนดค่าให้ส่ง header X-Forwarded-For เดียวที่รวมกัน
• รองรับทั้งที่อยู่ IPv4 และ IPv6 ค่าที่ไม่ใช่ IP ที่ถูกต้องจะถูกปฏิเสธและ server จะใช้ RemoteAddr แทน

การย้ายจากเวอร์ชันก่อนหน้า

เวอร์ชันก่อนหน้าใช้ค่า X-Forwarded-For ซ้ายสุดเมื่อมี header โดยไม่มีการกำหนดค่า ซึ่งไม่ปลอดภัย เนื่องจากค่าซ้ายสุดถูกปลอมแปลงได้ง่ายที่สุด ค่าเริ่มต้นตอนนี้คือ RemoteAddr หากคุณรัน server หลัง proxy และพึ่งพาการส่งต่อ X-Forwarded-For ไปยัง HCP Terraform / TFE ให้ตั้งค่า MCP_REMOTE_IP_METHOD=X-Forwarded-For และ MCP_XFF_TRUSTED_HOPS เป็นจำนวน proxy ที่คุณดำเนินการ

Headers ที่รองรับ

ตัวอย่าง: 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",...}'

ข้อควรพิจารณาด้านความปลอดภัย

• TFE_ADDRESS ไม่สามารถตั้งค่าโดยไคลเอ็นต์ได้ ในโหมด streamable-http ที่อยู่ Terraform จะถูกดึงจากตัวแปรสภาพแวดล้อม TFE_ADDRESS ฝั่ง server เท่านั้น (หรือค่าเริ่มต้น) คำขอที่พยายามตั้งค่า TFE_ADDRESS ผ่าน HTTP header หรือ query parameter จะถูกปฏิเสธด้วยรหัส 403 ซึ่งป้องกันไม่ให้ไคลเอ็นต์เปลี่ยนเส้นทางคำขอและ token Authorization ไปยัง server ที่เป็นอันตราย
• การระบุการปรับใช้แบบโฮสต์: การตั้งค่า TF_MCP_SHARED_SECRET จะส่งค่านั้นเป็น header X-Tf-Mcp-Secret ในทุกคำขอ HCP Terraform / TFE ทำให้ backend ระบุคำขอจากการปรับใช้แบบโฮสต์ที่รู้จักได้ (เช่น การใช้ IP allowlists) เป็นความลับแบบคงที่ที่ส่งใน header ดังนั้นใช้ผ่าน TLS เท่านั้นและถือว่าค่าเป็นข้อมูลรับรอง
• ห้ามส่ง token ใน query parameters - server จะปฏิเสธคำขอดังกล่าวด้วยข้อผิดพลาด 400
• ใช้ TLS เสมอ (MCP_TLS_CERT_FILE/MCP_TLS_KEY_FILE) เมื่อปรับใช้แบบรวมศูนย์เพื่อปกป้อง token ระหว่างการส่ง
• กำหนดค่า MCP_ALLOWED_ORIGINS เพื่อจำกัดว่าไคลเอ็นต์ใดสามารถเชื่อมต่อได้

ตัวอย่างการปรับใช้แบบรวมศูนย์

# 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

ผู้ใช้เชื่อมต่อด้วย token ส่วนบุคคลที่ส่งผ่าน headers ทำให้สามารถบังคับใช้ RBAC ต่อผู้ใช้ได้

การแก้ไขปัญหา

Corporate Proxy / การตรวจสอบ TLS (Zscaler ฯลฯ)

หากคุณอยู่หลัง corporate proxy ที่ทำการตรวจสอบ TLS (เช่น Zscaler Internet Access) คุณอาจพบข้อผิดพลาดใบรับรอง:

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

วิธีแก้ไข: ติดตั้งใบรับรอง CA ขององค์กรของคุณลงในคอนเทนเนอร์:

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

สำหรับการกำหนดค่า MCP client:

{
  "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"
      ]
    }
  }
}

ทางเลือก: รันไบนารีโดยตรง

หากไม่ได้รับอนุญาตให้ใช้ Docker ในสภาพแวดล้อมของคุณ คุณสามารถติดตั้งและรันไบนารี server ได้โดยตรง ซึ่งจะใช้ที่เก็บใบรับรองของระบบ:

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

การพัฒนา

ข้อกำหนดเบื้องต้น

• Go (ตรวจสอบไฟล์ go.mod สำหรับเวอร์ชันเฉพาะ)
• Docker (ไม่บังคับ สำหรับการสร้างคอนเทนเนอร์)

คำสั่ง Make ที่มีให้ใช้งาน

การมีส่วนร่วม

1. Fork repository
2. สร้าง feature branch ของคุณ
3. ทำการเปลี่ยนแปลงของคุณ
4. รันการทดสอบ
5. ส่ง pull request

สัญญาอนุญาต

โปรเจกต์นี้อยู่ภายใต้สัญญาอนุญาตโอเพนซอร์ส MPL-2.0 โปรดดูไฟล์ LICENSE สำหรับข้อกำหนดฉบับเต็ม

ความปลอดภัย

สำหรับปัญหาด้านความปลอดภัย โปรดติดต่อ security@hashicorp.com หรือปฏิบัติตาม นโยบายความปลอดภัย ของเรา

การสนับสนุน

สำหรับรายงานข้อบกพร่องและคำขอฟีเจอร์ โปรดเปิด issue บน GitHub

สำหรับคำถามทั่วไปและการสนทนา โปรดเปิด GitHub Discussion