Infrastructure as Code has become the backbone of modern cloud operations and Terraform remains a central tool for defining and provisioning resources declaratively. The term Terraform server covers two related but distinct realities today: the classic Terraform workflow used to deploy and manage servers in cloud environments, and the newer Terraform MCP Server that exposes Terraform Registry APIs and workspace operations to Model Context Protocol clients. Both are built around HashiCorp's Terraform, an industry-standard Infrastructure as Code tool used to build, modify, and manage infrastructure safely and efficiently.
Understanding how Terraform works as an IaC engine and how the Terraform MCP Server extends that capability to automation and AI-assisted workflows provides a complete picture of what a Terraform server entails in practice.
Terraform as Infrastructure as Code
Terraform, developed by HashiCorp, automates infrastructure provisioning instead of manual console configuration. It enables version control, collaboration, and repeatable deployments. It reduces human errors while improving scalability and consistency.
Infrastructure as Code is the practice of managing IT infrastructure using configuration files rather than manual, interactive configuration tools. The core principles that define Terraform's approach are declarative and version controlled. You tell Terraform what you want, for example "I want 5 servers", and Terraform figures out how to create them. You can track the history of your infrastructure changes just like application code.
Key features that shape Terraform usage:
- Cloud Agnostic: Unlike CloudFormation which is AWS only or ARM Templates which are Azure only, Terraform works with any cloud provider including AWS, Google Cloud, Azure, Kubernetes, Alibaba, and others.
- Immutable Infrastructure: Terraform typically replaces servers rather than changing them, reducing configuration drift where servers become inconsistent over time.
- State Management: Terraform keeps track of your real-world resources in a state file, acting as the source of truth.
- Modular: You can package code into Modules to reuse common patterns, for example a standard Web Server module used by all teams.
Terraform uses a declarative configuration language to define infrastructure and manage resources in a way that aligns with these principles.
Deploying Your First Server with Terraform
Deploying a first server with Terraform is a practical introduction to IaC. The guide will walk you through the steps to deploy your first server using Terraform. By the end of this article, you will have a basic understanding of how Terraform works and a running server.
Prerequisites before you begin ensure the following are in place:
- Terraform Installed: Download and install Terraform from Terraform's official website.
- Cloud Provider Account: Create an account with your preferred cloud provider, for example AWS.
- Access Credentials: Set up access credentials for your cloud provider.
- Code Editor: Use a code editor like Visual Studio Code.
Step 1: Initialize Your Terraform Project
Create a project directory:
mkdir terraform-server-deploy && cd terraform-server-deploy
Write Your First Configuration File:
Create a file named main.tf and open it in your editor.
Infrastructure as Code is revolutionizing the way we manage and provision cloud resources. Among the various tools available, Terraform stands out for its simplicity, flexibility, and wide adoption across cloud platforms. If you are new to Terraform, deploying your first server might seem daunting, but it does not have to be. In this guide, we will walk you through the process step-by-step, ensuring you get up and running with confidence.
Let's start by creating a new directory for our Terraform project. Inside this directory, create a file named main.tf. This will be the main configuration file where we will define our server.
provider "aws" {
region = "us-east-1"
}
resource "aws_instance" "example" {
ami = "ami-0e86e20dae9224db8" #Ubuntu 20.04 LTS
instance_type = "t2.micro"
tags = {
Name = "MyFirstTerraformServer"
}
}
The code defines a provider and a resource. The provider block specifies AWS as the cloud provider and sets the region. The resource block defines an EC2 instance resource using an Amazon Machine Image and setting the instance type to t2.micro, which is a low-cost option suitable for testing.
The description of the example notes that provider "aws" specifies that we are using AWS as our cloud provider and sets the region to us-west-2. The resource "aws_instance" "example" defines an EC2 instance resource. We are using an Amazon Machine Image and setting the instance type to t2.micro.
Before we can deploy our server, we need to initialize Terraform in our project directory. Whether you are deploying a single server or managing hundreds of resources across multiple cloud providers, Terraform has you covered.
This workflow illustrates the beginner path to Terraform server deployment: create a directory, author main.tf with provider and resource blocks, and initialize the project.
Terraform MCP Server Architecture
The Terraform MCP Server is a Model Context Protocol server that provides seamless integration with Terraform Registry APIs, enabling advanced automation and interaction capabilities for Infrastructure as Code development.
The server is designed to bridge Terraform's ecosystem with MCP clients and large language models.
Transport and Registry Integration
Dual Transport Support: Both Stdio and StreamableHTTP transports with configurable endpoints.
Terraform Registry Integration: Direct integration with public Terraform Registry APIs for providers, modules, and policies.
HCP Terraform and Terraform Enterprise Support
HCP Terraform & Terraform Enterprise Support: Full workspace management, organization/project listing, and private registry access.
Workspace Operations: Create, update, delete workspaces with support for variables, tags, and run management.
Observability
OTel metrics for monitoring tool usage: Integration with open telemetry meters to track tool-call volume, latency and failures in Streamable HTTP mode. Also exposes default http server metrics when this feature is enabled.
Security and Legal Considerations
Security Note: Depending on the query, the MCP server may expose certain Terraform data to the MCP client and LLM. Do not use the MCP server with untrusted MCP clients or LLMs.
Legal Note: Your use of a third party MCP Client/LLM is subject solely to the terms of use for such MCP/LLM, and IBM is not responsible for the performance of such third party tools.
The Terraform MCP Server enables sharing of configuration with others through standardized MCP configuration.
MCP Configuration Examples
Version configuration differs between 0.3.0+ and 0.2.3 or lower.
| Configuration Item | Version 0.3.0+ or greater | Version 0.2.3 or lower |
|---|---|---|
| Server command | docker run -i --rm -e TFETOKEN=${input:tfetoken} -e TFEADDRESS=${input:tfeaddress} hashicorp/terraform-mcp-server:1.0.0 | docker run -i --rm hashicorp/terraform-mcp-server:0.2.3 |
| Inputs | tfetoken promptString password true, tfeaddress promptString password false | none |
Add this to your Cursor config ~/.cursor/mcp.json or via Settings → Cursor Settings → MCP:
| Cursor Config Version | Server Definition |
|---|---|
| 0.3.0+ or greater | mcpServers.terraform.command = docker run -i --rm -e TFEADDRESS=< |
| 0.2.3 or lower | servers.terraform.command = docker run -i --rm hashicorp/terraform-mcp-server:0.2.3 |
The configuration supports environment variables for Terraform Enterprise address and token when using version 0.3.0 or greater.
Terraform Server Concepts in Practice
The combination of classic Terraform server deployment and the Terraform MCP Server creates two complementary layers.
The classic layer is the declarative IaC engine. Terraform works with any cloud provider. It keeps track of real-world resources in a state file as source of truth. It supports modular code reuse. It automates provisioning instead of manual console configuration.
The MCP layer is the integration layer. It provides seamless integration with Terraform Registry APIs. It supports dual transport with Stdio and StreamableHTTP. It offers HCP Terraform and Terraform Enterprise support with workspace management, organization and project listing, and private registry access. It provides workspace operations for create, update, delete with variables, tags, and run management. It integrates open telemetry meters to track tool-call volume, latency and failures.
For a beginner deploying a first server, the workflow starts with installing Terraform, creating a cloud provider account, setting access credentials, and using a code editor. The project directory is created and main.tf is written with provider and resource blocks. Initialization follows.
For an advanced workflow using the Terraform MCP Server, the configuration is added to an MCP client such as Cursor. Environment variables for TFETOKEN and TFEADDRESS are supplied for version 0.3.0+. The server then exposes Terraform Registry data, workspace operations, and metrics to the client.
Conclusion
Terraform server as a concept spans both the foundational IaC engine that provisions cloud servers declaratively and the emerging Model Context Protocol server that exposes Terraform's registry and workspace capabilities to automation and AI tooling. Terraform developed by HashiCorp remains an industry-standard Infrastructure as Code tool used to build, modify, and manage infrastructure safely and efficiently. It automates infrastructure provisioning instead of manual console configuration, enables version control and repeatable deployments, and reduces human errors while improving scalability and consistency.
The declarative nature of Infrastructure as Code means you tell Terraform what you want and Terraform figures out how to create it. Version control allows tracking history of infrastructure changes just like application code. Cloud agnostic support, immutable infrastructure practices, state management, and modular design are the key features that make Terraform durable across environments.
Deploying a first server begins with prerequisites of Terraform installation, cloud provider account, access credentials, and a code editor. The project directory is created and main.tf is authored with provider and resource blocks. Initialization prepares the project for deployment. The example AWS configuration shows provider region setting and an awsinstance resource with AMI ami-0e86e20dae9224db8 for Ubuntu 20.04 LTS, instancetype t2.micro, and tags naming the server.
The Terraform MCP Server extends this foundation. It provides seamless integration with Terraform Registry APIs for providers, modules, and policies. It supports dual transport with Stdio and StreamableHTTP with configurable endpoints. It offers full HCP Terraform and Terraform Enterprise support with workspace management, organization and project listing, and private registry access. Workspace operations include create, update, delete with variables, tags, and run management. Open telemetry integration tracks tool-call volume, latency and failures in Streamable HTTP mode and exposes default http server metrics.
Security considerations are explicit: the MCP server may expose certain Terraform data to the MCP client and LLM, so it should not be used with untrusted clients. Legal responsibility for third party MCP Client/LLM use remains with the terms of use for those tools.
Together, the classic Terraform server deployment workflow and the Terraform MCP Server integration represent the current state of Terraform server usage: declarative provisioning for reliable infrastructure and protocol-based automation for scalable IaC development.