Installer et Configurer Terraform sur Linux, macOS et Windows

Vous avez découvert les concepts fondamentaux de Terraform dans notre article d'introduction et vous êtes convaincu de ses avantages pour gérer votre infrastructure ? Excellent ! Il est maintenant temps de passer à la pratique. Dans ce guide complet, nous allons voir comment installer Terraform sur les trois systèmes d'exploitation majeurs — Linux, macOS et Windows — puis configurer votre environnement de travail pour être immédiatement opérationnel. Suivez chaque étape et vous serez prêt à déployer votre première infrastructure en un rien de temps.

Processus d'installation en un coup d'oeil

Prérequis avant l'installation

Avant de commencer l'installation de Terraform, assurez-vous d'avoir les éléments suivants :

• Un terminal : Terminal ou iTerm2 sur macOS, un terminal Linux (bash/zsh), ou PowerShell/Windows Terminal sur Windows.
• Un accès administrateur : certaines méthodes d'installation nécessitent des privilèges élevés (sudo sur Linux/macOS, administrateur sur Windows).
• Un compte cloud (optionnel mais recommandé) : pour tester Terraform en conditions réelles, un compte AWS, Azure ou GCP avec le free tier sera utile.
• Git (recommandé) : pour versionner vos fichiers de configuration Terraform.
• Un éditeur de code : Visual Studio Code avec l'extension HashiCorp Terraform est fortement recommandé pour la coloration syntaxique, l'autocomplétion et le linting.

Installer Terraform sur Linux

Il existe plusieurs méthodes pour installer Terraform sur Linux. Nous allons couvrir les deux plus courantes : via le gestionnaire de paquets et via le binaire.

Méthode 1 : Installation via apt (Ubuntu/Debian)

HashiCorp maintient un dépôt officiel pour les distributions basées sur Debian et Ubuntu. C'est la méthode recommandée car elle facilite les mises à jour futures.

# Mettre à jour les paquets et installer les dépendances
sudo apt-get update && sudo apt-get install -y gnupg software-properties-common

# Ajouter la clé GPG de HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | \
  gpg --dearmor | \
  sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg > /dev/null

# Vérifier l'empreinte de la clé
gpg --no-default-keyring \
  --keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \
  --fingerprint

# Ajouter le dépôt officiel HashiCorp
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-get update && sudo apt-get install terraform

Méthode 2 : Installation via yum/dnf (CentOS/RHEL/Fedora)

Pour les distributions basées sur Red Hat, utilisez le dépôt yum de HashiCorp :

# Installer yum-utils
sudo yum install -y yum-utils

# Ajouter le dépôt HashiCorp
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo

# Installer Terraform
sudo yum -y install terraform

Pour Fedora avec dnf :

# Ajouter le dépôt HashiCorp
sudo dnf config-manager --add-repo https://rpm.releases.hashicorp.com/fedora/hashicorp.repo

# Installer Terraform
sudo dnf -y install terraform

Méthode 3 : Installation via le binaire (toutes distributions)

Cette méthode universelle fonctionne sur n'importe quelle distribution Linux. Vous téléchargez directement le binaire depuis le site officiel de HashiCorp.

# Définir la version souhaitée
TERRAFORM_VERSION="1.7.0"

# Télécharger l'archive
wget https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Décompresser l'archive
unzip terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Déplacer le binaire dans un répertoire du PATH
sudo mv terraform /usr/local/bin/

# Nettoyer
rm terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Vérifier l'installation
terraform version

Installer Terraform sur macOS

Sur macOS, l'installation est encore plus simple grâce à Homebrew, le gestionnaire de paquets le plus populaire.

Méthode 1 : Installation via Homebrew (recommandée)

Si vous n'avez pas encore Homebrew, installez-le d'abord :

# Installer Homebrew (si ce n'est pas déjà fait)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Ensuite, installez Terraform :

# Ajouter le tap HashiCorp
brew tap hashicorp/tap

