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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. 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

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Cloud Shell est préinstallé avec Terraform.
Si vous utilisez un shell local, procédez comme suit :
- Installez Terraform.
- Create local authentication credentials for your user account:
```
gcloud auth application-default login
```
  If an authentication error is returned, confirm that you have configured the gcloud CLI to use Workforce Identity Federation.
Create or select a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
- Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
  Replace PROJECT_ID with a name for the Google Cloud project you are creating.
- Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
  Replace PROJECT_ID with your Google Cloud project name.
Make sure that billing is enabled for your Google Cloud project.
Enable the Cloud Storage API:
```
gcloud services enable storage.googleapis.com
```
Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For examples, see Represent workforce pool users in IAM policies.
- Replace ROLE with each individual role.
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 des 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 pour stocker le fichier d'état. Ce bucket est configuré pour avoir 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 d'éviter que les informations d'état du bucket ne soient supprimées par erreur.
  - 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 d'autorisations IAM au lieu de listes de contrôle d'accès.
  - versioning est activé pour garantir 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