Comment utiliser Terraform avec DigitalOcean

Introduction

Terraform est un outil pour construire et gérer l’infrastructure de manière organisée. Vous pouvez l’utiliser pour gérer des droplets DigitalOcean, des équilibreurs de charge et même des 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 s’exécuter depuis votre bureau ou un serveur distant.

Terraform fonctionne en lisant des fichiers de configuration qui décrivent les composants de votre environnement d’application ou de 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 souhaité. 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 le nouvel état décrit.

Dans ce tutoriel, vous installerez Terraform et l’utiliserez pour créer une infrastructure sur DigitalOcean composée de deux serveurs Nginx équilibrés par un équilibreur de charge DigitalOcean. Ensuite, vous utiliserez Terraform pour ajouter une entrée DNS sur DigitalOcean qui pointe vers votre équilibreur de charge. Cela vous aidera à démarrer avec l’utilisation de Terraform et vous donnera une idée de comment vous pouvez l’utiliser pour gérer et déployer une infrastructure basée sur DigitalOcean qui répond à vos propres besoins.

Prérequis

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

• A DigitalOcean account. If you do not have one, sign up for a new account.
• A DigitalOcean Personal Access Token, which you can create via the DigitalOcean control panel. Instructions to do that can be found at: How to Create a Personal Access Token.
• A password-less SSH key added to your DigitalOcean account, which you can create by following How To Use SSH Keys with DigitalOcean Droplets. When you add the key to your account, remember the name you give it, as you’ll need it in this tutorial. (For Terraform to accept the name of your key, it must start with a letter or underscore and may contain only letters, digits, underscores, and dashes.)
• A personal domain pointed to DigitalOcean’s nameserver, which you can do by following the tutorial, How To Point to DigitalOcean Nameservers From Common Domain Registrars.

Étape 1 — Installation de Terraform

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

Tout d’abord, téléchargez le paquet approprié pour votre système d’exploitation et votre architecture à partir de la page de téléchargement officielle. Si vous êtes sur 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-la 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 de pouvoir exécuter la commande terraform sans spécifier le chemin complet vers 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 l’éditer en exécutant :

nano ~/.bashrc

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 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 à ce qui suit :

Output
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 plus à leur sujet tout au long de ce tutoriel.

Maintenant que Terraform est installé, configurons-le pour qu’il fonctionne avec les ressources de DigitalOcean.

Étape 2 — Configuration de Terraform pour DigitalOcean

Terraform prend en charge divers fournisseurs de services via les fournisseurs que vous pouvez installer. Chaque fournisseur a ses propres spécifications, qui correspondent généralement à l’API de son fournisseur de services respectif.

Le fournisseur DigitalOcean permet à Terraform d’interagir avec l’API DigitalOcean pour construire une infrastructure. Ce fournisseur prend en charge la création de diverses ressources DigitalOcean, notamment 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 DigitalOcean pour communiquer avec l’API DigitalOcean et gérer les ressources de votre compte. Ne partagez pas cette clé avec d’autres personnes et gardez-la hors des scripts et du contrôle de version. Exportez votre jeton d’accès personnel DigitalOcean 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 ultérieures et le gardera séparé de votre code.

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

mkdir ~/loadbalance

Naviguez vers le 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 devez 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 DigitalOcean avec Terraform, vous devez informer Terraform à ce sujet et configurer le plugin avec les variables d’identification appropriées. Créez un fichier appelé provider.tf, qui stockera la configuration du fournisseur :

nano provider.tf

Ajoutez les lignes suivantes dans le fichier pour indiquer à Terraform que vous souhaitez utiliser le fournisseur DigitalOcean, 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 DigitalOcean.
• 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 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 DigitalOcean et spécifiez les informations d’identification de votre compte DigitalOcean 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 à tout nouveau Droplet que vous créez. Lorsque vous avez ajouté votre clé SSH à DigitalOcean, 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 DigitalOcean :

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

Votre fichier provider.tf complet 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.

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 cela dans la sortie du journal :

Output
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 trouvez 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 DigitalOcean. À l’étape suivante, vous utiliserez Terraform pour définir un Droplet qui exécutera un serveur Nginx.

Étape 3 — Définition du Premier Serveur Nginx

