Comment Structurer un Projet Terraform

Tutoriels

Introduction

La structuration appropriée des projets Terraform en fonction de leurs cas d’utilisation et de leur complexité perçue est essentielle pour assurer leur maintien et leur extensibilité dans les opérations quotidiennes. Une approche systématique de l’organisation correcte des fichiers de code est nécessaire pour s’assurer que le projet demeure scalable pendant la déploiement et utilisable pour vous et votre équipe.

Dans ce tutoriel, vous allez apprendre à structurer les projets Terraform en fonction de leur but général et de leur complexité. Ensuite, vous créerez un projet avec une structure simple en utilisant les fonctionnalités plus communes de Terraform : les variables, les valeurs locales, les sources de données et les fournisseurs. Enfin, votre projet déployera un serveur Ubuntu 20.04 (Droplet) sur DigitalOcean, installera un serveur Web Apache et pointera votre domaine vers le serveur Web.

Prérequis

Un jeton d’accès personnel à DigitalOcean, que vous pouvez créer via le panneau de contrôle de DigitalOcean. Vous pouvez trouver des instructions dans les documents produit de DigitalOcean, dans la rubrique Comment Créer un Jeton d’Accès Personnel.
Une clé SSH ajoutée à votre compte DigitalOcean sans mot de passe, que vous pouvez créer en suivant Comment utiliser les clés SSH avec les instances DigitalOcean.
Terraform installé sur votre machine locale. Pour des instructions selon votre système d’exploitation, consultez Étape 1 du tutoriel Comment Utiliser Terraform avec DigitalOcean.
Python 3 est installé sur votre machine locale. Vous pouvez accomplir l’étape 1 de Comment installer et configurer un environnement de développement local pour Python 3 pour votre système d’exploitation.
Un nom de domaine enregistré ajouté à votre compte DigitalOcean. Pour des instructions sur comment faire cela, visitez les documents officiels.

Remarque : Cet tutoriel a été testé avec Terraform 1.0.2.

Structure du projet Terraform

Dans cette section, vous apprendrez ce que Terraform considère comme un projet, comment vous pouvez organiser le code de l’infrastructure et quand choisir chaque approche. Vous apprendrez également sur les espaces de travail de Terraform, ce qu’ils font, et comment Terraform stocke l’état.

Un ressource est une entité d’une service en ligne (tel que un serveur DigitalOcean) déclarée dans le code de Terraform qui est créée selon les propriétés spécifiées et inférées. Plusieurs ressources forment une infrastructure avec leurs connexions mutuelles. Plusieurs ressources forment une infrastructure avec leurs connexions mutuelles.

Terraform utilise une langue de programmation spéciale pour définir l’infrastructure, appelée Langage de configuration Hashicorp (HCL). Le code HCL est généralement stocké dans des fichiers avec l’extension tf. Un projet Terraform consiste dans tout répertoire qui contient des fichiers tf et qui a été initialisé avec la commande init, qui configure les caches de Terraform et le statut local.

Le état de Terraform est le mécanisme par lequel il garde trace des ressources qui sont effectivement déployées dans le nuage. L’état est stocké dans des arrières-plan (localement sur le disque ou en cloud de stockage de fichiers ou logiciel spécial de gestion d’état). Vous pouvez lire plus sur différents arrières-plans dans la documentation de Terraform.

Les espaces de travail de projets vous permettent d’avoir plusieurs états dans le même back-end, liés à la même configuration. Cela vous permet de déployer plusieurs instances distinctes du même infrastructuration. Chaque projet commence avec un espace de travail nommé default. Ce sera utilisé si vous ne créez pas explicitement ou n’utilisez pas une autre.

Les modules en Terraform (analogues aux bibliothèques dans d’autres langages de programmation) sont des conteneurs de code paramétriqués qui contiennent plusieurs déclarations de ressources. Ils permettent d’abstraire une partie commune de votre infrastructure et de l’utiliser plus tard avec des entrées différentes.

Un projet Terraform peut également inclure des fichiers externes de code pour une utilisation dynamique des données d’entrée, qui peuvent parser les sorties JSON d’une commande CLI et les offrir pour une utilisation dans les déclarations de ressources. Dans ce tutoriel, vous allez faire ceci avec un script Python.

Après avoir compris qu’un projet Terraform se compose, revoyons deux approches générales pour structurer un projet Terraform.

