Les states de Terraform

Les états (states) dans Terraform sont le cœur de vos configurations. Ils représentent une photographie en temps réel de l’infrastructure gérée, stockant des informations importantes sur les ressources et leurs dépendances. Une gestion adéquate de ces états est essentielle pour maintenir la cohérence et la fiabilité de votre infrastructure. Un fichier d’état mal géré peut conduire à des désynchronisations, des erreurs de déploiement et, dans le pire des cas, à des perturbations majeures.

Dans ce guide, nous explorerons les nuances de la gestion des états dans Terraform. J’aborderai son fonctionnement, les meilleures pratiques pour maintenir l’intégrité des fichiers d’état et les stratégies pour optimiser la collaboration au sein des équipes.

Validité pour OpenTofu

La documentation présentée ici est également applicable à OpenTofu, un fork open source de Terraform. Ce fork a été créé en réponse au changement de licence de Terraform par HashiCorp en 2023, qui est passé de la licence open-source Mozilla Public License (MPL 2.0) à la Business Source License (BSL). Ce changement a été perçu par une partie de la communauté comme une restriction de la liberté d’utilisation, ce qui a conduit à la création d’OpenTofu pour garantir une continuité dans l’utilisation de Terraform sous une licence open-source. Par conséquent, les concepts, les commandes et les pratiques documentés ici s’appliquent également à OpenTofu.

Pour les commandes, il suffit de remplacer terraform par tofu :

tofu apply

Fonctionnement des États dans Terraform

Le concept des états dans Terraform est à la fois simple et puissant. Chaque fois que Terraform applique une configuration, il crée ou met à jour un fichier d’état. Ce fichier, généralement nommé terraform.tfstate, joue un rôle important en agissant comme une photographie de votre infrastructure actuelle.

Le fichier d’état contient des informations détaillées sur les ressources que Terraform a créées ou gère. Ces informations incluent non seulement l’état actuel des ressources (comme les identifiants, les attributs et les dépendances) mais aussi des métadonnées nécessaires pour la gestion de l’infrastructure. Cela permet à Terraform de savoir quelles actions entreprendre lors des prochaines exécutions et d’éviter des modifications inutiles ou redondantes.

Imaginons que vous déployez un serveur virtuel via Terraform. Lors de la première exécution, Terraform crée le serveur et enregistre des détails tels que son ID, son adresse IP et d’autres configurations dans le fichier d’état. Lors des exécutions ultérieures, Terraform se réfère à ce fichier pour déterminer si des modifications sont nécessaires. Si vous changez la configuration du serveur dans votre code Terraform, le fichier d’état aide à appliquer ces changements de manière ciblée et cohérente.

Pourquoi le Fichier d’État est-il Essentiel ?

La gestion efficace des fichiers d’état est essentielle pour plusieurs raisons :

• Cohérence : Elle assure que l’état de votre infrastructure correspond à ce qui est défini dans votre configuration Terraform.
• Performance : En ayant une vue claire de l’état actuel, Terraform peut opérer plus rapidement, en se concentrant uniquement sur les ressources qui nécessitent des changements.
• Sécurité : Un fichier d’état bien géré contribue à la sécurité de votre infrastructure en évitant des modifications accidentelles ou non autorisées.

Un Exemple Détaillé

Pour illustrer le rôle important des fichiers d’état dans Terraform, prenons l’exemple d’un projet de déploiement d’une infrastructure cloud simple. Supposons que vous ayez à configurer un serveur virtuel sur AWS, avec un groupe de sécurité associé et un équilibrage de charge.

Création et Gestion du Fichier d’État

Lorsque vous exécutez terraform apply pour la première fois, Terraform crée un fichier d’état nommé terraform.tfstate. Ce fichier enregistre des détails clés sur les ressources créées, comme les identifiants AWS, les adresses IP et les configurations de sécurité.

1. Configuration Initiale : Votre fichier Terraform définit un serveur EC2, un groupe de sécurité et un équilibrage de charge.
2. Première Exécution : Terraform déploie ces ressources et enregistre leurs états dans terraform.tfstate.
3. Consultation du Fichier d’État : Ce fichier contient maintenant des informations telles que l’ID de l’instance EC2, les règles du groupe de sécurité et les détails de l’équilibrage de charge.