# Installer Terraform
brew install hashicorp/tap/terraform

# Vérifier l'installation
terraform version

Pour mettre à jour Terraform ultérieurement :

# Mettre à jour Terraform
brew update
brew upgrade hashicorp/tap/terraform

Méthode 2 : Installation via le binaire

Comme sur Linux, vous pouvez télécharger le binaire directement :

# Télécharger (Apple Silicon / M1/M2/M3)
curl -O https://releases.hashicorp.com/terraform/1.7.0/terraform_1.7.0_darwin_arm64.zip

# Ou pour les Mac Intel
curl -O https://releases.hashicorp.com/terraform/1.7.0/terraform_1.7.0_darwin_amd64.zip

# Décompresser
unzip terraform_1.7.0_darwin_*.zip

# Déplacer dans le PATH
sudo mv terraform /usr/local/bin/

# Vérifier
terraform version

Installer Terraform sur Windows

Windows offre également plusieurs options pour installer Terraform. Nous recommandons l'utilisation de Chocolatey ou de winget pour simplifier la gestion des versions.

Méthode 1 : Installation via Chocolatey

Chocolatey est un gestionnaire de paquets pour Windows. Si vous ne l'avez pas encore, installez-le en ouvrant PowerShell en tant qu'administrateur :

# Installer Chocolatey (PowerShell en administrateur)
Set-ExecutionPolicy Bypass -Scope Process -Force
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# Installer Terraform
choco install terraform

# Vérifier l'installation
terraform version

Méthode 2 : Installation via winget

Si vous utilisez Windows 10/11 avec winget (le gestionnaire de paquets natif de Microsoft) :

# Installer Terraform via winget
winget install HashiCorp.Terraform

# Vérifier l'installation
terraform version

Méthode 3 : Installation manuelle

Pour une installation manuelle sur Windows :

1. Rendez-vous sur la page de téléchargement officielle.
2. Téléchargez l'archive ZIP pour Windows (AMD64).
3. Extrayez le fichier terraform.exe dans un répertoire de votre choix (par exemple C:\terraform).
4. Ajoutez ce répertoire à la variable d'environnement PATH :

# PowerShell - Ajouter au PATH utilisateur
[Environment]::SetEnvironmentVariable(
  "PATH",
  $env:PATH + ";C:\terraform",
  [EnvironmentVariableTarget]::User
)

# Redémarrer le terminal puis vérifier
terraform version

Vérifier l'installation

Quelle que soit votre méthode d'installation, vérifiez que Terraform est correctement installé en exécutant les commandes suivantes :

# Afficher la version installée
$ terraform version
Terraform v1.7.0
on darwin_arm64

# Afficher l'aide
$ terraform -help
Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

# Afficher l'aide d'une sous-commande spécifique
$ terraform plan -help

Si la commande terraform version affiche un numéro de version, votre installation est réussie.

Configurer l'autocomplétion

L'autocomplétion est une fonctionnalité très pratique qui vous permet de compléter automatiquement les commandes et sous-commandes Terraform en appuyant sur la touche Tab. Terraform fournit un support natif de l'autocomplétion pour Bash et Zsh.

Autocomplétion pour Bash

# Activer l'autocomplétion pour Bash
terraform -install-autocomplete

# Recharger le profil Bash
source ~/.bashrc

Autocomplétion pour Zsh

# Activer l'autocomplétion pour Zsh
terraform -install-autocomplete

# Recharger le profil Zsh
source ~/.zshrc

Après cette configuration, vous pourrez taper terraform suivi de Tab pour voir toutes les sous-commandes disponibles, ou commencer à taper une sous-commande et appuyer sur Tab pour la compléter automatiquement.

Configurer Visual Studio Code pour Terraform

Un bon éditeur de code fait toute la différence lorsque vous travaillez avec Terraform. Visual Studio Code, combiné avec l'extension officielle HashiCorp Terraform, offre une expérience de développement excellente.

Installer l'extension

