Introduction à Terraform pour les débutants – Tutoriel Terraform

Vous vous demandez ce qu’est Terraform ? Découvrons-le.

Infrastructure as Code (IaC) est une terminologie très répandue parmi les professionnels du DevOps. Il s’agit du processus de gestion et de provisionnement de l’infrastructure informatique complète (comprenant à la fois des machines physiques et virtuelles) à l’aide de fichiers de définition lisibles par machine. Il s’agit d’une approche d’ingénierie logicielle pour les opérations. Elle permet d’automatiser l’ensemble du centre de données à l’aide de scripts de programmation.

Avec toutes les fonctionnalités qu’offre l’Infrastructure as Code, elle présente de nombreux défis :

• Nécessité d’apprendre à coder
• Ne pas connaître l’impact du changement.
• Nécessité de revenir sur le changement
• Impossibilité de suivre les changements
• Impossibilité d’automatiser une ressource
• Multiples environnements pour l’infrastructure

Terraform a été créé pour résoudre ces problèmes.

Vous trouverez ci-dessous quelques-uns des avantages de l’utilisation de Terraform.

• Fait de l’orchestration, pas seulement de la gestion de configuration
• Prend en charge de nombreux fournisseurs tels que AWS, Azure, GCP, DigitalOcean et bien d’autres encore
• Fournit une infrastructure immuable où les changements de configuration se font en douceur
• Utilise un langage facile à comprendre, HCL (HashiCorp configuration language)
• Facilement transférable à n’importe quel autre fournisseur
• Supporte l’architecture client seulement, donc pas besoin d’une gestion de configuration supplémentaire sur un serveur

Concepts de base de Terraform

Vous trouverez ci-dessous les concepts/terminologies de base utilisés dans Terraform :

• Variables: Également appelées variables d’entrée, il s’agit de paires clé-valeur utilisées par les modules Terraform pour permettre la personnalisation.
• Fournisseur: Il s’agit d’un plugin permettant d’interagir avec les API d’un service et d’accéder à ses ressources connexes.
• Module: Il s’agit d’un dossier contenant des modèles Terraform où toutes les configurations sont définies
• État: Il s’agit d’informations mises en cache sur l’infrastructure gérée par Terraform et les configurations associées.
• Ressources: Il s’agit d’un bloc d’un ou plusieurs objets d’infrastructure (instances de calcul, réseaux virtuels, etc.), qui sont utilisés pour configurer et gérer l’infrastructure.
• Source de données: Elle est mise en œuvre par les fournisseurs pour renvoyer à Terraform des informations sur des objets externes.
• Valeurs de sortie: Ce sont les valeurs de retour d’un module terraform qui peuvent être utilisées par d’autres configurations.
• Plan: C’est l’une des étapes où l’on détermine ce qui doit être créé, mis à jour ou détruit pour passer de l’état réel/courant de l’infrastructure à l’état désiré.
• Appliquer: C’est l’une des étapes où l’on applique les changements de l’état réel/courant de l’infrastructure afin de passer à l’état désiré.

Cycle de vie de Terraform

Le cycle de vie de Terraform comprend les étapes suivantes : init, plan, apply et destroy.

• Terraform init initialise le répertoire de travail qui contient tous les fichiers de configuration
• Terraform plan est utilisé pour créer un plan d’exécution afin d’atteindre l’état souhaité de l’infrastructure. Des modifications sont apportées aux fichiers de configuration afin d’atteindre l’état souhaité.
• Terraform apply effectue ensuite les changements dans l’infrastructure tels que définis dans le plan, et l’infrastructure atteint l’état souhaité.
• Terraform destroy est utilisé pour supprimer toutes les anciennes ressources de l’infrastructure, qui sont marquées comme altérées après la phase d’application.

Comment fonctionne Terraform ?

Terraform a deux composants principaux qui constituent son architecture :

• Terraform Core
• Les fournisseurs

