Comment utiliser Terraform avec

Introduction

Terraform est un outil pour construire et gérer l'infrastructure de manière organisée. Vous pouvez l'utiliser pour gérer les Droplets de Linux-Console.net, les équilibreurs de charge, et même les entrées DNS, en plus d'une grande variété de services proposés par d'autres fournisseurs. Terraform utilise une interface en ligne de commande et peut fonctionner depuis votre ordinateur de bureau ou un serveur distant.

Terraform fonctionne en lisant des fichiers de configuration qui décrivent les composants qui composent votre environnement d'application ou votre centre de données. En fonction de la configuration, il génère un plan d'exécution qui décrit ce qu'il fera pour atteindre l'état désiré. Vous utilisez ensuite Terraform pour exécuter ce plan afin de construire l'infrastructure. Lorsque des modifications de la configuration se produisent, Terraform peut générer et exécuter des plans incrémentiels pour mettre à jour l'infrastructure existante vers l'état nouvellement décrit.

Dans ce tutoriel, vous allez installer Terraform et l'utiliser pour créer une infrastructure sur Linux-Console.net composée de deux serveurs Nginx équilibrés par un Load Balancer de Linux-Console.net. Ensuite, vous utiliserez Terraform pour ajouter une entrée DNS sur Linux-Console.net qui pointe vers votre Load Balancer. Cela vous aidera à commencer à utiliser Terraform et vous donnera une idée de la manière dont vous pouvez l'utiliser pour gérer et déployer une infrastructure basée sur Linux-Console.net répondant à vos propres besoins.

Remarque : Ce tutoriel a été testé avec Terraform 1.1.3.

Prérequis

Pour compléter ce tutoriel, vous aurez besoin de :

Un compte Linux-Console.net. Si vous n'en avez pas, inscrivez-vous pour un nouveau compte.
Un jeton d'accès personnel Linux-Console.net, que vous pouvez créer via le panneau de configuration de Linux-Console.net. Les instructions pour le faire peuvent être trouvées à : Comment créer un jeton d'accès personnel.
Une clé SSH sans mot de passe ajoutée à votre compte Linux-Console.net, que vous pouvez créer en suivant Comment utiliser les clés SSH avec les Droplets de Linux-Console.net. Lorsque vous ajoutez la clé à votre compte, souvenez-vous du nom que vous lui donnez, car vous en aurez besoin dans ce tutoriel. (Pour que Terraform accepte le nom de votre clé, il doit commencer par une lettre ou un underscore et ne peut contenir que des lettres, des chiffres, des underscores et des traits d’union.)
Un domaine personnel pointait vers le serveur de noms de Linux-Console.net, ce que vous pouvez faire en suivant le tutoriel, Comment Pointer vers les Serveurs de Noms de Linux-Console.net Depuis les Bureaux d'Enregistrement de Domaines Courants.

Étape 1 — Installer Terraform

Terraform est un outil en ligne de commande que vous exécutez sur votre ordinateur de bureau ou sur un serveur distant. Pour l’installer, vous le téléchargez et le placez sur votre PATH afin de pouvoir l’exécuter dans n’importe quel répertoire sur lequel vous travaillez.

Tout d'abord, téléchargez le package approprié pour votre système d'exploitation et votre architecture depuis la page officielle des téléchargements. Si vous utilisez macOS ou Linux, vous pouvez télécharger Terraform avec curl.

Sur macOS, utilisez cette commande pour télécharger Terraform et le placer dans votre répertoire personnel :

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_darwin_amd64.zip

Sur Linux, utilisez cette commande :

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_linux_amd64.zip

Créez le répertoire ~/opt/terraform :

mkdir -p ~/opt/terraform

Ensuite, décompressez Terraform dans ~/opt/terraform en utilisant la commande unzip. Sur Ubuntu, vous pouvez installer unzip en utilisant apt :

sudo apt install unzip

Utilisez-le pour extraire l'archive téléchargée dans le répertoire ~/opt/terraform en exécutant :

unzip ~/terraform.zip -d ~/opt/terraform

