Terraform MCP Server

Terraform MCP Server

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

คุณสมบัติ

• รองรับการขนส่งสองรูปแบบ: รองรับทั้งการขนส่งแบบ Stdio และ StreamableHTTP พร้อมจุดสิ้นสุดที่กำหนดค่าได้
• การผสานรวม Terraform Registry: ผสานรวมโดยตรงกับ Terraform Registry APIs สาธารณะสำหรับ providers, modules และ policies
• รองรับ HCP Terraform และ Terraform Enterprise: การจัดการ workspace อย่างเต็มรูปแบบ, การแสดงรายการ organization/project และการเข้าถึง private registry
• การดำเนินการกับ Workspace: สร้าง, อัปเดต, ลบ workspaces พร้อมรองรับตัวแปร, แท็ก และการจัดการ 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 แล้ว เพื่อใช้งานเซิร์ฟเวอร์ในสภาพแวดล้อมแบบคอนเทนเนอร์
2. ติดตั้ง AI assistant ที่รองรับ 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 สร้างการตอบสนองที่ไม่ถูกต้อง โปรดแทนที่ด้วยคำแนะนำของคุณเองและสร้างคอนเทนเนอร์หรือไบนารีใหม่ ตัวอย่างของคำแนะนำดังกล่าวอยู่ใน instructions/example-mcp-instructions.md

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

การติดตั้ง

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

เพิ่ม JSON block ต่อไปนี้ลงในไฟล์ 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.1.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.1.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.1.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.1.0"
      ]
    }
  }
}

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

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

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

• การขนส่งแบบ Local (stdio)

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

• การขนส่งแบบ Remote (streamable-http)

# 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

การใช้งานกับ Gemini extensions

เพื่อความปลอดภัย หลีกเลี่ยงการ hardcoding ข้อมูลประจำตัวของคุณ สร้างหรืออัปเดต ~/.gemini/.env (โดยที่ ~ คือ home หรือ project directory ของคุณ) สำหรับจัดเก็บข้อมูลประจำตัว HCP Terraform หรือ Terraform Enterprise

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

ติดตั้ง extension และรัน 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.1.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

ใช้ main 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 ภายในเครื่อง

ก่อนใช้งานเซิร์ฟเวอร์ คุณต้องสร้าง 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 assistant ของคุณได้ดังนี้:

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

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

ตรวจสอบเครื่องมือที่พร้อมใช้งานได้ที่นี่ :link:

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

ตรวจสอบทรัพยากรที่พร้อมใช้งานได้ที่นี่ :link:

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

มีการเก็บรวบรวมเมตริกสองประเภท ประการแรก เมตริกเซิร์ฟเวอร์ HTTP มาตรฐานถูกเพิ่มโดยการห่อ 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 สำหรับชื่อเครื่องมือแต่ละตัว ไม่สามารถใช้แฟล็กทั้งสองร่วมกันได้

การสนับสนุนการขนส่ง

Terraform MCP Server รองรับโปรโตคอลการขนส่งหลายรูปแบบ:

1. การขนส่งแบบ Stdio (ค่าเริ่มต้น)

การสื่อสารผ่านอินพุต/เอาต์พุตมาตรฐานโดยใช้ข้อความ JSON-RPC เหมาะสำหรับการพัฒนาในเครื่องและการผสานรวมโดยตรงกับไคลเอนต์ MCP

2. การขนส่งแบบ StreamableHTTP

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

คุณสมบัติ:

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

โหมดเซสชัน

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

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

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

export MCP_SESSION_MODE=stateless

การส่งผ่านโทเค็นสำหรับการปรับใช้แบบรวมศูนย์

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

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

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

เมื่อเรียกใช้เซิร์ฟเวอร์ MCP แบบรวมศูนย์หลังพร็อกซีหรือตัวจัดสรรภาระงาน คุณสามารถส่งต่อ IP ต้นทางของไคลเอนต์ไปยัง HCP Terraform / TFE ผ่านส่วนหัว X-Forwarded-For ได้ ซึ่งปิดใช้งานโดยค่าเริ่มต้นและต้องเปิดใช้งานด้วย MCP_FORWARD_CLIENT_IP=true

เมื่อเปิดใช้งาน เซิร์ฟเวอร์จะหา IP ของไคลเอนต์ตาม MCP_REMOTE_IP_METHOD:

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

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

ฮอปที่เชื่อถือได้

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

ตัวอย่างเช่น ด้วย MCP_XFF_TRUSTED_HOPS=1 และส่วนหัวของ 200.1.2.3, 10.1.1.10 เซิร์ฟเวอร์จะเลือก 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 หากจำนวนฮอปมากกว่าจำนวนรายการ หรือรายการที่เลือกไม่ใช่ IP ที่ถูกต้อง เซิร์ฟเวอร์จะถอยกลับไปใช้ RemoteAddr

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

ข้อจำกัด

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

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

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

ส่วนหัวที่รองรับ

ตัวอย่าง: 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 ฝั่งเซิร์ฟเวอร์เท่านั้น (หรือค่าเริ่มต้น) คำขอที่พยายามตั้งค่า TFE_ADDRESS ผ่านส่วนหัว HTTP หรือพารามิเตอร์คิวรีจะถูกปฏิเสธด้วย 403 ซึ่งป้องกันไม่ให้ไคลเอนต์เปลี่ยนเส้นทางคำขอและโทเค็น Authorization ไปยังเซิร์ฟเวอร์ที่เป็นอันตราย
• ห้ามส่งโทเค็นในพารามิเตอร์คิวรี - เซิร์ฟเวอร์จะปฏิเสธคำขอดังกล่าวด้วยข้อผิดพลาด 400
• ใช้ TLS (MCP_TLS_CERT_FILE/MCP_TLS_KEY_FILE) เสมอเมื่อปรับใช้แบบรวมศูนย์เพื่อปกป้องโทเค็นระหว่างการส่ง
• กำหนดค่า 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.1.0

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

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

พร็อกซีองค์กร / การตรวจสอบ TLS (Zscaler ฯลฯ)

หากคุณอยู่หลังพร็อกซีองค์กรที่ทำการตรวจสอบ 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.1.0

สำหรับการกำหนดค่าไคลเอนต์ MCP:

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

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

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

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. สร้าง branch คุณลักษณะของคุณ
3. ทำการเปลี่ยนแปลงของคุณ
4. เรียกใช้การทดสอบ
5. ส่ง pull request

ใบอนุญาต

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

ความปลอดภัย

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

การสนับสนุน

สำหรับรายงานข้อบกพร่องและคำขอคุณสมบัติ โปรดเปิด issue บน GitHub

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