Structure simple

Une structure simple convient aux petits projets et aux projets d’essai, avec quelques ressources de types variés et des variables. Elle comporte quelques fichiers de configuration, généralement un par type de ressource (ou plus si ils sont des helpers accompagnant un principal), et aucun module personnalisé, car la plupart des ressources sont uniques et il n’y en a pas assez pour être généralisées et réutilisées. Suite à cela, la majeure partie du code est stockée dans le même répertoire, côte à côte. Ces projets ont souvent quelques variables (comme une clé API pour accéder au cloud) et peuvent utiliser des entrées de données dynamiques et d’autres fonctionnalités de Terraform et HCL, bien que cela ne soit pas prononcé.

À titre d’exemple de la structure de fichiers de cette approche, voici à quoi ressemblera le projet que vous construirez dans ce tutoriel à la fin :

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Comme ce projet déploiera un serveur web Apache Droplet et configurera des enregistrements DNS, les définitions des variables de projet, le fournisseur Terraform DigitalOcean, le Droplet et les enregistrements DNS seront stockés dans leurs fichiers respectifs. Les versions minimales requises de Terraform et du fournisseur DigitalOcean seront spécifiées dans versions.tf, tandis que le script Python qui générera un nom pour le Droplet (et sera utilisé comme source de données dynamique dans data-sources.tf) sera stocké dans le répertoire external, pour le séparer du code HCL.

Structure Complexe

Contrairement à une structure simple, cette approche convient aux grands projets, avec des sous-repertoires clairement définis contenant plusieurs modules de complexité variables, en dehors du code habituel. Ces modules peuvent dépendre les uns des autres. Associée aux systèmes de contrôle de version, ces projets peuvent faire un usage intensif des espaces de travail. Cette approche convient aux grands projets gérant plusieurs applications, tout en réutilisant le code dans la mesure du possible.

Les instances d’infrastructure de développement, de staging, de contrôle qualité et de production peuvent également être hébergées sous le même projet dans des répertoires différents en s’appuyant sur des modules communs, ce qui élimine le code en double et fait du projet la source centrale de vérité. Voici la structure de fichiers d’un projet d’exemple avec une structure plus complexe, contenant plusieurs applications de déploiement, des modules Terraform et des environnements cloud cibles :

.
└── tf/
    ├── modules/
    │   ├── network/
    │   │   ├── main.tf
    │   │   ├── dns.tf
    │   │   ├── outputs.tf
    │   │   └── variables.tf
    │   └── spaces/
    │       ├── main.tf
    │       ├── outputs.tf
    │       └── variables.tf
    └── applications/
        ├── backend-app/
        │   ├── env/
        │   │   ├── dev.tfvars
        │   │   ├── staging.tfvars
        │   │   ├── qa.tfvars
        │   │   └── production.tfvars
        │   └── main.tf
        └── frontend-app/
            ├── env/
            │   ├── dev.tfvars
            │   ├── staging.tfvars
            │   ├── qa.tfvars
            │   └── production.tfvars
            └── main.tf

Cette approche est explorée plus en détail dans la série Comment gérer l’infrastructure avec Terraform.

Vous savez maintenant ce qu’est un projet Terraform, comment le structurer au mieux selon la complexité perçue, et le rôle des espaces de travail Terraform. Dans les étapes suivantes, vous créerez un projet avec une structure simple qui fournira un Droplet avec un serveur web Apache installé et des enregistrements DNS configurés pour votre domaine. Vous initialiserez d’abord votre projet avec le fournisseur DigitalOcean et les variables, puis vous définirez le Droplet, une source de données dynamique pour fournir son nom, et un enregistrement DNS pour le déploiement.

Étape 1 — Configuration de votre projet initial

Dans cette section, vous ajouteriez le fournisseur DigitalOcean pour Terraform à votre projet, définiriez les variables de projet et déclareriez une instance de fournisseur DigitalOcean, ce qui permettra à Terraform de se connecter à votre compte.

Commencez par créer un dossier pour votre projet Terraform avec la commande suivante :

mkdir ~/apache-droplet-terraform

Naviguez vers-le :

cd ~/apache-droplet-terraform