Enfin, ajoutez ~/opt/terraform à votre variable d'environnement PATH afin que vous puissiez exécuter la commande terraform sans spécifier le chemin complet de l'exécutable.

Sur Linux, vous devrez redéfinir PATH dans .bashrc, qui s'exécute lorsqu'un nouveau shell s'ouvre. Ouvrez-le pour le modifier en exécutant :

nano ~/.bashrc

Remarque : Sur macOS, ajoutez le chemin au fichier .bash_profile si vous utilisez Bash, ou au fichier .zshrc si vous utilisez ZSH.

Pour ajouter le chemin de Terraform à votre PATH, ajoutez la ligne suivante à la fin du fichier :

export PATH=$PATH:~/opt/terraform

Enregistrez et fermez le fichier lorsque vous avez terminé.

Désormais, toutes vos nouvelles sessions de shell pourront trouver la commande terraform. Pour charger le nouveau PATH dans votre session actuelle, exécutez la commande suivante si vous utilisez Bash sur un système Linux :

. ~/.bashrc

Si vous utilisez Bash sur macOS, exécutez plutôt cette commande :

. .bash_profile

Si vous utilisez ZSH, exécutez cette commande :

. .zshrc

Pour vérifier que vous avez installé Terraform correctement, exécutez la commande terraform sans arguments :

terraform

Vous verrez une sortie similaire à la suivante :

Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  test          Experimental support for module integration testing
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the
                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

Ce sont les commandes que Terraform accepte. La sortie vous donne une brève description, et vous en apprendrez davantage à leur sujet tout au long de ce tutoriel.

Maintenant que Terraform est installé, configurons-le pour qu'il fonctionne avec les ressources de Linux-Console.net.

Étape 2 — Configuration de Terraform pour Linux-Console.net

Terraform prend en charge une variété de fournisseurs de services via des providers que vous pouvez installer. Chaque provider a ses propres spécifications, qui se traduisent généralement par l'API de son fournisseur de services respectif.

Le fournisseur Linux-Console.net permet à Terraform d'interagir avec l'API Linux-Console.net pour créer des infrastructures. Ce fournisseur prend en charge la création de diverses ressources Linux-Console.net, y compris les suivantes :

digitalocean_droplet : Droplets (serveurs)
digitalocean_loadbalancer : Équilibreurs de charge
digitalocean_domain : entrées de domaine DNS
digitalocean_record : enregistrements DNS

Terraform utilisera votre jeton d'accès personnel Linux-Console.net pour communiquer avec l'API Linux-Console.net et gérer les ressources de votre compte. Ne partagez pas cette clé avec d'autres et ne la mettez pas dans les scripts ni dans le contrôle de version. Exportez votre jeton d'accès personnel Linux-Console.net vers une variable d'environnement appelée DO_PAT en exécutant :

export DO_PAT="your_personal_access_token"

Cela facilitera son utilisation dans les commandes suivantes et le maintiendra séparé de votre code.

Remarque : Si vous allez travailler fréquemment avec Terraform et Linux-Console.net, ajoutez cette ligne à vos fichiers de configuration de shell en utilisant la même approche que celle que vous avez utilisée pour modifier votre variable d'environnement PATH à l'étape précédente.

Créez un répertoire qui stockera votre configuration d'infrastructure en exécutant la commande suivante :

mkdir ~/loadbalance

Accédez au répertoire nouvellement créé :

cd ~/loadbalance

Les configurations Terraform sont des fichiers texte qui se terminent par l'extension de fichier .tf. Ils sont lisibles par l'homme et prennent en charge les commentaires. (Terraform prend également en charge les fichiers de configuration au format JSON, mais ils ne seront pas abordés ici.) Terraform lira tous les fichiers de configuration dans votre répertoire de travail de manière déclarative, donc l'ordre des définitions de ressources et de variables n'a pas d'importance. Toute votre infrastructure peut exister dans un seul fichier de configuration, mais vous devriez séparer les fichiers de configuration par type de ressource pour maintenir la clarté.