Ouvrez VS Code et installez l'extension HashiCorp Terraform depuis le marketplace. Vous pouvez également l'installer en ligne de commande :

code --install-extension hashicorp.terraform

Fonctionnalités de l'extension

L'extension offre de nombreuses fonctionnalités qui améliorent la productivité :

• Coloration syntaxique pour les fichiers .tf et .tfvars
• Autocomplétion intelligente des types de ressources, attributs et fonctions
• Navigation dans le code (Go to Definition, Find References)
• Validation en temps réel de la syntaxe HCL
• Formatage automatique avec terraform fmt
• Documentation inline au survol des ressources et attributs

Configuration recommandée pour VS Code

Ajoutez ces paramètres dans votre fichier settings.json de VS Code pour une expérience optimale :

{
  "[terraform]": {
    "editor.defaultFormatter": "hashicorp.terraform",
    "editor.formatOnSave": true,
    "editor.formatOnSaveMode": "file"
  },
  "[terraform-vars]": {
    "editor.defaultFormatter": "hashicorp.terraform",
    "editor.formatOnSave": true,
    "editor.formatOnSaveMode": "file"
  },
  "terraform.experimentalFeatures.validateOnSave": true
}

Configurer les providers cloud

Une fois Terraform installé, vous devez configurer l'accès à votre fournisseur cloud. Voici comment procéder pour les trois principaux providers.

Configuration pour AWS

Pour utiliser Terraform avec AWS, vous avez besoin d'un Access Key ID et d'un Secret Access Key. La méthode recommandée est d'utiliser l'AWS CLI :

# Installer l'AWS CLI
# Sur macOS
brew install awscli

# Sur Linux (Ubuntu/Debian)
sudo apt install awscli

# Configurer les credentials
aws configure
# AWS Access Key ID: AKIAIOSFODNN7EXAMPLE
# AWS Secret Access Key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# Default region name: eu-west-3
# Default output format: json

Terraform utilisera automatiquement les credentials configurés par l'AWS CLI. Vous pouvez aussi utiliser des variables d'environnement :

# Méthode par variables d'environnement
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
export AWS_DEFAULT_REGION="eu-west-3"

La configuration du provider AWS dans Terraform :

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

provider "aws" {
  region = "eu-west-3"
  # Les credentials sont récupérées automatiquement
  # depuis l'AWS CLI ou les variables d'environnement
}

Configuration pour Azure

Pour Azure, installez l'Azure CLI et authentifiez-vous :

# Installer Azure CLI
# Sur macOS
brew install azure-cli

# Sur Linux
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Se connecter
az login

# Vérifier le compte actif
az account show

La configuration du provider Azure :

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

provider "azurerm" {
  features {}
  # L'authentification utilise automatiquement
  # les credentials de l'Azure CLI
}

Configuration pour Google Cloud (GCP)

Pour GCP, installez le SDK Google Cloud :

# Installer le SDK Google Cloud
# Sur macOS
brew install google-cloud-sdk

# Se connecter
gcloud auth application-default login

# Configurer le projet
gcloud config set project MON-PROJET-ID

La configuration du provider GCP :

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }
}

provider "google" {
  project = "mon-projet-id"
  region  = "europe-west1"
}

Structure d'un projet Terraform

Un projet Terraform bien organisé suit une structure de fichiers conventionnelle. Voici la structure recommandée pour un projet de taille moyenne :

mon-projet-terraform/
├── main.tf              # Ressources principales
├── variables.tf         # Déclarations de variables
├── outputs.tf           # Valeurs de sortie
├── providers.tf         # Configuration des providers
├── versions.tf          # Contraintes de version
├── terraform.tfvars     # Valeurs des variables (ne pas commiter les secrets)
├── backend.tf           # Configuration du backend distant
├── modules/             # Modules locaux réutilisables
│   ├── networking/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   └── outputs.tf
│   └── compute/
│       ├── main.tf
│       ├── variables.tf
│       └── outputs.tf
├── environments/        # Configurations par environnement
│   ├── dev/
│   │   └── terraform.tfvars
│   ├── staging/
│   │   └── terraform.tfvars
│   └── prod/
│       └── terraform.tfvars
├── .gitignore           # Fichiers à exclure de Git
└── README.md            # Documentation du projet