Puisque ce projet suivra une approche de structure simple, vous stockeriez le fournisseur, les variables, le code pour le Droplet et le record DNS dans des fichiers séparés, conformément à la structure de fichiers de la section précédente. Premièrement, vous devez ajouter le fournisseur DigitalOcean pour Terraform à votre projet en tant que fournisseur requis.

Créez un fichier nommé versions.tf et ouvrez-le en édition en exécutant :

nano versions.tf

Ajoutez les lignes suivantes :

~/apache-droplet-terraform/versions.tf

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

Dans ce bloc terraform, vous listez les fournisseurs requis (DigitalOcean, version 2.x). Lorsque vous avez terminé, enregistrez et fermez le fichier.

Ensuite, définissez les variables que votre projet exposera dans le fichier variables.tf, en suivant l’approche de stockage des types de ressources différents dans des fichiers de code séparés :

nano variables.tf

Ajoutez les variables suivantes :

~/apache-droplet-terraform/variables.tf

variable "do_token" {}
variable "domain_name" {}

Enregistrez et fermezz le fichier.

La variable do_token contiendra votre jeton d’accès personnel à DigitalOcean et domain_name spécifiera le nom de domaine souhaité. Le Droplet déployé aura automatiquement installé la clé SSH identifiée par l’empreinte SSH.

Ensuite, définissons l’instance du fournisseur DigitalOcean pour ce projet. Vous la mettrez dans un fichier nommé provider.tf. Créez-le et ouvrez-le pour l’édition en exécutant :

nano provider.tf

Ajoutez le fournisseur :

~/apache-droplet-terraform/provider.tf

provider "digitalocean" {
  token = var.do_token
}

Enregistrez et quittez le fichier lorsque vous avez terminé. Vous avez défini le fournisseur digitalocean, qui correspond au fournisseur requis que vous avez spécifié précédemment dans provider.tf, et mis son token à la valeur de la variable, qui sera fourni pendant l’exécution.

Au cours de cette étape, vous avez créé un dossier pour votre projet, demandé que le fournisseur DigitalOcean soit disponible, déclaré des variables de projet et configuré la connexion à une instance de fournisseur DigitalOcean pour utiliser un token d’authentification qui sera fourni plus tard. Vous allez maintenant écrire un script qui générera des données dynamiques pour vos définitions de projet.

Étape 2 — Création d’un script Python pour les données dynamiques

Avant de continuer à définir la Droplet, vous créez un script Python qui générera dynamiquement le nom de la Droplet et déclarerez une ressource de source de données pour le parser. Le nom sera généré en concaténant une chaîne constante (web) avec l’heure actuelle de la machine locale, exprimée dans le format UNIX epoch. Un script de nommage peut être utile lorsque plusieurs Droplets sont générés selon un schéma de nommage, afin de les différencier facilement.

Vous stockeriez le script dans un fichier nommé name-generator.py, dans un dossier nommé external. Premièrement, créez le dossier en exécutant :

mkdir external

Le dossier external se trouve à la racine de votre projet et contiendra les fichiers de code non-HCL, comme le script Python que vous allez écrire.

Créez name-generator.py dans external et ouvrez-le pour l’édition :

nano external/name-generator.py

Ajoutez le code suivant :

external/name-generator.py

import json, time

fixed_name = "web"
result = {
  "name": f"{fixed_name}-{int(time.time())}",
}

print(json.dumps(result))

Ce script Python importe les modules json et time, déclare un dictionnaire nommé result, et affecte la valeur de la clé name à une chaîne interpolée, qui combine fixed_name avec l’heure UNIX actuelle de la machine sur laquelle il est exécuté. Ensuite, result est converti en JSON et sorti sur stdout. La sortie sera différente à chaque exécution du script :

Output
{"name": "web-1597747959"}

Lorsque vous aurez fini, enregistrez et fermez le fichier.

Note : Les projets structurés importants et complexes exigent d’être plus attentifs à la manière dont les sources externes de données sont créées et utilisées, en particulier en termes de portabilité et de traitement des erreurs. Terraform attend que le programme exécuté écrit un message d’erreur lisible par l’humain sur stderr et qu’il quitte avec un statut non nul de manière gracieuse, ce qui n’est pas montré dans cette étape en raison de la simplicité de la tâche. De plus, il attend que le programme n’ait pas de effets secondaires, afin qu’il puisse être exécuté autant de fois que nécessaire.