La première étape pour construire une infrastructure avec Terraform est de définir le fournisseur que vous allez utiliser.

Pour utiliser le fournisseur Linux-Console.net avec Terraform, vous devez informer Terraform à son sujet et configurer le plugin avec les variables d'identification appropriées. Créez un fichier appelé provider.tf, qui stockera la configuration pour le fournisseur :

nano provider.tf

Ajoutez les lignes suivantes dans le fichier pour indiquer à Terraform que vous souhaitez utiliser le fournisseur Linux-Console.net, et indiquez à Terraform où le trouver :

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

Ensuite, définissez les variables suivantes dans le fichier afin de pouvoir les référencer dans le reste de vos fichiers de configuration :

do_token : votre jeton d'accès personnel Linux-Console.net.
pvt_key : emplacement de la clé privée, afin que Terraform puisse l'utiliser pour se connecter aux nouveaux Droplets et installer Nginx.

Vous passerez les valeurs de ces variables à Terraform lorsque vous l'exécuterez, plutôt que de coder en dur les valeurs ici. Cela rend la configuration plus portable.

Pour définir ces variables, ajoutez ces lignes au fichier :

...
variable "do_token" {}
variable "pvt_key" {}

Ensuite, ajoutez ces lignes pour configurer le fournisseur Linux-Console.net et spécifiez les informations d'identification de votre compte Linux-Console.net en assignant le do_token à l'argument token du fournisseur :

...
provider "digitalocean" {
  token = var.do_token
}

Enfin, vous voudrez que Terraform ajoute automatiquement votre clé SSH à tous les nouveaux Droplets que vous créez. Lorsque vous avez ajouté votre clé SSH à Linux-Console.net, vous lui avez donné un nom. Terraform peut utiliser ce nom pour récupérer la clé publique. Ajoutez ces lignes, en remplaçant terraform par le nom de la clé que vous avez fourni dans votre compte Linux-Console.net :

...
data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Votre fichier provider.tf terminé ressemblera à ceci :

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

variable "do_token" {}
variable "pvt_key" {}

provider "digitalocean" {
  token = var.do_token
}

data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Remarque : Définir la variable d'environnement TF_LOG à 1 permettra d'activer une journalisation détaillée de ce que Terraform tente de faire. Vous pouvez la définir en exécutant :

export TF_LOG=1

Initialisez Terraform pour votre projet en exécutant :

terraform init

Cela lira votre configuration et installera les plugins pour votre fournisseur. Vous verrez que cela est consigné dans la sortie :

Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Installing digitalocean/digitalocean v2.16.0...
- Installed digitalocean/digitalocean v2.16.0 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)

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.

Si vous vous retrouvez coincé et que Terraform ne fonctionne pas comme prévu, vous pouvez recommencer en supprimant le fichier terraform.tfstate et en détruisant manuellement les ressources qui ont été créées (par exemple, via le panneau de contrôle).

Terraform est maintenant configuré et peut être connecté à votre compte Linux-Console.net. À l'étape suivante, vous utiliserez Terraform pour définir un Droplet qui exécutera un serveur Nginx.

Étape 3 — Définir le premier serveur Nginx

Vous pouvez utiliser Terraform pour créer un Droplet Linux-Console.net et installer des logiciels sur le Droplet une fois qu'il est lancé. Dans cette étape, vous allez provisionner un seul Droplet Ubuntu 20.04 et installer le serveur web Nginx en utilisant Terraform.

Créez un nouveau fichier de configuration Terraform appelé www-1.tf, qui contiendra la configuration du Droplet :

nano www-1.tf

Insérez les lignes suivantes pour définir la ressource Droplet :