Modifications et Mises à Jour

Supposons maintenant que vous modifiez la configuration pour augmenter la capacité de l’équilibrage de charge.

1. Mise à Jour de la Configuration : Vous ajustez le paramètre de capacité dans votre fichier Terraform.
2. Deuxième Exécution : Lorsque vous exécutez à nouveau terraform apply, Terraform compare l’état souhaité (votre configuration mise à jour) avec l’état actuel (stocké dans terraform.tfstate).
3. Application Sélective des Changements : Terraform détecte que seul l’équilibrage de charge doit être modifié et applique les changements nécessaires sans toucher aux autres ressources.

Les backends de Terraform

L’utilisation de backends dans Terraform joue un rôle important dans la gestion des états, surtout dans les environnements collaboratifs. Les backends déterminent où et comment les états sont stockés et gérés.

Le choix du backend doit être basé sur plusieurs facteurs, comme l’écosystème cloud utilisé, les besoins en matière de sécurité, de collaboration et de disponibilité. Chaque backend a ses forces et peut être mieux adapté à certains scénarios qu’à d’autres. Une compréhension claire de ces options vous aidera à choisir le backend le plus adapté à vos besoins en matière de gestion des états dans Terraform.

Le backend local

Par défaut les données du state sont stockés dans un fichier local, se nommant terraform.tfstate et utilise le backend local. On peut changer le répertoire ou il est stocké de cette manière :

terraform {
  backend "local" {
    path = "relative/path/to/terraform.tfstate"
  }
}

Le backend remote

Terraform propose de stocker ses states dans son infrastructure et ce soit :

• dans l’offre Terraform cloud
• dans l’offre Terraform Enterprise

Voici un exemple de configuration utilisant le backend remote :

terraform {
  backend "remote" {
    hostname = "app.terraform.io"
    organization = "company"

    workspaces {
      name = "my-app-prod"
    }
  }
}

Plus d’informations sur ce billet dédié

Les backends standards

Je ne documenterai pour le moment que le backend s3. Mais sachez qu’il existe les backends suivants (chacun n’intégrant pas forcément toutes les données du state) :

• artifactory ↗
• azurerm ↗
• consul ↗
• cos ↗
• etcd ↗
• gcs ↗
• http ↗
• kubernetes ↗
• manta ↗
• oss ↗
• pg ↗
• s3 ↗
• swift ↗

Le backend S3

Il est donc possible de stocker ses states dans des buckets Amazon S3. Ce backend prend en charge le verrouillage d'état et la vérification de cohérence avec une table Dynamo DB. Cela va permettre d’éviter de véroler les states suite à des déploiements simultanés par exemple.

Exemple de configuration utilisant le backend S3 :

terraform {
  backend "s3" {
    bucket = "mybucket"
    key    = "path/to/my/key"
    region = "eu-west-1"
    dynamodb_table = "terraform_state"
  }
}

Terraform doit posséder les permissions IAM suivantes pour stocker et lire les données du state:

s3:ListBucket on arn:aws:s3:::mybucket s3:GetObject on arn:aws:s3:::mybucket/path/to/my/key s3:PutObject on arn:aws:s3:::mybucket/path/to/my/key

Pour créer le backend S3 et la table dynamodb, vous pouvez utiliser cette configuration :

resource "aws_s3_bucket" "bucket" {
    bucket = "terraform-state-backend"
    versioning {
        enabled = true
    }
    server_side_encryption_configuration {
        rule {
            apply_server_side_encryption_by_default {
                sse_algorithm = "AES256"
            }
        }
    }
    object_lock_configuration {
        object_lock_enabled = "Enabled"
    }
    tags = {
        Name = "S3 Remote Terraform State Store"
    }
}

resource "aws_dynamodb_table" "terraform-lock" {
    name           = "terraform_state"
    read_capacity  = 5
    write_capacity = 5
    hash_key       = "LockID"
    attribute {
        name = "LockID"
        type = "S"
    }
    tags = {
        "Name" = "DynamoDB Terraform State Lock Table"
    }
}

Commandes de Gestion des States Terraform

La gestion des états dans Terraform est cruciale pour maintenir la synchronisation entre votre infrastructure et vos configurations. Voici un aperçu détaillé des principales commandes de gestion des états et leur utilisation.

