Fare clic su una console cloud va bene per un server. Si interrompe quando è necessaria la stessa configurazione in fase di staging e produzione o quando qualcuno chiede chi ha modificato una regola del firewall lo scorso marzo. Questo tutorial su Terraform per principianti ti mostra un modo migliore: descrivi la tua infrastruttura in codice e lascia che uno strumento la renda reale.

La maggior parte dei tutorial inizia con un account cloud, che aggiunge rischi di fatturazione prima che tu abbia imparato qualcosa. Iniziamo con il provider Terraform local, che crea semplicemente file sul tuo computer, quindi gli errori non costano nulla. Questi esempi e l’output di esempio sono illustrazioni standard che non abbiamo eseguito per questo articolo e il testo esatto varia in base alla versione.

Cos’è Terraform?

Terraform è uno strumento IaC (infrastruttura come codice) di HashiCorp. Scrivi i file di configurazione in HCL, il linguaggio di configurazione di HashiCorp, descrivendo il risultato finale desiderato. Terraform quindi capisce cosa creare, modificare o eliminare per arrivarci.

Comunica con le piattaforme tramite plugin chiamati provider. Esistono provider per AWS, Azure, Google Cloud, Kubernetes, GitHub, Cloudflare e molti altri, quindi puoi utilizzare un flusso di lavoro comune a tutti.

Una cosa da sapere: nel 2023, HashiCorp ha trasferito Terraform alla licenza Business Source. La comunità ha quindi creato OpenTofu, un fork open source che utilizza comandi e configurazioni molto simili. Ciò che impari qui si applica in gran parte a entrambi.

Perché l’infrastruttura come codice?

Terraform è anche dichiarativo. Dichiari “dovrebbero esserci tre server”, non “crea un server, tre volte”. Se ne esistono già due, ne aggiunge uno. Uno script che si limita a ripetere i suoi passaggi potrebbe finire per crearne altri tre.

Installa Terraform

Installalo utilizzando le istruzioni ufficiali di HashiCorp per il tuo sistema operativo, quindi verifica che funzioni:

terraform -version

Crea una cartella vuota per il progetto. Terraform legge ogni .tf file nella cartella corrente, quindi una cartella equivale a una configurazione.

La tua prima configurazione

Crea un file chiamato 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"
}

Osserva il blocco resource, poiché quasi tutto ciò che scrivi segue questa forma. local_file è il tipo di risorsa e greeting è il tuo nome all’interno della configurazione. Insieme formano il suo indirizzo: local_file.greeting. Gli argomenti all’interno descrivono ciò che desideri.

Il flusso di lavoro: init, pianificazione, applicazione

terraformare init

Questo prepara la cartella e scarica i provider richiesti. Eseguilo una volta all’inizio e di nuovo ogni volta che aggiungi un provider o un modulo. Crea inoltre un file .terraform.lock.hcl, che registra le versioni esatte del provider. Invia quel file a Git.

terraform init

piano di terraformazione

Questo confronta il tuo codice con quello esistente e mostra le modifiche pianificate, senza toccare nulla:

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.

Impara i simboli, perché leggerai molti piani:

applicare terraformare

Questo mostra nuovamente il piano, chiede conferma e apporta le modifiche:

terraform apply

Vengono visualizzati il tipo yes e hello.txt. Ora esegui di nuovo terraform plan. Non dovrebbe riportare alcuna modifica, perché la realtà corrisponde già al tuo codice. Questa proprietà, per cui l’esecuzione ripetuta non provoca ulteriori modifiche, è chiamata idempotenza.

Cambiare e distruggere

Modifica la riga content ed esegui terraform plan. Terraform individua la differenza e propone un cambiamento. Per questa risorsa, sostituisce il file. Prestare attenzione alle sostituzioni su infrastrutture reali, poiché ricreare un database potrebbe significare la perdita di dati.

Successivamente, elimina hello.txt manualmente e pianifica di nuovo. Terraform nota che manca e si offre di ricrearlo. Una differenza tra il tuo codice e la realtà si chiama deriva e rilevarla è uno dei principali vantaggi dello strumento.