resource "digitalocean_droplet" "www-1" {
    image = "ubuntu-20-04-x64"
    name = "www-1"
    region = "nyc3"
    size = "s-1vcpu-1gb"
    ssh_keys = [
      data.digitalocean_ssh_key.terraform.id
    ]

Dans la configuration précédente, la première ligne définit une ressource digitalocean_droplet nommée www-1. Les lignes restantes spécifient les attributs du Droplet, y compris le centre de données dans lequel il sera hébergé et le slug qui identifie la taille du Droplet que vous souhaitez configurer. Dans ce cas, vous utilisez s-1vcpu-1gb, ce qui créera un Droplet avec un processeur et 1 Go de RAM. (Consultez ce tableau des tailles de slug pour voir les slugs disponibles que vous pouvez utiliser.)

La section ssh_keys spécifie une liste de clés publiques que vous souhaitez ajouter au Droplet. Dans ce cas, vous spécifiez la clé que vous avez définie dans provider.tf. Assurez-vous que le nom ici correspond au nom que vous avez spécifié dans provider.tf.

Lorsque vous exécutez Terraform contre l'API Linux-Console.net, il collectera diverses informations sur le Droplet, telles que ses adresses IP publiques et privées. Ces informations peuvent être utilisées par d'autres ressources de votre configuration.

Si vous vous demandez quels arguments sont requis ou optionnels pour une ressource Droplet, veuillez vous référer à la documentation officielle de Terraform : Spécification du Droplet de Linux-Console.net.

Pour configurer une connection que Terraform peut utiliser pour se connecter au serveur via SSH, ajoutez les lignes suivantes à la fin du fichier :

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

Ces lignes décrivent comment Terraform doit se connecter au serveur, afin que Terraform puisse se connecter via SSH pour installer Nginx. Notez l'utilisation de la variable de clé privée var.pvt_key — vous passerez sa valeur lors de l'exécution de Terraform.

Maintenant que vous avez configuré la connexion, configurez le provisionneur remote-exec, que vous utiliserez pour installer Nginx. Ajoutez les lignes suivantes à la configuration pour le faire :

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

Notez que les chaînes dans le tableau inline sont les commandes que l'utilisateur root exécutera pour installer Nginx.

Le fichier complété ressemble à ceci :

resource "digitalocean_droplet" "www-1" {
  image = "ubuntu-20-04-x64"
  name = "www-1"
  region = "nyc3"
  size = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.terraform.id
  ]
  
  connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }
  
  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # install nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Enregistrez le fichier et quittez l'éditeur. Vous avez défini le serveur et êtes prêt à le déployer, ce que vous allez faire maintenant.

Étape 4 — Utiliser Terraform pour créer le serveur Nginx

Votre configuration Terraform actuelle décrit un seul serveur Nginx. Vous allez maintenant déployer le Droplet exactement comme il est défini.

Exécutez la commande terraform plan pour voir le plan d'exécution, ou ce que Terraform tentera de faire pour construire l'infrastructure que vous avez décrite. Vous devrez spécifier les valeurs de votre jeton d'accès Linux-Console.net et le chemin vers votre clé privée, car votre configuration utilise ces informations pour accéder à votre Droplet afin d'installer Nginx. Exécutez la commande suivante pour créer un plan :

terraform plan \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Avertissement : La commande terraform plan prend en charge un paramètre -out pour enregistrer le plan. Cependant, le plan stockera les clés API, et Terraform ne chiffre pas ces données. Lorsque vous utilisez cette option, vous devriez envisager de chiffrer ce fichier si vous prévoyez de l’envoyer à d’autres personnes ou de le laisser au repos pendant une période prolongée.

Vous verrez une sortie similaire à ceci :

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:

  # digitalocean_droplet.www-1 will be created
  + resource "digitalocean_droplet" "www-1" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + graceful_shutdown    = false
      + 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                 = "www-1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "nyc3"
      + 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)
    }

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

───────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

La ligne + resource "digitalocean_droplet" "www-1" signifie que Terraform va créer une nouvelle ressource Droplet appelée www-1, avec les détails qui suivent. C’est exactement ce qui doit se passer, donc exécutez la commande terraform apply pour exécuter le plan actuel :

terraform apply \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Vous obtiendrez le même résultat qu'auparavant, mais cette fois, Terraform vous demandera si vous souhaitez continuer :

...
Plan: 1 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

