Création de ressources de base avec Terraform : Créer un fichier local

Introduction

Terraform est un outil d'Infrastructure as Code (IaC) open-source créé par HashiCorp. Il vous permet de définir et de fournir une infrastructure de centre de données à l'aide d'un langage de configuration déclaratif. Cela signifie que vous décrivez l'infrastructure souhaitée dans des fichiers de configuration, et Terraform détermine comment créer, mettre à jour ou supprimer les ressources pour correspondre à cet état.

Le flux de travail principal de Terraform se compose de trois étapes clés :

Écriture (Write) : Rédiger l'infrastructure sous forme de code.
Planification (Plan) : Prévisualiser les modifications avant de les appliquer.
Application (Apply) : Provisionner et gérer votre infrastructure.

Dans ce laboratoire, vous allez parcourir l'intégralité de ce flux de travail en créant une ressource très simple : un fichier local. L'utilisation du fournisseur local est un excellent moyen d'apprendre les mécanismes de Terraform sans avoir besoin d'identifiants pour un fournisseur cloud. Vous définirez un fichier, planifierez sa création, appliquerez les modifications et vérifierez le résultat.

Définir une ressource local_file dans main.tf

Dans cette étape, vous allez commencer par définir une ressource dans votre fichier de configuration Terraform. Toutes les configurations Terraform sont écrites dans des fichiers se terminant par l'extension .tf. Le fichier de configuration principal est généralement nommé main.tf.

Un bloc resource est la syntaxe principale pour déclarer un objet d'infrastructure. Il définit une ressource d'un type donné (par exemple, local_file) avec un nom local donné (par exemple, example). La combinaison du type et du nom doit être unique au sein d'un module.

Tout d'abord, ouvrez le fichier main.tf dans votre répertoire ~/project à l'aide de l'éditeur de texte nano.

nano main.tf

Ajoutez maintenant le code suivant au fichier. Cela définit une ressource de type local_file et lui donne le nom local example. Pour l'instant, le bloc de ressource est vide.

resource "local_file" "example" {
}

Après avoir ajouté le code, enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et enfin Enter.

Spécifier le nom du fichier et le contenu dans le bloc de ressource

Dans cette étape, vous allez ajouter des arguments au bloc de ressource pour spécifier les propriétés du fichier que vous souhaitez créer. Les arguments sont les paires clé-valeur à l'intérieur d'un bloc de ressource qui définissent sa configuration. Pour une ressource local_file, les deux arguments les plus importants sont filename et content.

filename : Le chemin vers le fichier qui sera créé.
content : Le contenu à écrire dans le fichier.

Ouvrez à nouveau le fichier main.tf avec nano.

nano main.tf

Modifiez le bloc de ressource local_file pour inclure les arguments filename et content comme indiqué ci-dessous.

resource "local_file" "example" {
  content  = "Hello, Terraform!"
  filename = "${path.module}/hello.txt"
}

Ici, nous demandons à Terraform de créer un fichier nommé hello.txt dans le répertoire actuel du projet. ${path.module} est une expression Terraform spéciale qui correspond au chemin du module actuel, qui dans ce cas est ~/project. Le contenu du fichier sera la chaîne "Hello, Terraform!".

Enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, Y et Enter.

Initialiser Terraform et prévisualiser les modifications

Dans cette étape, vous allez d'abord initialiser votre projet Terraform, puis exécuter la commande terraform plan pour créer un plan d'exécution.

Avant de pouvoir planifier des modifications, vous devez initialiser le projet. La commande terraform init analyse votre configuration, télécharge les fournisseurs requis (dans ce cas, pour local_file) et configure le backend.

Dans votre terminal, exécutez d'abord terraform init :

terraform init

Une fois l'initialisation réussie, exécutez terraform plan. Cette commande est une partie cruciale du flux de travail Terraform car elle fournit une "simulation" des modifications. Elle vous montre ce que Terraform fera sur votre infrastructure sans réellement effectuer de changements. Cela vous permet de vérifier et de valider les actions prévues avant qu'elles ne soient appliquées.

terraform plan