Per rimuovere tutto ciò che gestisce questa configurazione, esegui:

terraform destroy

Variabili e output

I valori codificati impediscono di riutilizzare il codice. Le variabili di input rendono flessibile la configurazione e gli output riportano valori utili:

# 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
}

Imposta i valori sulla riga di comando o conservali in un file chiamato terraform.tfvars, che viene caricato automaticamente:

terraform apply -var="environment=staging"

L’utilizzo di local_file.config.filename nell’output è anche il modo in cui le risorse si riferiscono tra loro. Terraform legge questi riferimenti per individuare l’ordine corretto in cui creare le cose.

Stato di terraformazione

Dopo l’applicazione, troverai un file chiamato terraform.tfstate. Questo è il registro di Terraform di ciò che gestisce, mappando il tuo codice su oggetti reali. Senza di esso, Terraform non saprebbe che local_file.greeting è quel file specifico.

Qui contano tre regole:

1. Non impegnare mai lo stato in Git. Può contenere password e altri segreti in testo semplice.
2. Non modificarlo manualmente. Utilizza comandi come terraform state list e terraform state mv.
3. Utilizza un backend remoto per progetti di gruppo. Un backend condiviso memorizza lo stato a livello centrale e lo blocca, in modo che due persone non possano presentare domanda contemporaneamente.

Ecco un tipico backend che utilizza Amazon S3, con un bucket creato in anticipo:

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

Una vera risorsa cloud

Il flusso di lavoro non cambia quando si passa al cloud. Ecco un bucket S3 su AWS. Controlla prima i prezzi e distruggi tutto ciò che crei mentre fai pratica:

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

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

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

Terraform ottiene le credenziali dalla configurazione dell’AWS CLI o dalle variabili di ambiente. Non scrivere mai le chiavi di accesso in un file .tf.

Moduli

Un modulo è semplicemente una cartella di file Terraform che puoi chiamare con input diversi. Funziona in modo molto simile a una funzione, permettendoti di definire un modello una volta e riutilizzarlo:

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"
}

Anche il registro pubblico Terraform dispone di moduli già pronti, ma leggili prima di fare affidamento su di essi e aggiungi la versione. Non creare moduli troppo presto. Attendi finché non avrai ripetuto uno schema almeno due volte.

Un flusso di lavoro di squadra sicuro

1. Crea un ramo e modifica i file .tf. Consulta il nostro tutorial su Git per principianti se hai bisogno di un ripasso.
2. Esegui terraform fmt e terraform validate.
3. Aprire una richiesta pull, con l’output di terraform plan allegato per la revisione.
4. Dopo l’approvazione, applica il piano salvato da un luogo controllato, idealmente un oleodotto.

Salvare il piano ti assicura di applicare esattamente ciò che è stato rivisto:

terraform plan -out=tfplan
terraform apply tfplan

Questo si adatta naturalmente a CI/CD e Azioni GitHub. Terraform solitamente esegue il provisioning del cluster e strumenti come Kubernetes eseguono quindi le applicazioni su di esso.

Errori comuni

• Fare domanda senza leggere il piano. Uno -/+ su un database può essere una sorpresa molto costosa.
• Mantenere lo stato su un laptop. Se perdi quel laptop, Terraform perderà traccia della tua infrastruttura.
• Apportare modifiche manuali alla console. Causano deviazioni e l’applicazione successiva potrebbe annullarle.
• Utilizzo di versioni non bloccate. Blocca le versioni del provider e del modulo in modo che gli aggiornamenti avvengano di proposito.
• Utilizzo di un’unica configurazione enorme. La suddivisione per ambiente o sistema limita i danni derivanti da eventuali errori.

Considerazioni finali

Ora hai visto le idee alla base di quasi tutto il lavoro di Terraform: dichiarare le risorse, rivedere il piano, applicarlo e proteggere lo stato. Fai pratica con il fornitore local fino a quando il flusso di lavoro non sembra naturale, quindi gestisci una piccola risorsa reale in un account di livello gratuito. Portare in stato remoto e moduli quando è coinvolta più di una persona o più di un ambiente.

Domande frequenti

Continua a imparare