Entrez yes et appuyez sur ENTRÉE. Terraform va provisionner votre Droplet :

digitalocean_droplet.www-1: Creating...

Après un certain temps, vous verrez Terraform installer Nginx avec le provisionneur remote-exec, puis le processus se terminera :

digitalocean_droplet.www-1: Provisioning with 'remote-exec'...

....

digitalocean_droplet.www-1: Creation complete after 1m54s [id=your_www-1_droplet_id]

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

Terraform a créé un nouveau Droplet appelé www-1 et y a installé Nginx. Si vous visitez l'adresse IP publique de votre nouveau Droplet, vous verrez l'écran d'accueil de Nginx. L'IP publique a été affichée lors de la création du Droplet, mais vous pouvez toujours la consulter en regardant l'état actuel de Terraform. Terraform met à jour le fichier d'état terraform.tfstate à chaque fois qu'il exécute un plan ou actualise son état.

Pour afficher l'état actuel de votre environnement, utilisez la commande suivante :

terraform show terraform.tfstate

Cela vous montrera l'adresse IP publique de votre Droplet.

resource "digitalocean_droplet" "www-1" {
    backups              = false
    created_at           = "..."
    disk                 = 25
    id                   = "your_www-1_droplet_id"
    image                = "ubuntu-20-04-x64"
    ipv4_address         = "your_www-1_server_ip"
    ipv4_address_private = "10.128.0.2"
    ...

Accédez à http://votre_ip_serveur_www-1 dans votre navigateur pour vérifier que votre serveur Nginx fonctionne.

Note : Si vous modifiez votre infrastructure en dehors de Terraform, votre fichier d'état sera obsolète. Si vos ressources sont modifiées en dehors de Terraform, vous devrez actualiser le fichier d'état pour le mettre à jour. Cette commande permettra de récupérer les informations actualisées sur les ressources depuis votre(s) fournisseur(s) :

terraform refresh \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

À cette étape, vous avez déployé le Droplet que vous avez décrit dans Terraform. Vous allez maintenant en créer un deuxième.

Étape 5 — Création du deuxième serveur Nginx

Maintenant que vous avez décrit un serveur Nginx, vous pouvez en ajouter un second rapidement en copiant le fichier de configuration du serveur existant et en remplaçant le nom et le nom d'hôte de la ressource Droplet.

Vous pouvez le faire manuellement, mais il est plus rapide d'utiliser la commande sed pour lire le fichier www-1.tf, remplacer toutes les occurrences de www-1 par www-2, et créer un nouveau fichier appelé www-2.tf. Voici la commande sed pour le faire :

sed 's/www-1/www-2/g' www-1.tf > www-2.tf

Vous pouvez en apprendre davantage sur sed en visitant Using sed.

Exécutez terraform plan à nouveau pour prévisualiser les modifications que Terraform apportera :

terraform plan \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

La sortie montre que Terraform va créer le deuxième serveur, www-2 :

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:

  # digitalocean_droplet.www-2 will be created
  + resource "digitalocean_droplet" "www-2" {
      + 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                 = "www-2"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "nyc3"
      + 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)
    }

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

Exécutez terraform apply à nouveau pour créer le deuxième Droplet :

terraform apply \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Comme précédemment, Terraform vous demandera de confirmer si vous souhaitez continuer. Examinez à nouveau le plan et tapez yes pour continuer.

Après un certain temps, Terraform créera le nouveau serveur et affichera les résultats :