Pour plus d’info sur ce que Terraform attend, visitez les documents officiels sur les sources de données.

Maintenant que le script est prêt, vous pouvez définir la source de données, qui extraira les données depuis le script. Vous stockerez la source de données dans un fichier nommé data-sources.tf à la racine de votre projet, selon l’approche de structure simple.

Créez-en un pour l’édition en exécutant :

nano data-sources.tf

Ajoutez la définition suivante :

~/apache-droplet-terraform/data-sources.tf

data "external" "droplet_name" {
  program = ["python3", "${path.module}/external/name-generator.py"]
}

Enregistrez et fermez le fichier.

Cette source de données s’appelle droplet_name et exécute le script name-generator.py en utilisant Python 3, qui se trouve dans le répertoire external que vous venez de créer. Elle parse automatiquement son sortie et fournit les données déserialisées sous son attribut result pour être utilisées dans d’autres définitions de ressources.

Avec la source de données déclarée, vous pouvez maintenant définir le Droplet sur lequel Apache sera exécuté.

Étape 3 — Définition du noyau

En cette étape, vous écrivez la définition du noyau de ressource et l’enregistrez dans un fichier de code spécialement dédié aux nuages, selon une approche de structure simplifiée. Son nom sera différent chaque fois qu’il est déployé en fonction des données dynamiques que vous avez juste créées.

Créez et ouvrez le fichier droplets.tf pour le modifier :

nano droplets.tf

Ajoutez les définitions suivantes pour la ressource de noyau :

~/apache-droplet-terraform/droplets.tf

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]
}

Vous déclarez d’abord une ressource de clé SSH DigitalOcean appelée ssh_key, qui va récupérer une clé de votre compte par son nom. Assurez-vous de remplacer le code indiqué avec le nom de votre clé SSH.

Ensuite, vous déclarez une ressource de nuage appelée web. Son nom actuel dans le nuage sera différent, car il est demandé à partir de la source de données droplet_name. Pour initialiser la ressource de nuage avec une clé SSH chaque fois qu’elle est déployée, l’ID de la ssh_key est passé au paramètre ssh_keys, ainsi DigitalOcean saura quelle clé appliquer.

Pour l’instant, cela constitue tout ce dont vous avez besoin dans le cadre de droplet.tf, alors savez-le et fermez le fichier lorsque vous avez terminé.

Vous écrirons maintenant la configuration pour le record DNS qui pointera votre domaine vers le noyau juste déclaré.

Étape 4 — Définition des enregistres DNS

La dernière étape du processus consiste à configurer les enregistres DNS qui pointent vers le Droplet de votre domaine.

Vous allez stocker la configuration DNS dans un fichier nommé dns.tf, car c’est une ressource différente des autres que vous avez créées lors des étapes précédentes. Créez et ouvrez-le pour l’éditer :

nano dns.tf

Ajoutez les lignes suivantes :

~/apache-droplet-terraform/dns.tf

resource "digitalocean_record" "www" {
  domain = var.domain_name
  type   = "A"
  name   = "@"
  value  = digitalocean_droplet.web.ipv4_address
}

Ceci déclare un enregistre DNS chez DigitalOcean au nom de votre domaine (passé en utilisant la variable), de type A. L’enregistre a un nom de @, qui est un lieu de passage pour le domaine lui-même et avec l’adresse IP du Droplet comme valeur. Vous pouvez remplacer la valeur name par quelque chose d’autre, ce qui résultera en création d’un sous-domaine.

Quand vous avez terminé, sauvegardez et fermez le fichier.

Maintenant que vous avez configuré le Droplet, la source de données générateurs de noms et un enregistre DNS, vous passeraz à la déployement du projet dans le nuage.

Étape 5 — Planification et application de la configuration

Dans cette section, vous initialiserez votre projet Terraform, le déployera dans la nuée et verifierez que tout a été fourni correctement.

Maintenant que l’infrastructure du projet est complète, il reste juste à initialiser le projet Terraform, le déployer dans la nuée et vérifier que tout a été fourni correctement.

terraform init

Pour cela, exédez les commandes suivantes :

OutputInitializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Finding latest version of hashicorp/external...
- Installing digitalocean/digitalocean v2.10.1...
- Installed digitalocean/digitalocean v2.10.1 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)
- Installing hashicorp/external v2.1.0...
- Installed hashicorp/external v2.1.0 (signed by HashiCorp)

Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Vous recevrez alors la sortie suivante :

