Rondklikken op een cloudconsole is prima voor één server. Het mislukt als je dezelfde configuratie nodig hebt voor staging en productie, of als iemand vraagt ​​wie afgelopen maart een firewallregel heeft gewijzigd. Deze Terraform-tutorial voor beginners laat je een betere manier zien: beschrijf je infrastructuur in code en laat een tool deze werkelijkheid maken.

De meeste tutorials beginnen met een cloudaccount, wat het factureringsrisico met zich meebrengt voordat u iets heeft geleerd. We beginnen met de provider local van Terraform, die alleen maar bestanden op uw computer aanmaakt, zodat fouten niets kosten. Deze voorbeelden en de voorbeelduitvoer zijn standaardillustraties die we niet voor dit artikel hebben uitgevoerd, en de exacte bewoording verschilt per versie.

Wat is Terraform?

Terraform is een infrastructuur als code (IaC)-tool van HashiCorp. Je schrijft configuratiebestanden in HCL, de HashiCorp Configuration Language, waarin je het gewenste eindresultaat beschrijft. Terraform bedenkt vervolgens wat er moet worden gemaakt, gewijzigd of verwijderd om daar te komen.

Het communiceert met platforms via plug-ins die providers worden genoemd. Er zijn providers voor AWS, Azure, Google Cloud, Kubernetes, GitHub, Cloudflare en vele anderen, zodat u één workflow voor allemaal kunt gebruiken.

Eén ding om te weten: in 2023 heeft HashiCorp Terraform overgezet naar de Business Source-licentie. De community heeft vervolgens OpenTofu gemaakt, een open-source fork die zeer vergelijkbare opdrachten en configuraties gebruikt. Wat je hier leert, geldt grotendeels voor beide.

Waarom infrastructuur als code?

Terraform is ook declaratief. U zegt “er moeten drie servers zijn”, niet “driemaal een server maken”. Als er al twee bestaan, wordt er één toegevoegd. Een script dat simpelweg zijn stappen herhaalt, zou er uiteindelijk nog drie kunnen creëren.

Installeer Terraform

Installeer het met behulp van de officiële HashiCorp-instructies voor uw besturingssysteem en bevestig vervolgens dat het werkt:

terraform -version

Maak een lege map voor het project. Terraform leest elk .tf bestand in de huidige map, dus één map is gelijk aan één configuratie.

Uw eerste configuratie

Maak een bestand met de naam main.tf:

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}

resource "local_file" "greeting" {
  filename = "${path.module}/hello.txt"
  content  = "Hello from Terraform\n"
}

Kijk naar blok resource, aangezien bijna alles wat je schrijft deze vorm volgt. local_file is het resourcetype en greeting is uw eigen naam ervoor binnen de configuratie. Samen vormen ze het adres: local_file.greeting. De argumenten binnenin beschrijven wat u wilt.

De workflow: initiëren, plannen, toepassen

terraform init

Hiermee wordt de map voorbereid en worden de providers gedownload waar u om hebt gevraagd. Voer het één keer uit aan het begin en opnieuw wanneer u een provider of module toevoegt. Er wordt ook een .terraform.lock.hcl-bestand gemaakt, waarin de exacte providerversies worden vastgelegd. Commit dat bestand naar Git.

terraform init

terraform plan

Dit vergelijkt uw code met wat er bestaat en toont de geplande wijzigingen, zonder iets aan te raken:

terraform plan

# local_file.greeting will be created
+ resource "local_file" "greeting" {
    + content  = "Hello from Terraform\n"
    + filename = "./hello.txt"
  }

Plan: 1 to add, 0 to change, 0 to destroy.

Leer de symbolen, want je leest veel plannen:

terraform van toepassing

Deze toont het plan opnieuw, vraagt om bevestiging en voert de wijzigingen door:

terraform apply

Type yes en hello.txt verschijnen. Voer nu terraform plan opnieuw uit. Het zou geen wijzigingen moeten rapporteren, omdat de werkelijkheid al overeenkomt met uw code. Deze eigenschap, waarbij het herhaaldelijk uitvoeren ervan geen verdere verandering teweegbrengt, wordt idempotence genoemd.

Veranderen en vernietigen

Bewerk de regel content en voer terraform plan uit. Terraform ziet het verschil en stelt een verandering voor. Voor deze bron vervangt het het bestand. Besteed aandacht aan vervangingen op de echte infrastructuur, aangezien het opnieuw aanmaken van een database kan betekenen dat gegevens verloren gaan.

Verwijder vervolgens hello.txt handmatig en plan opnieuw. Terraform merkt dat het ontbreekt en biedt aan om het opnieuw te maken. Een verschil tussen uw code en de werkelijkheid wordt drift genoemd, en het detecteren ervan is een van de belangrijkste voordelen van de tool.

Om alles wat deze configuratie beheert te verwijderen, voert u het volgende uit:

terraform destroy

Variabelen en uitgangen

Hardgecodeerde waarden zorgen ervoor dat u code niet opnieuw kunt gebruiken. Invoervariabelen maken een configuratie flexibel, en uitvoer rapporteert nuttige waarden terug:

