Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Stocker l'état Terraform dans un bucket Cloud Storage

Dans ce tutoriel, vous allez apprendre à stocker l'état Terraform dans un bucket Cloud Storage.

Par défaut, Terraform stocke l'état localement dans un fichier nommé terraform.tfstate. Cette configuration par défaut peut rendre l'utilisation de Terraform difficile pour les équipes lorsque de multiples utilisateurs exécutent Terraform en même temps et que chaque ordinateur possède sa propre compréhension de l'infrastructure actuelle.

Pour vous aider à éviter de tels problèmes, cette page vous explique comment configurer un état distant qui pointe vers un bucket Cloud Storage. Un état distant est une fonctionnalité des backends Terraform.

Objectifs

Ce tutoriel vous explique comment effectuer les tâches suivantes :

Utilisez Terraform pour provisionner un bucket Cloud Storage afin de stocker l'état Terraform.
Ajoutez des modèles dans le fichier de configuration Terraform pour migrer l'état du backend local vers le bucket Cloud Storage.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Cloud Storage

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Cloud Storage entraîne des coûts liés au stockage, aux opérations de lecture et d'écriture, à la sortie réseau et à la réplication.

Dans le bucket Cloud Storage de ce tutoriel, la gestion des versions des objets est activée pour conserver l'historique de vos déploiements. L'activation de la gestion des versions des objets augmente les coûts de stockage. Vous pouvez limiter cette augmentation des coûts en configurant la gestion du cycle de vie des objets afin de supprimer les anciennes versions d'état.

Avant de commencer

Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

Terraform est préinstallé sur Cloud Shell.
Si vous utilisez un shell local, procédez comme suit :
- Installez Terraform.
- Créez des identifiants d'authentification locaux pour votre compte utilisateur :
```
gcloud auth application-default login
```
  Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.
Créez ou sélectionnez un projet Google Cloud .
Rôles requis pour sélectionner ou créer un projet
- Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
- Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.
Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.
- Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
  Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
- Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
  Remplacez PROJECT_ID par le nom de votre projet Google Cloud .
Vérifiez que la facturation est activée pour votre projet Google Cloud .
Activez l'API Cloud Storage :
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.
```
gcloud services enable storage.googleapis.com
```
Attribuez des rôles à votre compte utilisateur. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet
- USER_IDENTIFIER : identifiant de votre compte d'utilisateur. compte. Pour consulter des exemples, reportez-vous à la page Représenter les utilisateurs de pools de personnel dans les stratégies IAM.
- ROLE : rôle IAM que vous accordez à votre compte utilisateur.
Vous pouvez également créer un rôle IAM personnalisé contenant les autorisations suivantes :
- storage.buckets.create
- storage.buckets.list
- storage.objects.get
- storage.objects.create
- storage.objects.delete
- storage.objects.update
Nous vous recommandons de contrôler les accès au bucket et aux fichiers d'état qui y sont stockés. Seul un petit groupe d'utilisateurs (par exemple, l'administrateur cloud principal et la personne agissant en tant qu'administrateur alternatif ou de secours) doit disposer des autorisations d'administrateur pour le bucket. Les autres développeurs doivent être uniquement autorisés à écrire et à lire des objets dans le bucket.

Préparer l'environnement

Clonez le dépôt GitHub contenant les exemples Terraform :

git clone https://github.com/terraform-google-modules/terraform-docs-samples.git --single-branch

Accédez au répertoire de travail :

cd terraform-docs-samples/storage/remote_terraform_backend_template

Examiner les fichiers Terraform

Examinez le fichier main.tf :
```
cat main.tf
```
Le résultat ressemble à ce qui suit :
```
resource "random_id" "default" {
  byte_length = 8
}

resource "google_storage_bucket" "default" {
  name     = "${random_id.default.hex}-terraform-remote-backend"
  location = "US"

  force_destroy               = false
  public_access_prevention    = "enforced"
  uniform_bucket_level_access = true

  versioning {
    enabled = true
  }
}

resource "local_file" "default" {
  file_permission = "0644"
  filename        = "${path.module}/backend.tf"

  # You can store the template in a file and use the templatefile function for
  # more modularity, if you prefer, instead of storing the template inline as
  # we do here.
  content = <<-EOT
  terraform {
    backend "gcs" {
      bucket = "${google_storage_bucket.default.name}"
    }
  }
  EOT
}
```
Ce fichier décrit les ressources suivantes :
- random_id : cette valeur est ajoutée au nom du bucket Cloud Storage pour garantir un nom unique.
- google_storage_bucket : bucket Cloud Storage permettant de stocker le fichier d'état. Ce bucket est configuré avec les propriétés suivantes :
  - force_destroy est défini sur false pour s'assurer que le bucket n'est pas supprimé s'il contient des objets. Cela permet de s'assurer que les informations sur l'état du bucket ne sont pas supprimées accidentellement.
  - public_access_prevention est défini sur enforced pour s'assurer que le contenu du bucket n'est pas accidentellement exposé au public.
  - uniform_bucket_level_access est défini sur true pour permettre de contrôler l'accès au bucket et à son contenu à l'aide des autorisations IAM au lieu des listes de contrôle des accès d'accès.
  - versioning est activé pour s'assurer que les versions antérieures de l'état sont conservées dans le bucket.
- local_file : fichier local. Le contenu de ce fichier indique à Terraform d'utiliser le bucket Cloud Storage comme backend distant une fois le bucket créé.

Provisionner le bucket Cloud Storage

Initialisez Terraform :
```
terraform init
```
Lorsque vous exécutez terraform init pour la première fois, le bucket Cloud Storage que vous avez spécifié dans le fichier main.tf n'existe pas encore. Terraform initialise donc un backend local pour stocker l'état dans le système de fichiers local.
Appliquez la configuration pour provisionner les ressources décrites dans le fichier main.tf :
```
terraform apply
```
Lorsque vous y êtes invité, saisissez yes.

Lorsque vous exécutez terraform apply pour la première fois, Terraform provisionne le bucket Cloud Storage pour stocker l'état. Il crée également un fichier local dont le contenu indique à Terraform d'utiliser le bucket Cloud Storage comme backend distant pour stocker l'état.

Migrer l'état vers un bucket Cloud Storage

Migrez l'état Terraform vers le backend Cloud Storage distant :
```
terraform init -migrate-state
```
Terraform détecte que vous disposez déjà d'un fichier d'état local et vous invite à migrer l'état vers le nouveau bucket Cloud Storage. Lorsque vous y êtes invité, saisissez yes.

Une fois cette commande exécutée, votre état Terraform est stocké dans le bucket Cloud Storage. Terraform extrait le dernier état de ce bucket avant d'exécuter une commande et transfère le dernier état vers le bucket après l'exécution d'une commande.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Pour éviter que les ressources utilisées sur cette page ne soient facturées sur votre compte Google Cloud , procédez comme suit :

Ouvrez le fichier main.tf.
Dans la ressource google_storage_bucket.default, remplacez la valeur de force_destroy par true.
Appliquez la configuration mise à jour :
```
terraform apply
```
Lorsque vous y êtes invité, saisissez yes.
Supprimez le fichier d'état :
```
rm backend.tf
```
Reconfigurez le backend pour qu'il soit local :
```
terraform init -migrate-state
```
Lorsque vous y êtes invité, saisissez yes.
Exécutez la commande suivante pour supprimer les ressources Terraform :
```
terraform destroy
```
Lorsque vous y êtes invité, saisissez yes.

Étape suivante

Découvrez comment gérer une Infrastructure as code avec Terraform, Cloud Build et GitOps.
Apprenez-en plus sur la validation des règles