digitalocean_droplet.www-2: Creation complete after 1m47s [id=your_www-2_droplet_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Terraform a créé le nouveau serveur, tout en n'altérant pas celui existant. Vous pouvez répéter cette étape pour ajouter des serveurs Nginx supplémentaires.

Maintenant que vous avez deux Droplets exécutant Nginx, vous allez définir et déployer un équilibreur de charge pour répartir le trafic entre eux.

Étape 6 — Création du répartiteur de charge

Vous utiliserez un équilibreur de charge Linux-Console.net, pris en charge par le fournisseur officiel Terraform, pour diriger le trafic entre les deux serveurs web.

Créez un nouveau fichier de configuration Terraform appelé loadbalancer.tf :

nano loadbalancer.tf

Ajoutez les lignes suivantes pour définir le répartiteur de charge :

resource "digitalocean_loadbalancer" "www-lb" {
  name = "www-lb"
  region = "nyc3"

  forwarding_rule {
    entry_port = 80
    entry_protocol = "http"

    target_port = 80
    target_protocol = "http"
  }

  healthcheck {
    port = 22
    protocol = "tcp"
  }

  droplet_ids = [digitalocean_droplet.www-1.id, digitalocean_droplet.www-2.id ]
}

La définition du Load Balancer spécifie son nom, le centre de données dans lequel il sera situé, les ports sur lesquels il doit écouter pour équilibrer le trafic, la configuration pour le contrôle de l'état, et les identifiants des Droplets qu'il doit équilibrer, que vous récupérez en utilisant des variables Terraform. Enregistrez et fermez le fichier.

Exécutez à nouveau la commande terraform plan pour examiner le nouveau plan d'exécution :

terraform plan \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Vous verrez plusieurs lignes de sortie, y compris les lignes suivantes :

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

  # digitalocean_loadbalancer.www-lb will be created
  + resource "digitalocean_loadbalancer" "www-lb" {
      + algorithm                        = "round_robin"
      + disable_lets_encrypt_dns_records = false
      + droplet_ids                      = [
          + ...,
          + ...,
        ]
      + enable_backend_keepalive         = false
      + enable_proxy_protocol            = false
      + id                               = (known after apply)
      + ip                               = (known after apply)
      + name                             = "www-lb"
      + redirect_http_to_https           = false
      + region                           = "nyc3"
      + size_unit                        = (known after apply)
      + status                           = (known after apply)
      + urn                              = (known after apply)
      + vpc_uuid                         = (known after apply)

      + forwarding_rule {
          + certificate_id   = (known after apply)
          + certificate_name = (known after apply)
          + entry_port       = 80
          + entry_protocol   = "http"
          + target_port      = 80
          + target_protocol  = "http"
          + tls_passthrough  = false
        }

      + healthcheck {
          + check_interval_seconds   = 10
          + healthy_threshold        = 5
          + port                     = 22
          + protocol                 = "tcp"
          + response_timeout_seconds = 5
          + unhealthy_threshold      = 3
        }

      + sticky_sessions {
          + cookie_name        = (known after apply)
          + cookie_ttl_seconds = (known after apply)
          + type               = (known after apply)
        }
    }

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

Cela signifie que les Droplets www-1 et www-2 existent déjà, et que Terraform va créer le Load Balancer www-lb.

Exécutez terraform apply pour créer le Load Balancer :

terraform apply \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Encore une fois, Terraform vous demandera de revoir le plan. Approuvez le plan en saisissant yes pour continuer.

Une fois que vous l’aurez fait, vous verrez une sortie contenant les lignes suivantes, tronquées pour des raisons de brièveté :

...
digitalocean_loadbalancer.www-lb: Creating...
...
digitalocean_loadbalancer.www-lb: Creation complete after 1m18s [id=your_load_balancer_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Utilisez terraform show terraform.tfstate pour localiser l'adresse IP de votre équilibreur de charge :

terraform show terraform.tfstate

Vous trouverez l'IP sous l'entrée www-lb :

...
# digitalocean_loadbalancer.www-lb:
resource "digitalocean_loadbalancer" "www-lb" {
    algorithm                = "round_robin"
    disable_lets_encrypt_dns_records = false
    droplet_ids              = [
        your_www-1_droplet_id,
        your_www-2_droplet_id,
    ]
    enable_backend_keepalive = false
    enable_proxy_protocol    = false
    id                       = "your_load_balancer_id"
    ip                       = "your_load_balancer_ip"
    name                     = "www-lb"
    ...

Accédez à http://votre_ip_de_équilibreur_de_charge dans votre navigateur et vous verrez un écran de bienvenue Nginx car le répartiteur de charge envoie le trafic à l'un des deux serveurs Nginx.

Vous allez maintenant apprendre à configurer le DNS pour votre compte Linux-Console.net en utilisant Terraform.

Étape 7 — Création de domaines et d'enregistrements DNS

En plus des Droplets et des Load Balancers, Terraform peut également créer des domaines DNS et enregistrer des domaines. Par exemple, si vous souhaitez pointer votre domaine vers votre Load Balancer, vous pouvez écrire la configuration décrivant cette relation.

Remarque : Utilisez votre propre nom de domaine unique, sinon Terraform ne pourra pas déployer les ressources DNS. Assurez-vous que votre domaine est dirigé vers les serveurs de noms Linux-Console.net.

Créez un nouveau fichier pour décrire votre DNS :

nano domain_root.tf

Ajoutez la ressource de domaine suivante, en remplaçant your_domain par votre nom de domaine :

resource "digitalocean_domain" "default" {
   name = "your_domain"
   ip_address = digitalocean_loadbalancer.www-lb.ip
}

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vous pouvez également ajouter un enregistrement CNAME qui pointe www.votre_domaine vers votre_domaine. Créez un nouveau fichier pour l'enregistrement CNAME :

nano domain_cname.tf

Ajoutez ces lignes au fichier :

resource "digitalocean_record" "CNAME-www" {
  domain = digitalocean_domain.default.name
  type = "CNAME"
  name = "www"
  value = "@"
}

Enregistrez et fermez le fichier lorsque vous avez terminé.

Pour ajouter les entrées DNS, exécutez terraform plan suivi de terraform apply, comme pour les autres ressources.

Accédez à votre nom de domaine et vous verrez un écran de bienvenue Nginx car le domaine pointe vers le Load Balancer, qui envoie le trafic vers l'un des deux serveurs Nginx.

Étape 8 — Détruire votre infrastructure

Bien que rarement utilisé dans les environnements de production, Terraform peut également détruire l'infrastructure qu'il a créée. Cela est principalement utile dans les environnements de développement qui sont déployés et détruits plusieurs fois.

Tout d'abord, créez un plan d'exécution pour détruire l'infrastructure en utilisant terraform plan -destroy :

terraform plan -destroy -out=terraform.tfplan \

  -var "do_token=${DO_PAT}" \

  -var "pvt_key=$HOME/.ssh/id_rsa"

Terraform produira un plan avec des ressources marquées en rouge et préfixées d'un signe moins, indiquant qu'il supprimera les ressources dans votre infrastructure.

Ensuite, utilisez terraform apply pour exécuter le plan :

terraform apply terraform.tfplan

Terraform procédera à la destruction des ressources, comme indiqué dans le plan généré.

Conclusion

Dans ce tutoriel, vous avez utilisé Terraform pour construire une infrastructure web équilibrée sur Linux-Console.net, avec deux serveurs web Nginx fonctionnant derrière un équilibreur de charge Linux-Console.net. Vous savez comment créer et détruire des ressources, afficher l'état actuel et utiliser Terraform pour configurer les entrées DNS.

Maintenant que vous comprenez comment Terraform fonctionne, vous pouvez créer des fichiers de configuration qui décrivent une infrastructure serveur pour vos propres projets. L'exemple de ce tutoriel est un bon point de départ qui montre comment vous pouvez automatiser le déploiement de serveurs. Si vous utilisez déjà des outils de provisionnement, vous pouvez les intégrer avec Terraform pour configurer les serveurs dans le cadre de leur processus de création plutôt que d'utiliser la méthode de provisionnement utilisée dans ce tutoriel.

Terraform a beaucoup plus de fonctionnalités, et peut fonctionner avec d'autres fournisseurs. Consultez la documentation officielle de Terraform pour en savoir plus sur la manière dont vous pouvez utiliser Terraform pour améliorer votre propre infrastructure.

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, depuis l'installation de Terraform pour la première fois jusqu'à la gestion de projets complexes.