# variables.tf
variable "environment" {
  type        = string
  description = "Deployment environment"
  default     = "dev"

  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "Use dev, staging or prod."
  }
}

# main.tf
resource "local_file" "config" {
  filename = "${path.module}/${var.environment}.txt"
  content  = "environment=${var.environment}\n"
}

# outputs.tf
output "config_path" {
  value = local_file.config.filename
}

Stel waarden in op de opdrachtregel, of bewaar ze in een bestand met de naam terraform.tfvars, dat automatisch wordt geladen:

terraform apply -var="environment=staging"

Het gebruik van local_file.config.filename in de uitvoer geeft ook aan hoe bronnen naar elkaar verwijzen. Terraform leest deze verwijzingen om de juiste volgorde te bepalen waarin dingen moeten worden gemaakt.

Terraforme staat

Na aanmelding vindt u een bestand met de naam terraform.tfstate. Dit is Terraform’s verslag van wat het beheert, waarbij uw code wordt toegewezen aan echte objecten. Zonder dit zou Terraform niet weten dat local_file.greeting dat specifieke bestand is.

Drie regels zijn hier van belang:

1. Geef nooit een status door aan Git. Het kan wachtwoorden en andere geheimen in platte tekst bevatten.
2. Bewerk het niet met de hand. Gebruik opdrachten zoals terraform state list en terraform state mv.
3. Gebruik een externe backend voor teamprojecten. Een gedeelde backend slaat de status centraal op en vergrendelt deze, zodat twee mensen niet tegelijk een aanvraag kunnen indienen.

Hier is een typische backend die Amazon S3 gebruikt, met een bucket die je vooraf maakt:

terraform {
  backend "s3" {
    bucket       = "my-company-terraform-state"
    key          = "shop/prod/terraform.tfstate"
    region       = "ap-south-1"
    encrypt      = true
    use_lockfile = true
  }
}

Een echte cloudbron

De workflow verandert niet als u naar een cloud verhuist. Hier is een S3-bucket op AWS. Controleer eerst de prijzen en vernietig alles wat je maakt tijdens het oefenen:

provider "aws" {
  region = "ap-south-1"
}

resource "aws_s3_bucket" "reports" {
  bucket = "my-unique-reports-bucket-2026"

  tags = {
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

Terraform haalt inloggegevens op van uw AWS CLI-installatie- of omgevingsvariabelen. Schrijf nooit toegangssleutels in een .tf-bestand.

Modules

Een module is eenvoudigweg een map met Terraform-bestanden die u met verschillende invoer kunt oproepen. Het werkt ongeveer als een functie, waarbij u een patroon één keer kunt definiëren en opnieuw kunt gebruiken:

project/
  main.tf
  modules/
    reports_bucket/
      main.tf
      variables.tf
      outputs.tf

module "staging_reports" {
  source      = "./modules/reports_bucket"
  environment = "staging"
}

module "prod_reports" {
  source      = "./modules/reports_bucket"
  environment = "prod"
}

Het openbare Terraform Registry heeft ook kant-en-klare modules, maar lees deze voordat u erop vertrouwt en pin de versie. Bouw modules niet te vroeg. Wacht tot je een patroon minimaal twee keer hebt herhaald.

Een veilige teamworkflow

1. Maak een vertakking en wijzig de .tf bestanden. Bekijk onze Git-tutorial voor beginners als je een opfriscursus nodig hebt.
2. Voer terraform fmt en terraform validate uit.
3. Open een pull-aanvraag, met de uitvoer van terraform plan ter beoordeling bijgevoegd.
4. Pas na goedkeuring het opgeslagen plan toe vanaf één gecontroleerde plek, idealiter een pijpleiding.

Als u het plan opslaat, weet u zeker dat u precies toepast wat is beoordeeld:

terraform plan -out=tfplan
terraform apply tfplan

Dit past natuurlijk in CI/CD en GitHub-acties. Terraform levert meestal het cluster, en tools als Kubernetes voeren er vervolgens applicaties op uit.

Veel voorkomende fouten

• Aanvragen zonder het plan te lezen. Eén -/+ in een database kan een erg dure verrassing zijn.
• Status bijhouden op één laptop. Als u die laptop kwijtraakt, verliest Terraform uw infrastructuur uit het oog.
• Handmatige wijzigingen aan de console aanbrengen. Ze veroorzaken drift en de volgende toepassing kan deze ongedaan maken.
• Niet-vastgezette versies gebruiken. Pin provider- en moduleversies vast, zodat upgrades expres plaatsvinden.
• Het gebruik van één grote configuratie. Door op te splitsen per omgeving of systeem wordt de schade van fouten beperkt.

Tot slot

Je hebt nu de ideeën achter bijna al het Terraform-werk gezien: grondstoffen declareren, het plan herzien, het toepassen en de staat beschermen. Oefen met de local provider totdat de workflow natuurlijk aanvoelt en beheer vervolgens een kleine echte bron in een gratis account. Schakel de externe status en modules in zodra er meer dan één persoon of meer dan één omgeving bij betrokken is.

Veelgestelde vragen

Blijf leren