Comment importer les ressources DigitalOcean existantes dans Terraform

L’auteur a choisi le Free and Open Source Fund pour recevoir une donation dans le cadre du programme Write for DOnations.

Introduction

Terraform est un outil d’infrastructure as code (infrastructure en tant que code) créé par HashiCorp qui aide les développeurs à déployer, mettre à jour et supprimer les différentes ressources de leur infrastructure d’une manière efficace et plus évolutive.

Les développeurs peuvent utiliser Terraform pour organiser différents environnements, suivre les changements par le contrôle des versions et automatiser les travaux répétitifs pour limiter les erreurs humaines. Il offre également aux équipes un moyen de collaborer pour améliorer leur infrastructure grâce à des configurations partagées.

Dans ce tutoriel, vous allez importer les infrastructures DigitalOcean existantes dans Terraform. Au terme de ce tutoriel, vous serez en mesure d’utiliser Terraform pour toute votre infrastructure existante en plus de créer de nouvelles ressources.

Conditions préalables

• Un jeton d’accès personnel à DigitalOcean. Pour le créer, vous pouvez suivre le guide Comment créer un jeton d’accès personnel.
• Une Droplet DigitalOcean avec une étiquette. Vous pouvez utiliser le guide Comment créer une Droplet depuis le tableau de contrôle DigitalOcean.
• Un pare-feu Cloud DigitalOcean appliqué à votre Droplet. Vous pouvez utiliser le guide Comment créer des pare-feu.
• Le client de ligne de commande DigitalOcean installé sur votre machine locale en suivant les instructions d’installation à la page GitHub doctl. Vous pouvez lire le tutoriel Comment utiliser Doctl, le client de ligne de commande DigitalOcean officiel.

Étape 1 - Installation locale de Terraform

Au cours de cette première étape, vous allez installer Terraform sur votre machine locale. Cette étape détaille l’installation du binaire Linux. Si vous utilisez Windows ou Mac, vous pouvez consulter la page de téléchargement de Terraform sur le site web de Terraform.

Déplacez-vous vers le dossier dans lequel vous souhaitez télécharger Terraform sur votre machine locale, puis utilisez l’outil wget pour télécharger le binaire Terraform 0.12.12 :

cd /tmp
wget https://releases.hashicorp.com/terraform/0.12.12/terraform_0.12.12_linux_amd64.zip

Pour vérifier si la somme de contrôle du sha256 est la même que celle fournie sur le site web de Terraform, vous téléchargerez le fichier de la somme de contrôle avec la commande suivante :

wget -q https://releases.hashicorp.com/terraform/0.12.12/terraform_0.12.12_SHA256SUMS

Ensuite, exécutez la commande suivante pour vérifier les sommes de contrôle :

sha256sum -c --ignore-missing terraform_0.12.12_SHA256SUMS

Le fichier SHA256SUMS que vous avez téléchargé énumère les noms de fichiers et leurs hachages. Cette commande recherchera le même fichier terraform_0.12.12_SHA256SUMS localement, puis vérifiera que les hachages correspondent à l’aide de l’indicateur-c. Comme ce fichier a plus d’un nom de fichier et que sa plate-forme est répertoriée, vous utilisez l’indicateur--ignore-missing pour éviter les erreurs dans votre sortie parce que vous n’avez pas de copie des autres fichiers

Vous verrez une sortie semblable à ceci :

Output
terraform_0.12.12_linux_amd64.zip: OK

Utilisez unzip pour extraire le binaire :

sudo unzip terraform_0.12.12_linux_amd64.zip -d /usr/local/bin/

Vérifiez maintenant si Terraform est installé correctement en vérifiant la version :

terraform version

Vous verrez une sortie semblable à ce qui suit :

Output
Terraform v0.12.12

Vous avez installé Terraform sur votre machine locale, vous allez maintenant préparer les fichiers de configuration.

Étape 2 - Préparation des fichiers de configuration Terraform