terraform state list

Description : Cette commande permet de lister toutes les ressources suivies dans le fichier d’état. C’est un moyen efficace de vérifier quelles ressources sont présentes et confirmées dans l’état.

Utilisation :

terraform state list

outscale_internet_service.internet_gateway-a
outscale_internet_service_link.internet_gateway_link-a
outscale_nat_service.public_nat_gateway-a
outscale_net.net-a
outscale_public_ip.public_nat_gateway_ip-a
outscale_route.route-IGW
outscale_route.to_nat_gateway-a1
outscale_route_table.private_route_table-a
outscale_route_table.public_route_table-a
outscale_route_table_link.backend_subnet_private_route_table_link-a
outscale_route_table_link.public_subnet_public_route_table_link-a
outscale_security_group.sg-all-all-a
outscale_security_group.sg-ssh-all-a
outscale_security_group_rule.security_group_rule01-a
outscale_security_group_rule.security_group_rule02-a
outscale_security_group_rule.security_group_rule03-a
outscale_security_group_rule.security_group_rule04-a
outscale_security_group_rule.security_group_rule05-a
outscale_security_group_rule.security_group_rule06-a
outscale_security_group_rule.security_group_rule07-a
outscale_security_group_rule.security_group_rule08-a
outscale_security_group_rule.security_group_rule09-a
outscale_security_group_rule.security_group_rule10-a
outscale_security_group_rule.security_group_rule20-a
outscale_subnet.backend_subnet-a
outscale_subnet.public_subnet-a

terraform state show

Description : La commande terraform state show affiche les détails d’une ressource spécifique dans le fichier d’état. Elle est utile pour examiner les attributs et les métadonnées de la ressource.

Utilisation :

terraform state show outscale_subnet.public_subnet-a

# outscale_subnet.public_subnet-a:
resource "outscale_subnet" "public_subnet-a" {
    available_ips_count     = 251
    id                      = "subnet-60bbc997"
    ip_range                = "XX.XX.XX.XX/24"
    map_public_ip_on_launch = false
    net_id                  = "vpc-3e16ed2f"
    state                   = "available"
    subnet_id               = "subnet-60bbc997"
    subregion_name          = "eu-west-2a"

    tags {
        key   = "Name"
        value = "public_subnet-a"
    }
}

terraform state rm

Description : La commande terraform state rm permet de supprimer une ressource spécifique du fichier d’état sans la supprimer de l’infrastructure. Cela “désassocie” la ressource de Terraform, la laissant en place mais non gérée par celui-ci.

Utilisation :

terraform state rm outscale_security_group_rule.security_group_rule20-a

terraform state mv

Description : La commande terraform state mv déplace une ressource d’une adresse à une autre dans le fichier d’état. Cela est utile lors de la réorganisation de la structure des modules ou des ressources dans votre configuration Terraform.

Utilisation :

terraform state mv outscale_security_group_rule.security_group_rule20-a module.new_module.outscale_security_group_rule.security_group_rule20-a

terraform state pull

Description : Cette commande extrait l’état actuel depuis le backend distant et l’affiche sous forme de JSON. Cela permet de visualiser le fichier d’état sans avoir besoin d’accéder directement au backend.

Utilisation :

terraform state pull > state.json

Cas d’utilisation : Utilisez terraform state pull pour sauvegarder l’état actuel dans un fichier local, par exemple, pour le versionner ou l’analyser.

terraform state push

Description : La commande terraform state push permet de charger un fichier d’état local vers le backend distant. Cela peut être nécessaire si vous devez restaurer un état précédent.

Utilisation :

terraform state push state.json

terraform state replace-provider

Description : Cette commande remplace un fournisseur dans le fichier d’état par un autre. Cela peut être nécessaire si vous migrez des ressources d’un fournisseur à un autre (par exemple, d’un fournisseur obsolète à une version mise à jour).

Utilisation :

terraform state replace-provider 'hashicorp/aws' 'custom/aws'

Dépannage et Récupération d’États dans Terraform

Même avec les meilleures pratiques de gestion des états, des problèmes peuvent survenir, nécessitant un dépannage efficace et parfois une récupération d’états. Ce chapitre vous guide à travers les stratégies de dépannage et les étapes de récupération pour maintenir la stabilité de votre infrastructure gérée par Terraform.

