Terraform Certification Hub
0 % complété
Se connecter

Infrastructure as Code avec Terraform › Théorie › Leçon 3 sur 8

Ce qu'est l'Infrastructure as Code

Domaine 1 de l'examen, 8 % des questions. 16 questions couvrant les objectifs 1a, 1b et 1c.

L'Infrastructure as Code consiste à décrire une infrastructure dans des fichiers texte versionnés, et à confier à un outil le soin de faire converger l'infrastructure réelle vers cette description.

La définition tient en deux points : l'infrastructure est décrite dans du code, et ce code est la source de vérité. Un script bash qui appelle des commandes cloud satisfait le premier point mais pas le second.

3.1 Déclaratif contre impératif

C'est la distinction centrale du module, et elle est régulièrement testée à l'examen.

Une approche impérative décrit la séquence d'opérations à exécuter : créer ce réseau, puis cette machine, puis attacher ce disque. Le script porte la logique du comment. Rejoué sur un environnement déjà provisionné, il échoue ou crée des doublons, sauf si l'auteur a lui-même code toutes les vérifications d'existence.

Une approche déclarative décrit l'état désiré : je veux ce réseau, cette machine et ce disque. L'outil compare cet état désiré à l'état réel, calcule l'écart, et n'applique que le delta. Terraform est déclaratif.

La différence se lit directement sur le même besoin, une instance Compute Engine.

# Impératif : la commande décrit l'opération à exécuter
gcloud compute instances create app-prod-01 \
    --zone=europe-west1-b \
    --machine-type=e2-standard-2 \
    --image-family=debian-12 \
    --image-project=debian-cloud

Relancée telle quelle, cette commande échoue avec already exists. Pour la rendre rejouable, il faut coder soi-même la vérification, puis la logique de mise à jour si la taille de machine a changé, puis celle du cas où l'instance existe dans une autre zone.

# Déclaratif : la configuration décrit l'état attendu
resource "google_compute_instance" "app_prod" {
  name         = "app-prod-01"
  zone         = "europe-west1-b"
  machine_type = "e2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }

  network_interface {
    network = "default"
  }
}

Appliqué une seconde fois, ce bloc ne produit aucun changement. Modifier machine_type en e2-standard-4 puis réappliquer produit une mise à jour, pas un doublon. Aucune de ces deux logiques n'a eu à être écrite.

graph LR
    subgraph "Impératif"
        direction TB
        S1[Script : créer VM] --> S2{VM existe ?}
        S2 -->|Non| S3[Création]
        S2 -->|Oui| S4[Erreur ou doublon]
    end

    subgraph "Déclaratif"
        direction TB
        D1[Configuration :<br>une VM doit exister] --> D2[Terraform compare<br>désiré et réel]
        D2 --> D3{Écart ?}
        D3 -->|Oui| D4[Applique le delta]
        D3 -->|Non| D5[No changes]
    end

    style S4 fill:#ffcccb,stroke:#b22222
    style D4 fill:#d4edda,stroke:#228b22
    style D5 fill:#d4edda,stroke:#228b22

Conséquence opérationnelle : cette propriété s'appelle l'idempotence. Appliquer deux fois la même configuration produit le même résultat que l'appliquer une fois. C'est ce qui rend l'exécution rejouable sans danger dans une chaîne d'intégration continue, et c'est la condition d'une automatisation fiable.

3.2 Le graphe de dépendances

Terraform ne lit pas la configuration de haut en bas. Il construit un graphe orienté acyclique des ressources à partir des références entre elles, puis parcourt ce graphe pour déterminer l'ordre des opérations et ce qui peut être exécuté en parallèle.

Quand une ressource référence un attribut d'une autre, Terraform en déduit une dépendance sans qu'on ait besoin de la déclarer. C'est pour cette raison que l'ordre des blocs dans un fichier n'a aucune importance, et que le nom des fichiers .tf n'en a pas non plus.

graph TD
    VPC[google_compute_network<br>vpc-prod] --> Sub[google_compute_subnetwork<br>subnet-europe-west1]
    Sub --> VM1[google_compute_instance<br>app-prod-01]
    Sub --> VM2[google_compute_instance<br>app-prod-02]
    VPC --> FW[google_compute_firewall<br>allow-internal]
    VM1 --> Disk[google_compute_attached_disk<br>data-disk-01]

    Note[app-prod-01 et app-prod-02 :<br>créées en parallèle,<br>aucune dépendance entre elles]

    style VPC fill:#d4edda,stroke:#228b22
    style Note fill:#fff3cd,stroke:#856404

Au moment de la destruction, Terraform parcourt le même graphe en sens inverse : le disque attaché avant l'instance, l'instance avant le sous-réseau, le sous-réseau avant le VPC. C'est ce qui évite l'erreur resource in use que produit une suppression manuelle dans le mauvais ordre.

3.3 Les avantages des patterns IaC

L'objectif 1b demande de décrire les avantages. Ils se ramènent à cinq, chacun ayant une contrepartie qu'il faut savoir énoncer.

Avantage Ce que cela apporte Contrepartie
Versionnement L'historique Git devient l'historique de l'infrastructure : qui, quand, quoi, et le message expliquant pourquoi Le dépôt devient critique, sa compromission expose la topologie complète
Revue par les pairs Un changement d'infrastructure passe par une pull request, comme un changement applicatif Délai supplémentaire avant application, mal vécu en situation d'urgence
Reproductibilité Le même code crée des environnements identiques (développement, préproduction, production) Nécessite de paramétrer proprement, sinon le code se duplique par environnement
Réduction de la dérive L'écart entre désiré et réel devient détectable par une commande, au lieu d'être invisible La détection ne sert que si quelqu'un la lance et la traite
Documentation vivante La configuration décrit l'état réel, elle ne peut pas devenir obsolète sans que l'infrastructure change Le code décrit le quoi, pas le pourquoi : les décisions d'architecture restent à documenter ailleurs

Ce que l'IaC ne résout pas : elle ne remplace ni la conception d'architecture, ni la gestion des accès, ni la surveillance. Elle déplace le risque plutôt qu'elle ne le supprime. Un terraform destroy lancé sur le mauvais répertoire détruit une production en quelques minutes, ce qu'une console web rend plus difficile à faire par inadvertance.

3.4 Terraform et la gestion de configuration

Terraform provisionne : il crée, modifie et détruit des ressources d'infrastructure (réseaux, machines, bases de données managées, rôles).

Ansible, Chef, Puppet et SaltStack configurent : ils installent des paquets, déposent des fichiers, gèrent des services à l'intérieur de machines qui existent déjà.

Ces catégories sont complémentaires, pas concurrentes. Une chaîne courante utilise Terraform pour créer les machines, puis Ansible pour les configurer. La question d'examen classique consiste à présenter Terraform comme un outil de gestion de configuration : c'est faux.

Deux nuances à connaître :

  • Les provisioners Terraform (remote-exec, local-exec, file) permettent d'exécuter des commandes sur une ressource créée, mais HashiCorp les documente explicitement comme un dernier recours. Ils sortent du modèle déclaratif : leur exécution n'est pas suivie dans le state et leur échec laisse la ressource marquée comme corrompue.
  • Le modèle immuable (immutable infrastructure) consiste à ne jamais modifier une machine en place, mais à en construire une nouvelle à partir d'une image et à remplacer l'ancienne. Il réduit la surface de la gestion de configuration au moment de la construction de l'image.