Vous devez maintenant définir le nom dynamique du serveur et l’adresse DNS associée pour votre compte DigitalOcean.

export DO_PAT="your_do_api_token"
export DO_DOMAIN_NAME="your_domain"

Commencez par définir les variables d’environnement pour le nom du serveur, la marque-pages des clés SSH et votre jeton d’accès personnel, ainsi que vous n’auriez pas à copier les valeurs chaque fois que vous exécutez Terraform. Exédez les commandes suivantes, en remplaçant les valeurs soulignées :

Vous pouvez trouver votre jeton API dans le Panneau de contrôle de votre compte DigitalOcean.

terraform plan -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Exédez les commandes suivantes avec les valeurs passées en paramètres d’environnement :

OutputTerraform 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:

  L'output sera similaire au suivant :
  + resource "digitalocean_droplet" "web" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "web-1625908814"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "fra1"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

  # Le digitalocean_droplet.web sera créé
  + resource "digitalocean_record" "www" {
      + domain = "your_domain'"
      + fqdn   = (known after apply)
      + id     = (known after apply)
      + name   = "@"
      + ttl    = (known after apply)
      + type   = "A"
      + value  = (known after apply)
    }

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

# Le digitalocean_record.www sera créé

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Les lignes commençant par un signe vert « + » indiquent que Terraform va créer chacun des ressources qui suivent après que vous appliquez la configuration :

OutputPlan: 2 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: `yes`

Lancez la commande apply avec les valeurs passées en paramètres d’environnement :Vous serez alors invité à confirmer :Entrez oui, et Terraform déployera votre Serveur et la entrée DNS suivante :

Outputdigitalocean_droplet.web: Creating...
...
digitalocean_droplet.web: Creation complete after 33s [id=204432105]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110657456]

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

Terraform a enregistré maintenant les ressources déployées dans son état. Pour confirmer que les enregistres DNS et le Droplet ont été connectés avec succès, vous pouvez extraire l’adresse IP du Droplet de l’état local et vérifier si elle correspond aux enregistres publics DNS pour votre domaine. Exédez la commande suivante pour obtenir l’adresse IP du Droplet :

terraform show | grep "ipv4"

Vous recevrez l’adresse IP du Droplet :

Output
ipv4_address       = "your_Droplet_IP"
...

Vous pouvez vérifier les enregistres publics A en exécutant :

nslookup -type=a your_domain | grep "Address" | tail -1

L’output montrera l’adresse IP auquel pointe l’enregistre A :

Output
Address: your_Droplet_IP

Il s’agit de même, ce qui signifie que le Droplet et les enregistres DNS ont été fournis avec succès.

Pour que les changements des étapes suivantes se produisent, annulez les ressources déployées en exécutant :

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Quand vous êtes invité à entrer oui, faites-le.

En cette étape, vous avez créé votre infrastructure et l’application sur votre compte DigitalOcean. Vous allez maintenant modifier pour installer automatiquement le serveur Web Apache sur le Droplet déployé en utilisant les provisionneurs de Terraform.

Étape 6 – Exécution du code avec des provisionnaires

Maintenant, vous configurez l’installation du serveur Web Apache sur votre Droplet déployé en utilisant le provisionnaire remote-exec pour exécuter des commandes personnalisées.

Les fournisseurs de provisions Terraform peuvent être utilisés pour exécuter des actions spécifiques sur les ressources distantes créées (le fournisseur remote-exec) ou sur la machine locale où le code est exécuté (utilisation du fournisseur local-exec). Si un fournisseur échoue, la nœud sera marqué comme tainte dans l’état actuel, ce qui signifie qu’il sera détruit et recréé lors de la prochaine exécution.

Pour se connecter à un noeud provisionné de Droplet, Terraform nécessite la clé SSH privée configurée sur le Droplet. La meilleure façon de transmettre la location de la clé privée est d’utiliser des variables, donc ouvrez variables.tf pour enregistrer des modifications :

nano variables.tf

Ajoutez la ligne soulignée ci-dessous :

~/apache-droplet-terraform/variables.tf

variable "do_token" {}
variable "domain_name" {}
variable "private_key" {}

Vous avez maintenant ajouté une nouvelle variable, appelée private_key , à votre projet. Sauvez et fermez le fichier.