Dans cette étape, vous allez importer vos ressources existantes dans Terraform en créant un répertoire de projet et en écrivant des fichiers de configuration. Puisque Terraform ne supporte pas la génération de configurations à partir de la commande import pour le moment, vous devez créer ces configurations manuellement.

Exécutez la commande suivante pour créer votre répertoire de projet :

mkdir -p do_terraform_import

Ensuite, entrez dans ce répertoire avec :

cd do_terraform_import

Dans cette étape, vous allez créer trois fichiers supplémentaires qui contiendront les configurations requises. La structure de votre répertoire pour ce projet ressemblera à ceci :

├── digitalocean_droplet.tf
├── digitalocean_firewall.tf
└── provider.tf

Pour commencer, vous allez créer le fichier provider.tf pour définir votre jeton d’accès DigitalOcean comme une variable d’environnement au lieu de le coder en dur dans votre configuration.

Outre votre jeton d’accès, vous allez également spécifier quel fournisseur vous souhaitez utiliser. Dans ce tutoriel, ce sera digitalocean. Pour une liste complète des sources de données et des ressources disponibles pour DigitalOcean avec Terraform, visitez la page des fournisseurs sur leur site web.

Créez et modifiez provider.tf avec la commande suivante :

nano provider.tf

Ajoutez le contenu suivant dans le fichier provider.tf :

variable "do_token" {}

provider "digitalocean" {
	token   = "${var.do_token}"
	version = "1.9.1"
	}

Dans ce fichier, vous ajoutez votre jeton d’accès DigitalOcean comme variable, que Terraform utilisera comme identification pour l’API DigitalOcean. Vous spécifiez également la version du plugin du fournisseur DigitalOcean. Terraform vous recommande de spécifier la version du fournisseur que vous utilisez afin que les futures mises à jour n’abiment pas votre configuration actuelle.

Vous allez maintenant créer le fichier digitalocean_droplet.tf. Ici, vous allez spécifier la ressource que vous allez utiliser, dans ce cas : droplet.

Créez le fichier avec la commande suivante :

nano digitalocean_droplet.tf

Ajoutez la configuration suivante :

resource "digitalocean_droplet" "do_droplet" {
    name   = "testing-terraform"
    region = "fra1"
    tags   = ["terraform-testing"]
    count  = "1"
}

Ici, vous spécifiez quatre paramètres :

• name : le nom de la Droplet.

• region : la région dans laquelle est située la Droplet.

• tags : une liste des étiquettes qui sont appliquées à cette Droplet.

• count : le nombre de ressources nécessaires pour cette configuration.

Ensuite, vous allez créer un fichier de configuration pour votre pare-feu. Créez le fichier digitalocean_firewall.tf​​​ avec la commande suivante :

nano digitalocean_firewall.tf

Ajoutez le contenu suivant au fichier :

resource "digitalocean_firewall" "do_firewall" {
  name  = "testing-terraform-firewall"
  tags  = ["terraform-testing"]
  count = "1"
}

Ici, vous spécifiez le nom du pare-feu que vous souhaitez importer et les étiquettes des Droplets auxquelles les règles du pare-feu s’appliquent. Enfin, la valeur count de 1 définit le nombre requis de la ressource particulière.

Maintenant, il est temps d’initialiser ces modifications afin que Terraform puisse télécharger les dépendances requises. Pour cela, vous allez utiliser la commande terraform init, ce qui vous permettra d’initialiser un répertoire de travail contenant les fichiers de configuration de Terraform.

Exécutez cette commande depuis votre répertoire de projet :

terraform init

Vous verrez la sortie suivante :

Output
Terraform has been successfully initialized!

Terraform a préparé avec succès le répertoire de travail en téléchargeant des plugins, en recherchant des modules, etc. Ensuite, vous allez commencer à importer vos ressources dans Terraform.

Étape 3 - Importation de vos ressources dans Terraform

