Définir des ressources

Introduction

Lors du laboratoire précédent, nous avons préparé notre cuisine (en installant Terraform). Il est maintenant temps d’écrire le menu.

Avec Terraform, vous ne décrivez généralement pas chaque étape technique de bas niveau. Vous décrivez plutôt les objets d’infrastructure souhaités. Chaque objet géré est représenté par une ressource.

Les ressources sont les principales unités gérées par Terraform. Elles font le lien entre le code de vos fichiers .tf et les objets réels de la plateforme cible.

Imaginez que vous passez une commande au restaurant. Vous ne dites pas au chef : « émincez un oignon, faites-le revenir, battez deux œufs… » ; vous dites simplement : « Je veux une omelette ». Terraform joue le rôle du serveur qui prend votre commande (la configuration) et s’assure que la cuisine (Docker) prépare exactement ce que vous avez demandé.

C’est le fonctionnement essentiel de Terraform : définir les ressources, prévisualiser les modifications proposées, puis les appliquer.

Définir l’image

Commençons par indiquer les ingrédients nécessaires. Dans l’univers Docker, avant de pouvoir exécuter un conteneur, vous avez besoin d’une image (qui ressemble à un paquet logiciel figé).

Commencez par accéder au dossier du projet et créez notre fiche de commande, le fichier main.tf.

cd ~/project
touch main.tf

Ouvrez main.tf avec l’éditeur de texte nano.

nano main.tf

Nous commençons toujours par indiquer à Terraform quel outil effectuera le travail (le provider). Copiez-collez ce bloc standard au début de votre fichier pour configurer le provider Docker :

terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 3.0.1"
    }
  }
}

provider "docker" {}

Ajoutez maintenant notre première demande : l’image Nginx. Ajoutez ce code dans votre fichier main.tf, sous le bloc du provider (utilisez les touches fléchées pour descendre) :

resource "docker_image" "nginx" {
  name         = "nginx:latest"
  keep_locally = false
}

Après avoir collé le code, enregistrez votre travail. Appuyez sur Ctrl + O, puis sur Enter pour confirmer, et enfin sur Ctrl + X pour quitter l’éditeur.

Décomposons cette syntaxe :

resource : ce mot indique à Terraform : « Je veux commander quelque chose. »
"docker_image" : il s’agit du type de l’élément commandé. Avec une intégration AWS, il pourrait s’agir de aws_instance.
"nginx" : il s’agit du nom que nous donnons à cet élément dans notre carnet afin de pouvoir y faire référence plus tard. Ce nom ne modifie rien dans le monde réel.
name = "nginx:latest" : il s’agit du paramètre précis envoyé à Docker. Il indique à Docker exactement quelle image télécharger.

Votre plan contient désormais un provider et une instruction définissant une ressource.

Définir le conteneur

Une image est stockée sur le disque, tandis qu’un conteneur correspond à l’application en cours d’exécution. C’est la différence entre une recette et le plat réellement servi dans l’assiette.

Nous allons maintenant ajouter une deuxième ressource à notre fichier main.tf. Cette nouvelle ressource dépend de la première.

Ouvrez à nouveau main.tf avec nano :

nano main.tf

Utilisez les touches fléchées pour aller à la fin du fichier, puis collez ce bloc à la dernière ligne :

resource "docker_container" "web" {
  image = docker_image.nginx.image_id
  name  = "tutorial"
  ports {
    internal = 80
    external = 8000
  }
}

Observez la particularité de la ligne image = docker_image.nginx.image_id.

Cette référence est plus qu’un simple raccourci. Elle permet à Terraform de construire un graphe de dépendances afin de déterminer automatiquement l’ordre de création.

Au lieu de saisir à nouveau "nginx:latest", nous faisons référence à la ressource définie précédemment (docker_image.nginx). Cela indique à Terraform : « Ne tente pas de créer ce conteneur avant d’avoir terminé de préparer l’image. » C’est ainsi que nous créons des dépendances.

Nous avons également ajouté un bloc ports. Il ouvre un accès depuis votre ordinateur (le port 8000) vers le conteneur (le port 80), ce qui vous permet d’afficher le site web.

Initialiser et planifier

Avant de laisser Terraform modifier l’infrastructure, nous devons initialiser le projet (télécharger les outils), puis prévisualiser le plan.

Commencez par exécuter init pour installer les plugins du provider Docker :

terraform init

Imaginez que le serveur apporte votre plat immédiatement, sans confirmer la commande. Ce serait risqué ! Terraform possède une fonction de sécurité appelée Plan. Elle examine ce que vous avez demandé, ce qui existe déjà, puis calcule la différence.

Exécutez la commande de planification :

terraform plan

Observez attentivement la sortie. Vous verrez des signes + verts à côté des ressources. Ces symboles signifient : « Je vais créer ceci. »

L’étape de planification est l’une des fonctions de sécurité les plus utiles de Terraform. Elle vous permet d’examiner les modifications proposées avant qu’un élément réel soit modifié.

Conseil important : lisez toujours le plan. C’est votre dernière occasion de repérer les erreurs avant qu’elles ne deviennent une réalité dans l’infrastructure.

Appliquer les modifications

Le plan semble correct. Il est maintenant temps de dire au serveur : « Exécutez la commande ! »

La commande apply exécute le plan.

terraform apply

Terraform est très prudent. Il affiche une nouvelle fois le plan et vous demande une confirmation finale. Vous devez saisir yes pour continuer.

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

Après avoir saisi yes et appuyé sur Entrée, Terraform contacte Docker, télécharge l’image et démarre le conteneur.

Vérifions que tout a fonctionné ! Vous pouvez utiliser les commandes Docker standard pour vérifier que le conteneur est en cours d’exécution :

docker ps

Vous pouvez également tester le site web que nous venons de déployer. Comme nous avons associé le port 8000, nous pouvons y accéder avec curl :

curl localhost:8000

Si le code HTML contenant « Welcome to nginx! » s’affiche, vous avez déployé avec succès votre première infrastructure à l’aide du code !

Résumé

Félicitations ! Vous avez terminé le processus Terraform essentiel.

Dans ce laboratoire, vous avez appris à :

Définir des ressources : spécifier ce que vous voulez (des images et des conteneurs) dans main.tf.
Utiliser des références : relier des ressources entre elles, par exemple en indiquant à un conteneur quelle image utiliser.
Planifier : prévisualiser la « facture » avant de valider les modifications.
Appliquer : créer l’infrastructure réelle.

Ce cycle Write -> Plan -> Apply correspond exactement à la manière dont les professionnels gèrent d’immenses infrastructures cloud. Vous venez de faire votre premier pas vers le métier d’ingénieur DevOps.