Qu’est-ce que Terraform ? Découvrons-le.
Infrastructure as Code (IaC) est une terminologie répandue parmi les professionnels 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 vers les opérations. Il aide à automatiser le centre de données complet en utilisant des scripts de programmation.
Avec toutes les fonctionnalités fournies par Infrastructure as Code, les défis sont multiples :
- Besoin d’apprendre à coder
- Je ne connais pas l’impact du changement.
- Besoin d’annuler le changement
- Impossible de suivre les modifications
- Impossible d’automatiser une ressource
- Environnements multiples pour l’infrastructure
Terraform a été créé pour résoudre ces défis.
Qu’est-ce que Terraform ?
Terraforme est une infrastructure open source en tant qu’outil de code développé par HashiCorp. Il est utilisé pour définir et fournir l’infrastructure complète à l’aide d’un langage déclaratif facile à apprendre.
Il s’agit d’un outil de provisionnement d’infrastructure dans lequel vous pouvez stocker la configuration de votre infrastructure cloud sous forme de codes. C’est très similaire à des outils tels que CloudFormation, que vous utiliseriez pour automatiser votre infrastructure AWS, mais vous ne pouvez l’utiliser que sur AWS. Avec Terraform, vous pouvez également l’utiliser sur d’autres plates-formes cloud.
Vous trouverez ci-dessous certains des avantages de l’utilisation de Terraform.
- Est-ce que l’orchestration, pas seulement la gestion de la configuration
- Prend en charge plusieurs fournisseurs tels qu’AWS, Azure, GCP, DigitalOcean et bien d’autres
- Fournir une infrastructure immuable où la configuration change en douceur
- Utilise un langage facile à comprendre, HCL (langage de configuration HashiCorp)
- Facilement transférable à tout autre fournisseur
- Prend en charge l’architecture client uniquement, donc pas besoin de gestion de configuration supplémentaire sur un serveur
Table des matières
Concepts de base de Terraform
Vous trouverez ci-dessous les concepts/terminologies de base utilisés dans Terraform :
- Variables : également utilisées comme variables d’entrée, il s’agit d’une paire clé-valeur utilisée par les modules Terraform pour permettre la personnalisation.
- Fournisseur : Il s’agit d’un plugin pour interagir avec les API de service et accéder à ses ressources associées.
- Module : C’est un dossier avec 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 dans la configuration et la gestion de l’infrastructure.
- Source de données : elle est implémentée par les fournisseurs pour renvoyer des informations sur des objets externes à terraform.
- Valeurs de sortie : il s’agit des valeurs de retour d’un module terraform qui peuvent être utilisées par d’autres configurations.
- Planifier : C’est l’une des étapes où il détermine ce qui doit être créé, mis à jour ou détruit pour passer de l’état réel/actuel de l’infrastructure à l’état souhaité.
- Appliquer : C’est l’une des étapes où l’on applique les changements d’état réel/actuel de l’infrastructure afin de passer à l’état souhaité.
Cycle de vie de Terraform
Le cycle de vie de Terraform consiste en – initialiser, planifier, appliquer et détruire.
- Terraform init initialise le répertoire de travail qui se compose de tous les fichiers de configuration
- Le plan Terraform est utilisé pour créer un plan d’exécution pour atteindre un état souhaité de l’infrastructure. Les modifications apportées aux fichiers de configuration sont effectuées afin d’atteindre l’état souhaité.
- Terraform applique ensuite les modifications de l’infrastructure telles que définies dans le plan, et l’infrastructure arrive à l’état souhaité.
- Terraform destroy est utilisé pour supprimer toutes les anciennes ressources d’infrastructure, qui sont marquées comme étant entachées après la phase d’application.
Comment fonctionne Terraform ?
Terraform a deux composants principaux qui composent son architecture :
Noyau Terraform
Le noyau de Terraform utilise deux sources d’entrée pour faire son travail.
La première source d’entrée est une configuration Terraform que vous, en tant qu’utilisateur, configurez. Ici, vous définissez ce qui doit être créé ou provisionné. Et la deuxième source d’entrée est un état dans lequel terraform conserve l’état à jour de la configuration actuelle de l’infrastructure.
Donc, ce que fait le noyau de terraform, c’est qu’il prend l’entrée et qu’il détermine le plan de ce qui doit être fait. Il compare l’état, quel est l’état actuel et quelle est la configuration que vous désirez dans le résultat final. Il détermine ce qui doit être fait pour atteindre l’état souhaité dans le fichier de configuration. Il indique ce qui doit être créé, ce qui doit être mis à jour, ce qui doit être supprimé pour créer et provisionner l’infrastructure.
Fournisseurs
Le deuxième composant de l’architecture sont des fournisseurs de technologies spécifiques. Il peut s’agir de fournisseurs de cloud comme AWS, Azure, GCP ou d’autres infrastructures en tant que plate-forme de service. C’est également un fournisseur de composants de plus haut niveau comme Kubernetes ou d’autres outils de plate-forme en tant que service, voire certains logiciels en tant qu’outil 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 dessus, puis créez des services/composants à l’intérieur de ce cluster Kubernetes.
Terraform compte plus d’une centaine de fournisseurs pour différentes technologies, et chaque fournisseur donne ensuite aux utilisateurs de terraform l’accès à ses ressources. Ainsi, via le 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 accédez à des produits, des ressources telles que des services, des déploiements et des espaces de noms, etc.
C’est ainsi que fonctionne Terraform, 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.
Faisons quelques trucs pratiques. 👨💻
Nous installerons Terraform sur Ubuntu et fournirons une infrastructure très basique.
Installer Terraform
Téléchargez le dernier package terraform.
Se référer au page de téléchargement officielle pour obtenir la dernière version du système d’exploitation respectif.
[email protected]:~$ 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 Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439 Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 34851622 (33M) [application/zip] Saving to: ‘terraform_0.13.0_linux_amd64.zip’ terraform_0.13.0_linux_amd64.zip 100%[=================================================================>] 33.24M 90.3KB/s in 5m 28s 2020-08-14 17:01:06 (104 KB/s) - ‘terraform_0.13.0_linux_amd64.zip’ saved [34851622/34851622]
Extrayez le package téléchargé.
[email protected]:~$ unzip terraform_0.13.0_linux_amd64.zip Archive: terraform_0.13.0_linux_amd64.zip inflating: terraform
Déplacez le fichier exécutable terraform vers le chemin indiqué ci-dessous. Vérifiez la version de terraform.
[email protected]:~$ sudo mv terraform /usr/local/bin/ [sudo] password for toptips.fr: [email protected]:~$ terraform -v Terraform v0.13.0
Vous pouvez voir que ce sont les commandes disponibles dans terraform pour l’exécution.
[email protected]:~$ terraform Usage: terraform [-version] [-help] <command> [args] The available commands for execution are listed below. The most common, useful commands are shown first, followed by less common or more advanced commands. If you're just getting started with Terraform, stick with the common commands. For the other commands, please read the help and docs before usage. Common commands: apply Builds or changes infrastructure console Interactive console for Terraform interpolations destroy Destroy Terraform-managed infrastructure env Workspace management fmt Rewrites config files to canonical format get Download and install modules for the configuration graph Create a visual graph of Terraform resources import Import existing infrastructure into Terraform init Initialize a Terraform working directory login Obtain and save credentials for a remote host logout Remove locally-stored credentials for a remote host output Read an output from a state file plan Generate and show an execution plan providers Prints a tree of the providers used in the configuration refresh Update local state file against real resources show Inspect Terraform state or plan taint Manually mark a resource for recreation untaint Manually unmark a resource as tainted validate Validates the Terraform files version Prints the Terraform version workspace Workspace management All other commands: 0.12upgrade Rewrites pre-0.12 module source code for v0.12 0.13upgrade Rewrites pre-0.13 module source code for v0.13 debug Debug output management (experimental) force-unlock Manually unlock the terraform state push Obsolete command for Terraform Enterprise legacy (v1) state Advanced state management
Provisionner 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.
[email protected]:~$ mkdir terraform_demo
Accédez au 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.
[email protected]:~$ cd terraform_demo/
[email protected]:~/terraform_demo$ gedit awsec2.tf
provider "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ+T6GY7H"
region = "us-west-2"
}
resource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}Remarque : j’ai changé les clés d’accès et secrètes 😛, vous devez utiliser les vôtres.
À partir de la configuration mentionnée ci-dessus, vous pouvez voir que je mentionne le fournisseur comme AWS. Au sein 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 AMI d’Ubuntu (ami-0a634ae95e11c6f91) et mentionne que le type d’instance doit être t2.micro
Vous pouvez voir à quel point le fichier de configuration est facile et lisible, même si vous n’êtes pas un codeur invétéré.
initialisation de terraform
Maintenant, la première étape consiste à initialiser terraform.
[email protected]:~/terraform_demo$ terraform init Initializing the backend... Initializing provider plugins... - Using previously-installed hashicorp/aws v3.2.0 The following providers do not have any version constraints in configuration, so the latest version was installed. To prevent automatic upgrades to new major versions that may contain breaking changes, we recommend adding version constraints in a required_providers block in your configuration, with the constraint strings suggested below. * hashicorp/aws: version = "~> 3.2.0" 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.
plan de terraform
Vient ensuite l’étape du plan; il créera le graphe d’exécution pour créer et provisionner l’infrastructure.
[email protected]:~/terraform_demo$ terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.
------------------------------------------------------------------------
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)
+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}
+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}
+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}
+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}
Plan: 1 to add, 0 to change, 0 to destroy.
------------------------------------------------------------------------
Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.terraform appliquer
L’étape d’application exécutera le fichier de configuration et lancera une instance AWS EC2. Lorsque vous exécutez la commande d’application, il vous demandera « Voulez-vous effectuer ces actions? », Vous devez taper oui et appuyer sur Entrée.
[email protected]:~/terraform_demo$ terraform apply
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)
+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}
+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}
+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}
+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}
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
aws_instance.terraform_demo: Creating...
aws_instance.terraform_demo: Still creating... [10s elapsed]
aws_instance.terraform_demo: Still creating... [20s elapsed]
aws_instance.terraform_demo: Still creating... [30s elapsed]
aws_instance.terraform_demo: Still creating... [40s elapsed]
aws_instance.terraform_demo: Creation complete after 44s [id=i-0eec33286ea4b0740]
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.Accédez à 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.
terraformer détruire
Enfin, si vous souhaitez supprimer l’infrastructure, vous devez exécuter la commande destroy.
[email protected]:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo: Refreshing state... [id=i-0eec33286ea4b0740]
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
- destroy
Terraform will perform the following actions:
# aws_instance.terraform_demo will be destroyed
- resource "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
}
- metadata_options {
- 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 to add, 0 to change, 1 to destroy.
Do you really want to destroy all resources?
Terraform will destroy all your managed infrastructure, as shown above.
There is no undo. Only 'yes' will be accepted to confirm.
Enter a value: yes
aws_instance.terraform_demo: Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 10s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 20s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 30s elapsed]
aws_instance.terraform_demo: Destruction complete after 34s
Destroy complete! Resources: 1 destroyed.Si vous revérifiez le tableau de bord EC2, vous verrez que l’instance a été résiliée.
Conclusion
Je crois 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 consulter ces logiciels d’automatisation d’infrastructure.
Si vous souhaitez en savoir plus, je vous suggère de vérifier Cours Apprendre DevOps avec Terraform.