Dans cette étape, vous allez importer vos ressources DigitalOcean dans Terraform. Vous allez utiliser doctl pour trouver les numéros d’identification de vos Droplets avant d’importer vos ressources. Ensuite, vous allez vérifier la configuration d’importation avec les commandes terraform show et terraform plan.

Pour commencer, vous allez exporter votre jeton d’accès DigitalOcean comme variable d’environnement, que vous allez ensuite injecter dans Terraform pendant l’exécution.

Exportez-le comme une variable d’environnement dans votre session shell en cours avec la commande suivante :

export DO_TOKEN="YOUR_TOKEN"

Pour importer votre Droplet et votre pare-feu existants, vous aurez besoin de leurs numéros d’identification. Vous pouvez utiliser doctl, l’interface en ligne de commande de l’API DigitalOcean. Exécutez la commande suivante pour énumérer vos Droplets et accéder à leurs ID :

doctl compute droplet list

Vous verrez une sortie semblable à ce qui suit :

Output
ID           Name                     Public IPv4        Private IPv4     Public IPv6    Memory    VCPUs    Disk    Region    Image                       Status    Tags    Features              Volumes
DROPLET-ID    DROPLET-NAME          				DROPLET-IPv4                 1024      1        25      fra1      Ubuntu 18.04.3 (LTS) x64              active
DROPLET-ID    DROPLET-NAME         					DROPLET-IPv4                 2048      1        50      fra1      Ubuntu 18.04.3 (LTS) x64           active
DROPLET-ID    DROPLET-NAME           				DROPLET-IPv4                 1024      1        25      fra1      Ubuntu 18.04.3 (LTS) x64

Maintenant, vous allez importer votre Droplet et votre pare-feu existants dans Terraform :

terraform import -var "do_token=${DO_TOKEN}" digitalocean_droplet.do_droplet DROPLET_ID

Vous utilisez l’indicateur -var pour spécifier la valeur de votre jeton d’accès DigitalOcean que vous avez précédemment exporté vers votre session shell. Cela est nécessaire pour que l’API DigitalOcean puisse vérifier qui vous êtes et appliquer les changements à votre infrastructure.

Maintenant, exécutez la même commande pour votre pare-feu :

terraform import -var "do_token=${DO_TOKEN}" digitalocean_firewall.do_firewall FIREWALL_ID

Vous allez vérifier que l’importation a réussi en utilisant la commande terraform show. Cette commande fournit un résultat lisible par l’homme de l’état de votre infrastructure. Elle peut être utilisée pour inspecter un plan afin de s’assurer que les changements souhaités vont être exécutés, ou pour inspecter l’état actuel tel que Terraform le voit.

Dans ce contexte, state fait référence à la mise en correspondance de vos ressources DigitalOcean avec la configuration Terraform que vous avez écrite et le suivi des métadonnées. Cela vous permet de confirmer qu’il n’y a aucune différence entre les ressources DigitalOcean existantes que vous souhaitez importer et les ressources dont Terraform assure le suivi :

terraform show

Vous verrez une sortie semblable à celle-ci :

Output
. . .
# digitalocean_droplet.do_droplet:
resource "digitalocean_droplet" "do_droplet" {
    backups            = false
    created_at         = "2020-02-03T16:12:02Z"
    disk               = 25
    id                 = "DROPLET-ID"
    image              = "DROPLET-IMAGE"
    ipv4_address       = "DROPLET-IP"
    ipv6               = false
    locked             = false
    memory             = 1024
    monitoring         = false
    name               = "testing-terraform-0"
    price_hourly       = 0.00744
    price_monthly      = 5
    private_networking = false
    region             = "fra1"
    resize_disk        = true
    size               = "s-1vcpu-1gb"
    status             = "active"
    tags               = [
        "terraform-testing",
    ]
    urn                = "DROPLET-URN"
    vcpus              = 1
    volume_ids         = []
. . .
}