Terraform Core

Le noyau de Terraform utilise deux sources d’entrée pour effectuer son travail.

La première source d’entrée est une configuration Terraform que vous configurez en tant qu’utilisateur. Ici, vous définissez ce qui doit être créé ou provisionné. La deuxième source d’entrée est un état dans lequel Terraform conserve l’état actualisé de la configuration actuelle de l’infrastructure.

Donc, ce que fait terraform core, c’est qu’il prend les données d’entrée et qu’il détermine le plan de ce qui doit être fait. Il compare l’état, l’état actuel et la configuration que vous souhaitez pour le résultat final. Il détermine ce qu’il faut faire pour atteindre l’état souhaité dans le fichier de configuration. Il détermine ce qui doit être créé, ce qui doit être mis à jour, ce qui doit être supprimé pour créer et approvisionner l’infrastructure.

Les fournisseurs

Le deuxième élément de l’architecture est constitué par les fournisseurs de technologies spécifiques. Il peut s’agir de fournisseurs de cloud comme AWS, Azure, GCP ou d’autres plateformes d’infrastructure en tant que service. Il s’agit également d’un fournisseur pour des composants de plus haut niveau comme Kubernetes ou d’autres outils de plateforme en tant que service, voire certains logiciels en tant qu’outils en libre-service.

Il vous donne la possibilité de créer une infrastructure à différents niveaux.

Par exemple, créez une infrastructure AWS, puis déployez Kubernetes au-dessus et créez des services/composants à l’intérieur de ce cluster Kubernetes.

Terraform a plus d’une centaine de fournisseurs pour différentes technologies, et chaque fournisseur donne à l’utilisateur de Terraform l’accès à ses ressources. Ainsi, grâce au fournisseur AWS, par exemple, vous avez accès à des centaines de ressources AWS telles que les instances EC2, les utilisateurs AWS, etc. Avec le fournisseur Kubernetes, vous avez accès à des ressources comme les services, les déploiements, les espaces de noms, etc.

C’est ainsi que Terraform fonctionne, et de cette façon, il essaie de vous aider à provisionner et à couvrir la configuration complète de l’application, de l’infrastructure jusqu’à l’application.

Passons à la pratique. 👨‍💻

Nous allons installer Terraform sur Ubuntu et mettre en place une infrastructure très basique.

Installer Terraform

Téléchargez la dernière version de Terraform.

Référez-vous à la page de téléchargement officielle pour obtenir la dernière version pour le système d’exploitation concerné.

geekflare@geekflare:~$ wget https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
--2020-08-14 16:55:38--
https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
Résolution de releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439
Connexion à releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... connecté.
Requête HTTP envoyée, en attente de réponse... 200 OK
Longueur : 34851622 (33M) [application/zip]
Sauvegarde dans : 'terraform_0.13.0_linux_amd64.zip'

terraform_0.13.0_linux_amd64.zip
100%[=================================================================>] 33.24M
90.3KB/s en 5m 28s

2020-08-14 17:01:06 (104 KB/s) - 'terraform_0.13.0_linux_amd64.zip' sauvegardé [34851622/34851622]

Extrayez le paquet téléchargé.

geekflare@geekflare:~$ unzip terraform_0.13.0_linux_amd64.zip
Archive :
terraform_0.13.0_linux_amd64.zip
gonfler : terraform

Déplacez le fichier exécutable terraform vers le chemin indiqué ci-dessous. Vérifiez la version de terraform.

geekflare@geekflare:~$ sudo mv terraform /usr/local/bin/
mot de passe [sudo] pour geekflare :
geekflare@geekflare:~$ terraform -v
Terraform v0.13.0

Vous pouvez voir qu’il s’agit des commandes disponibles dans terraform pour l’exécution.

geekflare@geekflare:~$ terraform
Utilisation : terraform [-version] [-help] <commande> [args]