Terraform lira votre fichier de configuration et le comparera à l'état actuel de votre infrastructure (qui est actuellement vide). Il affichera ensuite un plan d'action. Vous devriez voir une sortie similaire à la suivante, indiquant qu'une ressource va être créée.

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  ## local_file.example will be created
  + resource "local_file" "example" {
      + content              = "Hello, Terraform!"
      + content_base64sha256 = (known after apply)
      + content_base64sha512 = (known after apply)
      + content_md5          = (known after apply)
      + content_sha1         = (known after apply)
      + content_sha256       = (known after apply)
      + content_sha512       = (known after apply)
      + directory_permission = "0777"
      + file_permission      = "0777"
      + filename             = "./hello.txt"
      + id                   = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Le symbole + à côté de resource "local_file" "example" signifie que cette ressource sera créée. La sortie détaille tous les attributs qui seront définis sur le nouveau fichier.

Exécuter terraform apply pour créer la ressource

Dans cette étape, vous allez appliquer les modifications à l'aide de la commande terraform apply pour créer réellement le fichier. Cette commande exécute les actions proposées dans la sortie de terraform plan.

Par défaut, terraform apply vous montrera à nouveau le plan et demandera une confirmation interactive avant de procéder. Pour le rendre non interactif, ce qui est utile pour les laboratoires et l'automatisation, vous pouvez utiliser l'indicateur -auto-approve.

Exécutez la commande suivante dans votre terminal :

terraform apply -auto-approve

Terraform va maintenant exécuter le plan. La sortie affichera d'abord le plan à nouveau, suivi de la progression de l'application. Une fois terminé, vous verrez un message de confirmation.

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  ## local_file.example will be created
  + resource "local_file" "example" {
      + content              = "Hello, Terraform!"
      + content_base64sha256 = (known after apply)
      + content_base64sha512 = (known after apply)
      + content_md5          = (known after apply)
      + content_sha1         = (known after apply)
      + content_sha256       = (known after apply)
      + content_sha512       = (known after apply)
      + directory_permission = "0777"
      + file_permission      = "0777"
      + filename             = "./hello.txt"
      + id                   = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.
local_file.example: Creating...
local_file.example: Creation complete after 0s [id=42086c02e03bf671ddf621ed9922f52f2c7a605c]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Le message "Apply complete!" confirme que Terraform a créé avec succès la ressource telle que définie dans votre configuration.

Vérifier que le fichier créé existe dans le système de fichiers

Dans cette dernière étape, vous allez vérifier que Terraform a bien créé le fichier sur votre système de fichiers local comme spécifié. Puisque vous avez utilisé la ressource local_file, le résultat est un fichier tangible dans votre répertoire de projet.

Tout d'abord, utilisez la commande ls pour lister les fichiers dans le répertoire actuel. Vous devriez maintenant voir hello.txt aux côtés de votre fichier de configuration Terraform.

ls

Sortie attendue :

hello.txt  main.tf  terraform.tfstate

Ensuite, utilisez la commande cat pour afficher le contenu du fichier hello.txt nouvellement créé.

cat hello.txt

Vous devriez voir le contenu que vous avez défini dans main.tf.

Hello, Terraform!

Cela confirme que votre configuration Terraform a été appliquée avec succès et que la ressource a été créée exactement comme vous l'avez définie dans votre code.

Résumé

Félicitations ! Vous avez terminé avec succès votre premier projet Terraform.

Dans ce laboratoire, vous avez appris le flux de travail fondamental de Terraform :

Écriture (Write) : Vous avez défini une ressource local_file dans un fichier de configuration main.tf.
Planification (Plan) : Vous avez utilisé terraform plan pour prévisualiser la création du fichier sans effectuer de modifications.
Application (Apply) : Vous avez utilisé terraform apply pour exécuter le plan et créer le fichier sur votre système de fichiers local.

Cet exemple simple de création d'un fichier local démontre la puissance fondamentale de l'Infrastructure as Code. Vous avez déclaré l'état souhaité d'une ressource dans un fichier de configuration, et Terraform a géré la logique pour atteindre cet état. Les mêmes principes s'appliquent lors de la gestion d'infrastructures plus complexes, telles que des machines virtuelles, des réseaux et des bases de données dans le cloud.