Après cela, vous ajoutez les déclarations de données de connexion et de fournisseurs distants au fichier de configuration de la Droplet. Ouvrez droplets.tf pour le modifier en exécutant :

nano droplets.tf

Développez les lignes soulignées ci-dessous :

~/apache-droplet-terraform/droplets.tf

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]

  connection {
    host        = self.ipv4_address
    user        = "root"
    type        = "ssh"
    private_key = file(var.private_key)
    timeout     = "2m"
  }

  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # Install Apache
      "apt update",
      "apt -y install apache2"
    ]
  }
}

Le bloc connection spécifie comment Terraform doit se connecter aux cibles de Droplet. Le bloc provisioner contient le tableau de commandes, dans le paramètre inline, que Terraform exécutera après la provisionnement. C’est-à-dire, mettre à jour le cache du gestionnaire de paquets et installer Apache. Sauvez et sortez quand vous êtes fini.

Vous pouvez également créer une variable d’environnement temporaire pour le chemin de la clé privée ainsi :

export DO_PRIVATE_KEY="private_key_location"

Note :
Le fichier de clé privée ainsi que tous les autres fichiers que vous souhaitez charger à l’intérieur du projet doivent être placés dans le projet. Voir la tutoriel Comment configurer une authentification basée sur une clé SSH sur un serveur Linux pour plus d’informations concernant la mise en place des clés SSH sur Ubuntu 20.04 ou d’autres distributions.

Essayez d’appliquer la configuration de nouveau :

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Entrez oui lorsque vous êtes invité. Vous recevrez une sortie similaire à celle précédente, mais suivie par une sortie longue provenant du fournisseur de provisions remote-exec.

Outputdigitalocean_droplet.web: Creating...
digitalocean_droplet.web: Still creating... [10s elapsed]
digitalocean_droplet.web: Still creating... [20s elapsed]
digitalocean_droplet.web: Still creating... [30s elapsed]
digitalocean_droplet.web: Provisioning with 'remote-exec'...
digitalocean_droplet.web (remote-exec): Connecting to remote host via SSH...
digitalocean_droplet.web (remote-exec):   Host: ...
digitalocean_droplet.web (remote-exec):   User: root
digitalocean_droplet.web (remote-exec):   Password: false
digitalocean_droplet.web (remote-exec):   Private key: true
digitalocean_droplet.web (remote-exec):   Certificate: false
digitalocean_droplet.web (remote-exec):   SSH Agent: false
digitalocean_droplet.web (remote-exec):   Checking Host Key: false
digitalocean_droplet.web (remote-exec): Connected!
...
digitalocean_droplet.web: Creation complete after 1m5s [id=204442200]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110666268]

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

Vous pouvez maintenant naviguer vers votre domaine dans un navigateur Web. Vous verrez la page d’accueil par défaut Apache.

Cela signifie que Apache a été installé avec succès et que Terraform a fourni tout correctement.

Pour détruire les ressources déployées, exédez la commande suivante et entrez oui lorsque vous êtes invité :

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Vous avez maintenant terminé un petit projet Terraform avec une structure simple qui déploie le serveur Web Apache sur un Droplet et configure les entrées DNS pour le domaine souhaité.

Conclusion

Vous avez appris deux approches générales pour structurer vos projets Terraform, selon leur complexité. En suivant l’approche de structuration simple et en utilisant le provisionneur remote-exec pour exécuter des commandes, vous avez ensuite déployé une Droplet exécutant Apache avec des enregistrements DNS pour votre domaine.

Pour référence, voici la structure de fichiers du projet que vous avez créé dans ce tutoriel :

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Les ressources que vous avez définies (la Droplet, l’enregistrement DNS et la source de données dynamiques, le fournisseur DigitalOcean et les variables) sont stockées chacune dans son propre fichier distinct, conformément à la structure de projet simple décrites dans la première section de ce tutoriel.

Pour plus d’information sur les provisionneurs Terraform et leurs paramètres, consultez la documentation officielle.

Ce tutoriel fait partie de la série Comment Gérer l’Infrastructure avec Terraform. La série couvre un certain nombre de sujets Terraform, allant de l’installation de Terraform pour la première fois à la gestion de projets complexes.

Source:
https://www.digitalocean.com/community/tutorials/how-to-structure-a-terraform-project