Vous verrez deux ressources dans la sortie avec leurs attributs.

Après avoir importé votre Droplet et votre pare-feu dans l’état Terraform, vous devez vous assurer que les configurations représentent l’état actuel des ressources importées. Pour ce faire, vous allez spécifier les valeurs image et size de votre Droplet. Vous pouvez trouver ces deux valeurs dans la sortie de terraform show pour la ressource digitalocean_droplet.do_droplet.

Ouvrez le fichier digitalocean_droplet.tf :

nano digitalocean_droplet.tf

Dans ce tutoriel :

• L’image du système d’exploitation utilisée pour notre Droplet existante est ubuntu-16-04-x64.
• La région dans laquelle est située votre Droplet est fra1.
• L’étiquette Droplet pour votre Droplet existant est terraform-testing.

La Droplet que vous avez importée en utilisant la configuration dans digitalocean_droplet.tf ressemblera à ceci :

resource "digitalocean_droplet" "do_droplet" {
    image   = "ubuntu-16-04-x64"
    name    = "testing-terraform"
    region  = "fra1"
    size    = "s-1vcpu-1gb"
    tags    = ["terraform-testing"]
}

Ensuite, vous allez ajouter dans les règles du pare-feu. Dans notre exemple, les ports ouverts pour le trafic entrant sont 22, 80 et 443. Tous les ports sont ouverts pour le trafic sortant. Vous pouvez adapter cette configuration en fonction de vos ports ouverts.

Ouvrez digitalocean_firewall.tf :

nano digitalocean_firewall.tf

Ajoutez la configuration suivante :

