What Terraform Is

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

It is worth being precise about what Terraform is and is not, because the word gets stretched. Terraform is the engine and the language. It is not the Google provider, not the managed services that run it for you, and not tied to any one cloud. Those distinctions are the whole of this topic, and getting them straight now saves confusion in every chapter that follows.

The Terraform Model: Three Parts

The entire system is three parts. Configuration is the HCL you write — the resources, variables, and outputs that describe desired state. Providers are plugins that translate that configuration into real API calls; the google provider knows how to turn a google_storage_bucket block into a Cloud Storage API request. State is the record of what Terraform created, the map between your configuration and the real resources it stands behind.

Everything in this course is one of those three things or the workflow that connects them. When a plan surprises you, the answer is almost always in how configuration, providers, and state relate. Hold the three-part model and the rest has a place to hang.

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"   # the provider plugin
      version = "~> 7.0"
    }
  }
}

provider "google" {
  project = "hatch-pipeline-dev"      # configuration the provider reads
  region  = "us-central1"
}

resource "google_storage_bucket" "raw" {   # tracked in state once applied
  name     = "hatch-events-raw"
  location = "US"
}

That snippet names all three: the required_providers block declares the provider, the provider block configures it, and the resource becomes a tracked entry in state after the first apply. The next chapters take each part apart in turn.

Provider-Agnostic by Design

Terraform's engine knows nothing about Google Cloud. It knows how to read HCL, build a graph of resources, and walk that graph calling whatever provider each resource names. The google provider is one of hundreds — AWS, Azure, Kubernetes, GitHub, Cloudflare, Datadog — and they all plug into the same engine and the same workflow.

The practical consequence is that the language, the state model, and the plan/apply loop you learn here carry to every other provider unchanged. What changes between clouds is the provider — the resource names and their arguments. That is why this course separates the universal Terraform skill from the GCP-specific surface, and spends real time on the parts that are genuinely particular to Google Cloud.

The HashiCorp Ecosystem and Infrastructure Manager

Around the open tool sit a few related things people conflate with it. The Registry at registry.terraform.io hosts providers and shared modules. HCP Terraform is HashiCorp's managed SaaS that runs Terraform for you, stores state, and adds policy and run pipelines. And on Google Cloud specifically, Infrastructure Manager is Google's own managed service that runs the exact same Terraform on your behalf, hosting the state and tying into GCP IAM.

None of these is a different tool or language. They run the same HCL the local CLI runs. Whether you execute Terraform from your laptop, from a CI pipeline, from HCP Terraform, or from Infrastructure Manager is an operational choice covered later — the configuration is identical across all of them.

The License Change and OpenTofu

In 2023 HashiCorp relicensed Terraform from the open MPL 2.0 to the Business Source License, which restricts using Terraform's source to build a competing product but leaves normal use untouched. The community forked the last MPL version as OpenTofu, now stewarded by the Linux Foundation. OpenTofu runs the same google provider and is roughly ninety-nine percent compatible; the two diverge only on newer features — OpenTofu shipped client-side state encryption early, Terraform shipped Stacks — and on the license itself.

This course teaches HashiCorp Terraform 1.x and calls out OpenTofu only where behavior genuinely differs. Choose between them at the organization level based on license policy, then standardize so everyone runs the same binary. Everything you learn about the language, state, and workflow applies to both.