Les commandes disponibles pour l'exécution sont listées ci-dessous.
Les commandes les plus courantes et les plus utiles sont présentées en premier, suivies des commandes moins courantes ou plus avancées
suivies des commandes moins courantes ou plus avancées. Si vous commencez tout juste à utiliser Terraform, contentez-vous des commandes les moins courantes ou les plus avancées
avec Terraform, contentez-vous des commandes les plus courantes. Pour les
autres commandes, veuillez lire l'aide et la documentation avant de les utiliser.

Commandes courantes :
apply Construit ou modifie l'infrastructure
console Console interactive pour les interpolations Terraform
destroy Destruction de l'infrastructure gérée par Terraform
env Gestion de l'espace de travail
fmt Réécriture des fichiers de configuration au format canonique
get Télécharger et installer des modules pour la configuration
graph Créer un graphique visuel des ressources Terraform
import Importe l'infrastructure existante dans Terraform
init Initialiser un répertoire de travail Terraform
login Obtention et enregistrement des informations d'identification pour un hôte distant
logout Supprimer les informations d'identification stockées localement pour un hôte distant
output Lire une sortie à partir d'un fichier d'état
plan Génère et affiche un plan d'exécution
providers Imprime une arborescence des fournisseurs utilisés dans la configuration
refresh Mise à jour du fichier d'état local par rapport aux ressources réelles
show Inspecter l'état ou le plan Terraform
taint Marquer manuellement une ressource pour la recréation
unaintt Annule manuellement le marquage d'une ressource comme tainted
validate Valide les fichiers Terraform
version Imprime la version de Terraform
workspace Gestion de l'espace de travail

Toutes les autres commandes :
0.12upgrade Réécrit le code source du module pré-0.12 pour la v0.12
0.13upgrade Réécrit le code source du module pré-0.13 pour la v0.13
debug Gestion de la sortie de débogage (expérimental)
force-unlock Déverrouillage manuel de l'état de Terraform
push Commande obsolète pour Terraform Enterprise legacy (v1)
state Gestion avancée de l'état

Approvisionnement d’une instance AWS EC2 à l’aide de Terraform

Dans cette démo, je vais lancer une nouvelle instance AWS EC2 à l’aide de Terraform.

Créez un répertoire de travail pour cette démo Terraform.

geekflare@geekflare:~$ mkdir terraform_demo

Allez dans le répertoire et créez un fichier de configuration terraform dans lequel vous définissez le fournisseur et les ressources pour lancer une instance AWS EC2.

geekflare@geekflare:~$ cd terraform_demo/
geekflare@geekflare:~/terraform_demo$ gedit awsec2.tf

fournisseur "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ T6GY7H"
region = "us-west-2"
}

ressource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}

Note : j’ai changé les clés d’accès et de secret 😛, vous devez utiliser les vôtres.

À partir de la configuration mentionnée ci-dessus, vous pouvez voir que je mentionne le fournisseur comme AWS. À l’intérieur du fournisseur, je donne les informations d’identification de l’utilisateur AWS et les régions où l’instance doit être lancée.

Dans les ressources, je donne les détails de l’AMI d’Ubuntu (ami-0a634ae95e11c6f91) et je mentionne que le type d’instance doit être t2.micro

Vous pouvez voir à quel point le fichier de configuration est simple et lisible, même si vous n’êtes pas un codeur invétéré.

initialisation de terraform

Maintenant, la première étape est d’initialiser terraform.

geekflare@geekflare:~/terraform_demo$ terraform init

Initialisation du backend...

Initialisation des plugins fournisseurs...
- Utilisation de hashicorp/aws v3.2.0 précédemment installé

Les fournisseurs suivants n'ont pas de contraintes de version dans la configuration,
la dernière version a donc été installée.