Identification et Résolution des Problèmes Courants

• États Désynchronisés : Si Terraform indique des différences inattendues, vérifiez la cohérence entre votre infrastructure réelle et le fichier d’état. Une désynchronisation peut survenir à la suite de modifications manuelles dans l’infrastructure.
• Fichiers d’État Corrompus : Les fichiers d’état peuvent être endommagés en raison d’interruptions pendant l’exécution de Terraform ou de problèmes de stockage. Dans ce cas, Terraform ne pourra pas lire ni écrire correctement dans le fichier d’état.

Utilisation des Commandes Terraform pour le Dépannage

• terraform refresh : Cette commande permet de mettre à jour le fichier d’état pour qu’il corresponde à l’état réel des ressources dans le cloud.
• terraform plan : Exécutez terraform plan pour examiner les actions que Terraform envisage de prendre. Cela peut aider à identifier les incohérences.

Récupération des Fichiers d’État

• En cas de corruption ou de perte du fichier d’état, la récupération peut être complexe.
• Si vous avez activé le versionnement dans votre backend distant, vous pouvez restaurer une version antérieure du fichier d’état.
• Autrement, terraform import peut être utilisé pour reconstruire le fichier d’état. Cette commande permet d’importer les ressources existantes dans un nouveau fichier d’état.

Prévention des Problèmes Futurs

• Sauvegardes Régulières : Assurez-vous de sauvegarder régulièrement vos fichiers d’état, surtout avant d’effectuer des modifications majeures.
• Tests et Validation : Avant d’appliquer des changements importants, testez vos configurations dans un environnement de test pour prévenir les problèmes dans la production.

Gestion des Scénarios d’Urgence

• En cas de situation d’urgence, avoir un plan de récupération clair est indispensable. Documentez les procédures de dépannage et de récupération pour votre équipe.
• La communication rapide et efficace est essentielle lors de la gestion des incidents pour minimiser l’impact sur l’infrastructure.

Le dépannage et la récupération d’états sont des compétences essentielles pour tout administrateur système travaillant avec Terraform. Une compréhension approfondie de ces processus assure non seulement la stabilité de votre infrastructure, mais aussi sa résilience face aux imprévus.

Bonnes Pratiques de Gestion des États

La gestion des fichiers d’état dans Terraform est une tâche délicate qui nécessite attention et rigueur. Un fichier d’état mal géré peut entraîner des incohérences d’infrastructure et des risques sécuritaires. Voici quelques bonnes pratiques pour maintenir l’intégrité de vos fichiers d’état.

• Stocker les fichiers d’état localement sur votre machine n’est pas recommandé, surtout dans un environnement d’équipe.
• Utiliser des backends distants comme S3 d’AWS, Azure Blob Storage, ou Google Cloud Storage. Cela permet de sécuriser, partager et versionner les fichiers d’état. Ces services offrent également des fonctionnalités comme le verrouillage d’état pour prévenir les conflits lors des modifications simultanées.
• Les fichiers d’état peuvent contenir des informations sensibles. Il est important de les chiffrer lors du stockage. La plupart des services de backend distant offrent des options de chiffrement, assurez-vous de les activer.
• Restreindre l’accès aux fichiers d’état est essentiel pour la sécurité. Configurer des contrôles d’accès précis et donner les permissions uniquement aux utilisateurs nécessaires.
• Activer le versionnement sur votre backend pour garder un historique des modifications apportées aux fichiers d’état. Effectuer des sauvegardes régulières pour prévenir la perte de données en cas de corruption ou de suppression accidentelle.
• Gérer des états séparés pour vos environnements de développement, de test et de production. Cela permet d’éviter les interférences entre les environnements et réduit le risque d’erreurs.

Conclusion

La clé du succès dans la gestion des state Terrafom réside dans une approche méthodique. En adoptant les bonnes pratiques et en se préparant aux éventualités, vous pouvez non seulement prévenir les problèmes, mais aussi réagir efficacement lorsqu’ils surviennent.

J’espère que ce guide vous a fourni des insights utiles et des connaissances pratiques pour gérer efficacement les states de Terraform.