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.

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"
    }
}

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 crucial. 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.