What Terraform Is

Terraform is HashiCorp's tool for provisioning infrastructure across any cloud or service through one declarative language and a plugin system of providers. You write what you want in HCL, run terraform apply, and Terraform calls the underlying APIs to make reality match — recording everything it created in a state file so it knows what to change next time.

The whole system is three parts: the configuration you write, the providers that know how to talk to each platform's API, and the state that remembers what exists. Hold those three in your head and most of Terraform stops being mysterious. The rest of this course is, in a sense, those three parts examined one at a time.

The Terraform Model

A Terraform setup is configuration plus providers plus state. The configuration is your .tf files: the declarative description of resources. The providers are plugins Terraform downloads — aws, google, kubernetes — that translate a resource like aws_instance into the actual API calls. The state is a file mapping each resource in your config to the real object it created, so Terraform can compute a precise diff instead of recreating everything.

The minimal configuration below names a provider and declares one resource. Reading it top to bottom: require the AWS provider, configure it for a region, and declare that a VPC with this CIDR should exist. That is the entire shape of every Terraform file you will ever write — a provider and some resources — scaled up.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

Provider-Agnostic by Design

Terraform itself knows nothing about AWS. The engine understands resources, dependencies, and state; everything cloud-specific lives in a provider. That separation is the source of Terraform's reach: the same language and the same plan/apply workflow manage AWS, Google Cloud, Kubernetes, GitHub, Cloudflare, Datadog, and hundreds of other platforms, instead of a different tool for each.

The practical consequence is that what you learn here transfers. The AWS provider is the cloud-specific part of this course, but the language, the state model, modules, and the workflow are universal. Switch to Google Cloud and you change the provider and the resource names, not how you think.

The HashiCorp Ecosystem

Three things share the Terraform name and are worth keeping distinct. Terraform CLI is the open binary you run locally — the subject of this course. The Registry (registry.terraform.io) hosts providers and reusable modules with versioned documentation. HCP Terraform (formerly Terraform Cloud) is the paid managed service that runs Terraform for you with remote state, run approvals, and policy. You do not need the paid service to use Terraform; the CLI plus an S3 backend gets a team a long way.

The License Change and OpenTofu

In August 2023 HashiCorp relicensed Terraform from the open-source Mozilla Public License to the Business Source License, which restricts using Terraform to build a competing commercial product. In response, the community forked the last MPL-licensed version as OpenTofu, now governed by the Linux Foundation and fully open-source. For ordinary use — running Terraform to manage your own infrastructure — the BSL changes nothing; the restriction targets vendors building rival products.

Terraform and OpenTofu remain almost entirely compatible: the HCL language, the providers, and the CLI commands are the same, and configurations are portable between them today. They have begun to diverge on newer features — OpenTofu shipped client-side state encryption, Terraform shipped Stacks (and ephemeral resources first, since adopted by OpenTofu) — and the course flags those divergences where they matter. Pick one at the organization level based on your license policy, then standardize so everyone runs the same binary.

What This Course Uses

This course teaches HashiCorp Terraform 1.x and uses the AWS provider for every example. Where OpenTofu behaves differently, you will see a note. Because providers evolve quickly, the Registry documentation for your pinned provider version is always the final word on which arguments a resource accepts — treat it as the source of truth over any tutorial, including this one.