Le fichier .gitignore essentiel

Créez toujours un fichier .gitignore adapté à Terraform pour éviter de commiter des fichiers sensibles ou inutiles :

# Répertoire de travail Terraform
.terraform/
.terraform.lock.hcl

# Fichiers de state (contiennent des données sensibles)
*.tfstate
*.tfstate.*

# Fichiers de variables avec des secrets
*.tfvars
!example.tfvars

# Logs de crash
crash.log
crash.*.log

# Fichiers de plan
*.tfplan

# Fichiers de surcharge (rarement utilisés)
override.tf
override.tf.json
*_override.tf
*_override.tf.json

Premier test : terraform init

Pour valider votre installation, créons un projet minimal et exécutons terraform init. Créez un nouveau répertoire et un fichier main.tf :

# Créer le répertoire du projet
mkdir mon-premier-terraform && cd mon-premier-terraform

# Créer le fichier main.tf
cat > main.tf <<'EOF'
terraform {
  required_version = ">= 1.0"

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

resource "local_file" "hello" {
  content  = "Hello, Terraform !"
  filename = "${path.module}/hello.txt"
}
EOF

Maintenant, initialisez le projet :

$ terraform init

Initializing the backend...

Initializing provider plugins...
- Finding hashicorp/local versions matching "~> 2.0"...
- Installing hashicorp/local v2.4.1...
- Installed hashicorp/local v2.4.1 (signed by HashiCorp)

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure.

Testez ensuite le plan et appliquez :

# Voir le plan d'exécution
$ terraform plan

# Appliquer les changements
$ terraform apply -auto-approve

# Vérifier le résultat
$ cat hello.txt
Hello, Terraform !

# Nettoyer
$ terraform destroy -auto-approve

Si tout fonctionne, félicitations ! Votre environnement Terraform est correctement configuré et prêt pour des projets plus ambitieux.

Gérer plusieurs versions de Terraform avec tfenv

En entreprise, différents projets peuvent nécessiter différentes versions de Terraform. L'outil tfenv permet de gérer facilement plusieurs versions installées en parallèle, à la manière de nvm pour Node.js ou pyenv pour Python.

# Installer tfenv
# Sur macOS
brew install tfenv

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

# Lister les versions disponibles
tfenv list-remote

# Installer une version spécifique
tfenv install 1.7.0

# Installer la dernière version
tfenv install latest

# Utiliser une version spécifique
tfenv use 1.7.0

# Vérifier la version active
terraform version

# Définir une version par défaut pour un projet
echo "1.7.0" > .terraform-version

Le fichier .terraform-version à la racine d'un projet permet à tfenv de basculer automatiquement vers la bonne version lorsque vous entrez dans le répertoire du projet. C'est une pratique fortement recommandée en équipe.

Conclusion

Vous disposez maintenant d'un environnement Terraform entièrement fonctionnel, quel que soit votre système d'exploitation. Nous avons couvert l'installation via les gestionnaires de paquets (apt, brew, Chocolatey, winget) et via les binaires, la configuration de l'autocomplétion, la mise en place de VS Code avec l'extension officielle, la configuration des providers cloud (AWS, Azure, GCP), et la structure recommandée pour vos projets.

Avec ces bases solides, vous êtes prêt à passer à l'étape suivante : maîtriser le langage HCL, le cœur de Terraform. C'est précisément ce que nous aborderons dans le prochain article de cette série, où nous explorerons en détail la syntaxe, les types de données, les fonctions et les expressions avancées de HCL.

Cet article fait partie d'une série dédiée à Terraform sur CodeClan. N'hésitez pas à partager vos questions ou retours en commentaire, et restez connectés pour le prochain épisode !