Pour éviter les mises à niveau automatiques vers de nouvelles versions majeures qui peuvent contenir des changements radicaux, nous vous recommandons d'ajouter des contraintes de version dans un bloc required_providers
de rupture, nous vous recommandons d'ajouter des contraintes de version dans un bloc required_providers
dans votre configuration, avec les chaînes de contraintes suggérées ci-dessous.

* hashicorp/aws : version = "~> 3.2.0"

Terraform a été initialisé avec succès !

Vous pouvez maintenant commencer à travailler avec Terraform. Essayez d'exécuter "terraform plan" pour voir
les modifications à apporter à votre infrastructure. Toutes les commandes Terraform
devraient maintenant fonctionner.

Si vous avez défini ou modifié des modules ou la configuration du backend pour Terraform, exécutez à nouveau cette commande pour réinitialiser votre répertoire de travail,
exécutez à nouveau cette commande pour réinitialiser votre répertoire de travail. Si vous oubliez, d'autres commandes
le détecteront et vous rappelleront de le faire si nécessaire.

plan terraform

L’étape suivante est celle du plan ; elle permet de créer le graphe d’exécution pour la création et le provisionnement de l’infrastructure.

geekflare@geekflare:~/terraform_demo$ terraform plan
Rafraîchissement de l'état de Terraform en mémoire avant le plan...
L'état rafraîchi sera utilisé pour calculer ce plan, mais ne sera pas
mais ne sera pas conservé dans le stockage d'état local ou distant.

------------------------------------------------------------------------

Un plan d'exécution a été généré et est présenté ci-dessous.
Les actions sur les ressources sont indiquées par les symboles suivants :
  créer

Terraform effectuera les actions suivantes :