resource "digitalocean_firewall" "do_firewall" {
  name  = "testing-terraform-firewall"
  tags  = ["terraform-testing"]
  count = "1"

  inbound_rule {
      protocol                = "tcp"
      port_range              = "22"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }
  inbound_rule {
      protocol                = "tcp"
      port_range              = "80"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }
  inbound_rule {
      protocol                = "tcp"
      port_range              = "443"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }

  outbound_rule {
      protocol                = "tcp"
      port_range              = "all"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
  outbound_rule {
      protocol                = "udp"
      port_range              = "all"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
  outbound_rule {
      protocol                = "icmp"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
}

Ces règles reproduisent l’état de l’exemple de pare-feu existant. Si vous souhaitez limiter le trafic à différentes adresses IP, différents ports ou différents protocoles, vous pouvez ajuster le fichier pour reproduire votre pare-feu existant.

Après avoir mis à jour vos fichiers Terraform, vous utiliserez la commande plan pour voir si les modifications que vous avez apportées reproduisent l’état des ressources existantes sur DigitalOcean.

La commande terraform plan est utilisée à titre d’essai. Avec cette commande, vous pouvez vérifier si les changements que Terraform va apporter sont bien ceux que vous voulez faire. Il est conseillé de toujours exécuter cette commande pour confirmation avant d’appliquer des modifications.

Exécutez terraform plan avec ce qui suit :

terraform plan -var "do_token=$DO_TOKEN"

Vous verrez une sortie semblable à la sortie qui suit :

Output
No changes. Infrastructure is up-to-date.

Vous avez réussi à importer des ressources DigitalOcean existantes dans Terraform, et vous pouvez maintenant apporter des modifications à votre infrastructure grâce à Terraform sans risquer de supprimer ou de modifier accidentellement des ressources existantes.

Étape 4 - Création de nouvelles ressources via Terraform

Dans cette étape, vous allez ajouter deux Droplets supplémentaires à votre infrastructure existante. Il peut être utile d’ajouter des ressources de cette manière à votre infrastructure existante, par exemple si vous avez un site web en ligne et que vous ne voulez pas y apporter de modifications susceptibles de le casser pendant que vous y travaillez. Au lieu de cela, vous pouvez ajouter une Droplet supplémentaire à utiliser comme environnement de développement et travailler sur votre projet dans le même environnement que la Droplet de production, sans aucun risque.

Maintenant, ouvrez digitalocean_droplet.tf pour ajouter les règles de vos nouvelles Droplets :

nano digitalocean_droplet.tf

Ajoutez les lignes suivantes à votre fichier :

resource "digitalocean_droplet" "do_droplet" {
    image   = "ubuntu-16-04-x64"
    name    = "testing-terraform"
    region  = "fra1"
    size    = "s-1vcpu-1gb"
    tags    = ["terraform-testing"]
    count   = "1"
}

resource "digitalocean_droplet" "do_droplet_new" {
    image   = "ubuntu-18-04-x64"
    name    = "testing-terraform-${count.index}"
    region  = "fra1"
    size    = "s-1vcpu-1gb"
    tags    = ["terraform-testing"]
    count   = "2"
}

Vous utilisez le méta-argument count pour dire à Terraform combien de Droplets ayant les mêmes spécifications vous voulez. Ces nouvelles Droplets seront également ajoutées à votre pare-feu existant, car vous spécifiez la même étiquette que celle de votre pare-feu.

Appliquez ces règles pour vérifier les modifications que vous spécifiez dans digitalocean_droplet.tf :

terraform plan -var "do_token=$DO_TOKEN"

Vérifiez que les modifications que vous souhaitez apporter sont reproduites dans la sortie de cette commande.

Vous verrez une sortie semblable à ce qui suit :

. . .
[secondary_label Output]
# digitalocean_droplet.do_droplet_new[1] will be created
  + resource "digitalocean_droplet" "do_droplet_new" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-18-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + ipv6_address_private = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "testing-terraform-1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "fra1"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + status               = (known after apply)
      + tags                 = [
          + "terraform-testing",
        ]
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
    }

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

Une fois que vous êtes satisfait de la sortie, utilisez la commande terraform apply pour appliquer les changements que vous avez spécifiés à l’état de la configuration :

terraform apply -var "do_token=$DO_TOKEN"

Confirmez les changements en entrant yes sur la ligne de commande. Une fois l’exécution réussie, vous verrez une sortie semblable à ce qui suit :

Output
. . .
digitalocean_droplet.do_droplet_new[1]: Creating...
digitalocean_droplet.do_droplet_new[0]: Creating...
digitalocean_firewall.do_firewall[0]: Modifying... [id=FIREWALL-ID]
digitalocean_firewall.do_firewall[0]: Modifications complete after 1s [id=FIREWALL-ID]
digitalocean_droplet.do_droplet_new[0]: Still creating... [10s elapsed]
digitalocean_droplet.do_droplet_new[1]: Still creating... [10s elapsed]
digitalocean_droplet.do_droplet_new[0]: Creation complete after 16s [id=DROPLET-ID]
digitalocean_droplet.do_droplet_new[1]: Still creating... [20s elapsed]
digitalocean_droplet.do_droplet_new[1]: Creation complete after 22s [id=DROPLET-ID]

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

Vous verrez deux nouvelles Droplets dans votre panneau web DigitalOcean :

Vous les verrez également attachés à votre pare-feu existant :

Vous avez créé de nouvelles ressources avec Terraform en utilisant vos ressources existantes. Pour apprendre comment détruire ces ressources, vous pouvez éventuellement suivre l’étape suivante.

Étape 5 - Destruction des ressources importées et créées (facultatif)

Dans cette étape, vous allez détruire les ressources que vous avez importées et créées en ajustant la configuration.

Commencez par ouvrir digitalocean_droplet.tf :

nano digitalocean_droplet.tf

Dans le fichier, définissez count sur 0 comme suit :

resource "digitalocean_droplet" "do_droplet" {
    image   = "ubuntu-16-04-x64"
    name    = "testing-terraform"
    region  = "fra1"
    size    = "s-1vcpu-1gb"
    tags    = ["terraform-testing"]
    count   = "0"
}

resource "digitalocean_droplet" "do_droplet_new" {
    image   = "ubuntu-18-04-x64"
    name    = "testing-terraform-${count.index}"
    region  = "fra1"
    size    = "s-1vcpu-1gb"
    tags    = ["terraform-testing"]
    count   = "0"
}

Enregistrez et quittez le fichier.

Ouvrez le fichier de configuration de votre pare-feu pour également y modifier count :

nano digitalocean_firewall.tf

Définissez count sur 0 comme dans la ligne surlignée suivante :

resource "digitalocean_firewall" "do_firewall" {
  name  = "testing-terraform-firewall"
  tags  = ["terraform-testing"]
  count = "0"

  inbound_rule {
      protocol                = "tcp"
      port_range              = "22"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }
  inbound_rule {
      protocol                = "tcp"
      port_range              = "80"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }
  inbound_rule {
      protocol                = "tcp"
      port_range              = "443"
      source_addresses        = ["0.0.0.0/0", "::/0"]
    }

  outbound_rule {
      protocol                = "tcp"
      port_range              = "all"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
  outbound_rule {
      protocol                = "udp"
      port_range              = "all"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
  outbound_rule {
      protocol                = "icmp"
      destination_addresses   = ["0.0.0.0/0", "::/0"]
    }
}

Enregistrez et quittez le fichier.

Appliquez maintenant ces changements avec la commande suivante :

terraform apply -var "do_token=${DO_TOKEN}"

Terraform va vous demander de confirmer si vous souhaitez détruire les Droplets et le pare-feu. Cela détruira toutes les ressources que vous avez importées et créées via Terraform. Assurez-vous donc de vérifier que vous souhaitez poursuivre avant de taper yes.

Vous verrez un résultat semblable à :

Output
. . .
digitalocean_droplet.do_droplet[0]: Destroying... [id=YOUR-DROPLET-ID]]
digitalocean_droplet.do_droplet_new[0]: Destroying... [id=YOUR-DROPLET-ID]
digitalocean_droplet.do_droplet_new[1]: Destroying... [id=YOUR-DROPLET-ID]
digitalocean_firewall.do_firewall[0]: Destroying... [id=YOUR-FIREWALL-ID]
digitalocean_firewall.do_firewall[0]: Destruction complete after 1s
digitalocean_droplet.do_droplet_new[1]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed]
digitalocean_droplet.do_droplet[0]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed]
digitalocean_droplet.do_droplet_new[0]: Still destroying... [id=YOUR-DROPLET-ID, 10s elapsed]
digitalocean_droplet.do_droplet_new[1]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed]
digitalocean_droplet.do_droplet_new[0]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed]
digitalocean_droplet.do_droplet[0]: Still destroying... [id=YOUR-DROPLET-ID, 20s elapsed]
digitalocean_droplet.do_droplet_new[1]: Destruction complete after 22s
digitalocean_droplet.do_droplet[0]: Destruction complete after 22s
digitalocean_droplet.do_droplet_new[0]: Destruction complete after 22s

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

Vous avez supprimé toutes les ressources gérées par Terraform. Il s’agit d’un flux de travail utile si vous n’avez plus besoin d’une ressource ou si vous réduisez vos capacités.

Conclusion

Dans ce tutoriel, vous avez installé Terraform, importé des ressources existantes, créé de nouvelles ressources et éventuellement détruit ces ressources. Vous pouvez adapter ce flux de travail à un projet plus vaste, tel que le déploiement d’un cluster Kubernetes prêt à la production. Avec Terraform, vous avez pu gérer tous les nœuds, les entrées DNS, les pare-feu, le stockage et d’autres ressources, ainsi qu’utiliser le contrôle de version pour suivre les changements et collaborer avec une équipe.

Pour découvrir les autres caractéristiques de Terraform, consultez la documentation. Vous pouvez également consulter le contenu DigitalOcean relatif à Terraform pour découvrir d’autres tutoriels et des questions-réponses