Installer Terraform et premiers pas

Installer Terraform

Terraform est distribué sous forme d'un unique binaire à télécharger. Plusieurs méthodes selon ton OS :

Linux (Debian/Ubuntu)

La méthode officielle HashiCorp via apt :

# Ajouter le dépôt HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor \
  -o /usr/share/keyrings/hashicorp-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
  https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
  sudo tee /etc/apt/sources.list.d/hashicorp.list

# Installer Terraform
sudo apt update && sudo apt install terraform

Tu peux aussi utiliser tfenv, un gestionnaire de versions Terraform (recommandé si tu travailles sur plusieurs projets) :

# Installer tfenv
git clone https://github.com/tfutils/tfenv.git ~/.tfenv
echo 'export PATH="$HOME/.tfenv/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# Installer et utiliser une version précise
tfenv install 1.7.0
tfenv use 1.7.0

macOS (Homebrew)

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

Windows (Chocolatey ou binaire)

# Avec Chocolatey (PowerShell admin)
choco install terraform

# Ou télécharge le .zip sur releases.hashicorp.com,
# extrait terraform.exe et place-le dans un dossier de ton PATH

Vérifier l'installation

Dans n'importe quel terminal, tape :

terraform version

Tu dois obtenir quelque chose comme :

Terraform v1.7.0
on linux_amd64

Structure d'un projet Terraform

Un projet Terraform est un simple dossier contenant des fichiers .tf. Convention standard :

mon-projet/
├── main.tf          # ressources principales
├── variables.tf     # déclaration des variables
├── outputs.tf       # valeurs à exporter après apply
├── terraform.tfvars # valeurs concrètes des variables
└── .terraform/      # dossier auto-généré (plugins, cache)

Tu peux tout mettre dans un seul fichier main.tf pour commencer — la séparation est une convention de lisibilité, pas une obligation.

Le bloc terraform {} et required_providers

Tout projet commence par un bloc terraform qui déclare les providers nécessaires :

# main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  required_version = ">= 1.5.0"
}

Ce bloc dit à Terraform :

• Quel provider utiliser (ici AWS) et où le télécharger (hashicorp/aws = le registry officiel)
• Quelle version du provider est compatible (~> 5.0 = 5.x, patch autorisé)
• Quelle version minimale de Terraform est requise

Configurer le provider AWS

Le provider AWS a besoin de credentials pour s'authentifier. La méthode recommandée : les variables d'environnement.

# Dans ton terminal, avant de lancer Terraform
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
export AWS_DEFAULT_REGION="eu-west-3"

Puis dans main.tf, le bloc provider est minimal — les credentials sont lus automatiquement depuis l'environnement :

provider "aws" {
  region = "eu-west-3"
}

Première ressource : le provider local

Pour tester Terraform sans compte cloud, le provider local permet de créer des fichiers sur ta machine. C'est l'équivalent du "Hello World" Terraform.

# main.tf complet avec le provider local
terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.4"
    }
  }
}

resource "local_file" "bonjour" {
  filename = "./bonjour.txt"
  content  = "Bonjour depuis Terraform !"
}

Anatomie d'une ressource :

• resource — mot-clé qui déclare une ressource
• "local_file" — le type de ressource (défini par le provider)
• "bonjour" — le nom local que tu choisis (sert à référencer la ressource)
• Le bloc { } contient les arguments de configuration

Le workflow Terraform

Terraform suit toujours le même cycle en quatre commandes :

1. terraform init

Initialise le projet : télécharge les providers déclarés dans required_providers, crée le dossier .terraform/.

terraform init

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/local versions matching "~> 2.4"...
- Installing hashicorp/local v2.4.1...
Terraform has been successfully initialized!

2. terraform plan

Compare l'état actuel de l'infrastructure avec ce que décrivent tes fichiers .tf. Affiche un récapitulatif des changements sans rien créer.

terraform plan

Terraform will perform the following actions:

  # local_file.bonjour will be created
  + resource "local_file" "bonjour" {
      + content  = "Bonjour depuis Terraform !"
      + filename = "./bonjour.txt"
    }

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

3. terraform apply

Applique le plan : crée, modifie ou supprime les ressources. Terraform demande une confirmation (yes) avant d'agir.

terraform apply

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Après l'apply, le fichier bonjour.txt apparaît dans ton dossier.

4. terraform destroy

Supprime toutes les ressources gérées par ce projet Terraform. Très utile pour éviter de payer des ressources cloud oubliées.

terraform destroy

Destroy complete! Resources: 1 destroyed.

Comprendre .terraform/ et terraform.tfstate

Deux éléments sont créés automatiquement par Terraform :

mon-projet/
├── main.tf
├── .terraform/            # binaires des providers (à gitignorer)
│   └── providers/
│       └── hashicorp/local/2.4.1/
├── terraform.tfstate       # état actuel de l'infra (sensible !)
└── terraform.tfstate.backup

• .terraform/ — contient les binaires des providers téléchargés. À ajouter dans .gitignore car très volumineux.
• terraform.tfstate — le fichier d'état : Terraform y note ce qu'il a créé. C'est sa "mémoire". Ne pas le modifier à la main. En équipe, il faut le stocker à distance (remote backend S3 ou Terraform Cloud).