# aws_instance.terraform_demo sera créé
  ressource "aws_instance" "terraform_demo" {
  ami = "ami-0a634ae95e11c6f91"
  arn = (connu après application)
  associate_public_ip_address = (connu après application)
  availability_zone = (connu après application)
  cpu_core_count = (connu après application)
  cpu_threads_per_core = (connu après application)
  get_password_data = false
  host_id = (connu après application)
  id = (connu après application)
  instance_state = (connu après application)
  instance_type = "t2.micro"
  ipv6_address_count = (connu après application)
  ipv6_addresses = (connu après application)
  key_name = (connu après application)
  outpost_arn = (connu après application)
  password_data = (connu après application)
  placement_group = (connu après application)
  primary_network_interface_id = (connu après application)
  private_dns = (connu après application)
  private_ip = (connu après application)
  public_dns = (connu après application)
  public_ip = (connu après application)
  secondary_private_ips = (connu après application)
  security_groups = (connu après application)
  source_dest_check = true
  subnet_id = (connu après application)
  tenancy = (connu après application)
  volume_tags = (connu après application)
  vpc_security_group_ids = (connu après application)

  ebs_block_device {
  delete_on_termination = (connu après application)
  device_name = (connu après application)
  encrypted = (connu après application)
  iops = (connu après application)
  kms_key_id = (connu après application)
  snapshot_id = (connu après l'application)
  volume_id = (connu après l'application)
  volume_size = (connu après l'application)
  volume_type = (connu après l'application)
}

  ephemeral_block_device {
  device_name = (connu après application)
  no_device = (connu après application)
  virtual_name = (connu après application)
}

  metadata_options {
  http_endpoint = (connu après application)
  http_put_response_hop_limit = (connu après application)
  http_tokens = (connu après application)
}

  network_interface {
  delete_on_termination = (connu après application)
  device_index = (connu après application)
  network_interface_id = (connu après application)
}

  root_block_device {
  delete_on_termination = (connu après application)
  device_name = (connu après application)
  encrypted = (connu après application)
  iops = (connu après application)
  kms_key_id = (connu après application)
  volume_id = (connu après l'application)
  volume_size = (connu après l'application)
  volume_type = (connu après l'application)
}
}

Plan : 1 pour ajouter, 0 pour modifier, 0 pour détruire.

------------------------------------------------------------------------

Note : Vous n'avez pas spécifié de paramètre "-out" pour enregistrer ce plan, donc Terraform
ne peut donc pas garantir que ces actions seront exécutées si la commande
"terraform apply" est exécuté ultérieurement.

terraform apply

L’étape apply exécutera le fichier de configuration et lancera une instance AWS EC2. Lorsque vous exécutez la commande apply, elle vous demandera “Do you want to perform these actions ?”, vous devez taper oui et appuyer sur entrée.

geekflare@geekflare:~/terraform_demo$ terraform apply

Un plan d'exécution a été généré et est présenté ci-dessous.
Les actions sur les ressources sont indiquées par les symboles suivants :
  créer

Terraform effectuera les actions suivantes :

# aws_instance.terraform_demo sera créé
  ressource "aws_instance" "terraform_demo" {
  ami = "ami-0a634ae95e11c6f91"
  arn = (connu après application)
  associate_public_ip_address = (connu après application)
  availability_zone = (connu après application)
  cpu_core_count = (connu après application)
  cpu_threads_per_core = (connu après application)
  get_password_data = false
  host_id = (connu après application)
  id = (connu après application)
  instance_state = (connu après application)
  instance_type = "t2.micro"
  ipv6_address_count = (connu après application)
  ipv6_addresses = (connu après application)
  key_name = (connu après application)
  outpost_arn = (connu après application)
  password_data = (connu après application)
  placement_group = (connu après application)
  primary_network_interface_id = (connu après application)
  private_dns = (connu après application)
  private_ip = (connu après application)
  public_dns = (connu après application)
  public_ip = (connu après application)
  secondary_private_ips = (connu après application)
  security_groups = (connu après application)
  source_dest_check = true
  subnet_id = (connu après application)
  tenancy = (connu après application)
  volume_tags = (connu après application)
  vpc_security_group_ids = (connu après application)

  ebs_block_device {
  delete_on_termination = (connu après application)
  device_name = (connu après application)
  encrypted = (connu après application)
  iops = (connu après application)
  kms_key_id = (connu après application)
  snapshot_id = (connu après l'application)
  volume_id = (connu après l'application)
  volume_size = (connu après l'application)
  volume_type = (connu après l'application)
}

  ephemeral_block_device {
  device_name = (connu après application)
  no_device = (connu après application)
  virtual_name = (connu après application)
}

  metadata_options {
  http_endpoint = (connu après application)
  http_put_response_hop_limit = (connu après application)
  http_tokens = (connu après application)
}

  network_interface {
  delete_on_termination = (connu après application)
  device_index = (connu après application)
  network_interface_id = (connu après application)
}

  root_block_device {
  delete_on_termination = (connu après application)
  device_name = (connu après application)
  encrypted = (connu après application)
  iops = (connu après application)
  kms_key_id = (connu après application)
  volume_id = (connu après l'application)
  volume_size = (connu après l'application)
  volume_type = (connu après l'application)
}
}

Plan : 1 pour ajouter, 0 pour modifier, 0 pour détruire.

Voulez-vous effectuer ces actions ?
Terraform effectuera les actions décrites ci-dessus.
Seuls les "oui" seront acceptés pour approbation.

Entrez une valeur : oui

aws_instance.terraform_demo : Création...
aws_instance.terraform_demo : Toujours en cours de création... [10s écoulées]
aws_instance.terraform_demo : Toujours en cours de création... [20s écoulées]
aws_instance.terraform_demo : Toujours en cours de création... [30s écoulées]
aws_instance.terraform_demo : Toujours en cours de création... [40s écoulées]
aws_instance.terraform_demo : Création terminée après 44s [id=i-0eec33286ea4b0740]

Application terminée ! Ressources : 1 ajoutée, 0 modifiée, 0 détruite.

Allez sur votre tableau de bord AWS EC2, et vous verrez qu’une nouvelle instance avec l’identifiant d’instance mentionné à la fin de la commande apply a été créée.

Vous avez lancé avec succès une instance AWS EC2 à l’aide de Terraform.

terraform destroy

Enfin, si vous souhaitez supprimer l’infrastructure, vous devez exécuter la commande destroy.

geekflare@geekflare:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo : Rafraîchissement de l'état... [id=i-0eec33286ea4b0740]

Un plan d'exécution a été généré et est présenté ci-dessous.
Les actions sur les ressources sont indiquées par les symboles suivants :
- détruire

Terraform effectuera les actions suivantes :

# aws_instance.terraform_demo sera détruit
- ressource "aws_instance" "terraform_demo" {
- ami = "ami-0a634ae95e11c6f91" -> null
- arn = "arn:aws:ec2:us-west-2:259212389929:instance/i-0eec33286ea4b0740" -> null
- associate_public_ip_address = true -> null
- availability_zone = "us-west-2c" -> null
- cpu_core_count = 1 -> null
- cpu_threads_per_core = 1 -> null
- disable_api_termination = false -> null
- ebs_optimized = false -> null
- get_password_data = false -> null
- hibernation = false -> null
- id = "i-0eec33286ea4b0740" -> null
- instance_state = "running" -> null
- instance_type = "t2.micro" -> null
- ipv6_address_count = 0 -> null
- ipv6_addresses = [] -> null
- monitoring = false -> null
- primary_network_interface_id = "eni-02a46f2802fd15634" -> null
- private_dns = "ip-172-31-13-160.us-west-2.compute.internal" -> null
- private_ip = "172.31.13.160" -> null
- public_dns = "ec2-34-221-77-94.us-west-2.compute.amazonaws.com" -> null
- public_ip = "34.221.77.94" -> null
- secondary_private_ips = [] -> null
- security_groups = [
- "default",
] -> null
- source_dest_check = true -> null
- subnet_id = "subnet-5551200c" -> null
- tags = {} -> null
- tenancy = "default" -> null
- volume_tags = {} -> null
- vpc_security_group_ids = [
- "sg-b5b480d1",
] -> null

- credit_specification {
- cpu_credits = "standard" -> null
}

- options_métadonnées {
- http_endpoint = "enabled" -> null
- http_put_response_hop_limit = 1 -> null
- http_tokens = "optional" -> null
}

- root_block_device {
- delete_on_termination = true -> null
- device_name = "/dev/sda1" -> null
- encrypted = false -> null
- iops = 100 -> null
- volume_id = "vol-0be2673afff6b1a86" -> null
- volume_size = 8 -> null
- volume_type = "gp2" -> null
}
}

Plan : 0 à ajouter, 0 à modifier, 1 à détruire.

Voulez-vous vraiment détruire toutes les ressources ?
Terraform détruira toute votre infrastructure gérée, comme indiqué ci-dessus.
Il n'y a pas d'annulation possible. Seul un "oui" sera accepté pour confirmer.

Entrez une valeur : oui

aws_instance.terraform_demo : Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo : Toujours en cours de destruction... [id=i-0eec33286ea4b0740, 10s écoulées]
aws_instance.terraform_demo : Toujours en cours de destruction... [id=i-0eec33286ea4b0740, 20s écoulées]
aws_instance.terraform_demo : Toujours en cours de destruction... [id=i-0eec33286ea4b0740, 30s écoulées]
aws_instance.terraform_demo : Destruction terminée après 34s

Destruction terminée ! Ressources : 1 détruit.

Si vous vérifiez à nouveau le tableau de bord EC2, vous verrez que l’instance a été terminée.

Conclusion

Je pense que ce qui précède vous donne une idée pour démarrer avec Terraform. Allez-y et essayez l’exemple que je viens de montrer.

Vous devriez également jeter un coup d’œil à ces logiciels d’automatisation d’infrastructure.

Si vous souhaitez en savoir plus, je vous suggère de consulter le cours Learning DevOps with Terraform.