Vous pouvez utiliser Terraform pour créer un Droplet DigitalOcean et installer des logiciels sur le Droplet une fois qu’il est opérationnel. À cette étape, vous provisionnerez un seul Droplet Ubuntu 20.04 et installerez le serveur web Nginx à l’aide de 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. Le reste des lignes spécifie les attributs du Droplet, y compris le centre de données dans lequel il résidera et le slug qui identifie la taille du Droplet que vous souhaitez configurer. Dans ce cas, vous utilisez s-1vcpu-1gb, qui créera un Droplet avec un CPU et 1 Go de RAM. (Visitez cette table de slug de taille 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 DigitalOcean, 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 dans votre configuration.

Si vous vous demandez quels arguments sont nécessaires ou facultatifs pour une ressource Droplet, veuillez vous référer à la documentation officielle de Terraform : Spécification du Droplet DigitalOcean.

Pour configurer une connexion 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 en passerez la 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 faire exactement cela :

...
provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # installer 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 complet 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",
      # installer 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 ferez maintenant.

Étape 4 — Utilisation de 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 tel qu’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 DigitalOcean 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" 

Vous verrez une sortie similaire à ceci :

Output
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 sera créé
  + 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 créera une nouvelle ressource Droplet appelée www-1, avec les détails qui suivent. C’est exactement ce qui devrait se passer, alors 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 la même sortie qu’auparavant, mais cette fois, Terraform vous demandera si vous voulez continuer :

Output
...
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 ENTER. Terraform provisionnera votre Droplet :

Output
digitalocean_droplet.www-1: Creating...

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

Output
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 a installé Nginx dessus. Si vous visitez l’adresse IP publique de votre nouveau Droplet, vous verrez l’écran d’accueil de Nginx. L’adresse 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.

Output
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"
    ...

Naviguez vers http://your_www-1_server_ip dans votre navigateur pour vérifier que votre serveur Nginx fonctionne.

terraform refresh \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Dans 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 deuxième 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, substituer toutes les occurrences de www-1 par www-2, et créer un nouveau fichier appelé www-2.tf. Voici la commande sed pour cela :

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

Vous pouvez en savoir plus sur sed en visitant Utilisation de sed.

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

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 :

Output
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 sera créé
  + 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 à nouveau la commande terraform apply 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 que vous souhaitez continuer. Revoyez le plan encore une fois et tapez yes pour continuer.

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

Output
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, sans modifier 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 définirez et déploierez un équilibreur de charge pour répartir le trafic entre eux.

Étape 6 — Création de l’équilibreur de charge

Vous utiliserez un Équilibreur de Charge DigitalOcean, que le fournisseur Terraform officiel prend en charge, pour router 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 l’équilibreur 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 de l’équilibreur de charge spécifie son nom, le centre de données dans lequel il se trouvera, les ports sur lesquels il doit écouter pour équilibrer le trafic, la configuration pour la vérification de l’état de santé, et les IDs des Droplets qu’il devrait é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:

Output
...
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 sera créé
  + 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 Terraform créera le Load Balancer www-lb.

Exécutez terraform apply pour construire 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 entrant 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é:

Output
...
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 Load Balancer:

terraform show terraform.tfstate

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

Output
...
# 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"
    ...

Naviguez vers http://votre_adresse_ip_du_load_balancer dans votre navigateur et vous verrez un écran de bienvenue Nginx car le Load Balancer envoie du trafic vers l’un des deux serveurs Nginx.

Vous apprendrez maintenant comment configurer le DNS pour votre compte DigitalOcean en utilisant Terraform.

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

En plus des gouttelettes et des équilibreurs de charge, Terraform peut également créer des domaines DNS et des enregistrements de domaine. Par exemple, si vous souhaitez pointer votre domaine vers votre équilibreur de charge, vous pouvez écrire la configuration décrivant cette relation.

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

nano domain_root.tf

Ajoutez la ressource de domaine suivante, en remplaçant votre_domaine 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 l’équilibreur de charge, qui envoie du trafic à l’un des deux serveurs Nginx.

Étape 8 — Destruction de votre infrastructure

Bien que peu 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 de 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 DigitalOcean, avec deux serveurs web Nginx fonctionnant derrière un équilibreur de charge DigitalOcean. Vous savez comment créer et détruire des ressources, consulter l’état actuel et utiliser Terraform pour configurer des entrées DNS.

Maintenant que vous comprenez comment fonctionne Terraform, vous pouvez créer des fichiers de configuration décrivant une infrastructure de 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 à Terraform pour configurer les serveurs dans le cadre de leur processus de création, au lieu d’utiliser la méthode de provisionnement utilisée dans ce tutoriel.

Terraform dispose de nombreuses fonctionnalités supplémentaires 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 plusieurs sujets Terraform, de l’installation de Terraform pour la première fois à la gestion de projets complexes.