Une introduction à Terraform pour les débutants - Tutoriel Terraform

Vous vous demandez, qu'est-ce que Terraform? Découvrons-le.

Infrastructure as Code (IaC) est une terminologie répandue parmi DevOps professionnels. Il s'agit du processus de gestion et de provisionnement de l'infrastructure informatique complète (comprenant des machines physiques et virtuelles) à l'aide de fichiers de définition lisibles par machine. C'est une approche de génie logiciel vers les opérations. Il aide à automatiser le centre de données complet en utilisant des scripts de programmation.

Avec toutes les fonctionnalités qui L'infrastructure comme code fournit, il présente de multiples défis:

• 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 problèmes.

Voici quelques-uns des avantages de l'utilisation de Terraform.

• Fait de l'orchestration, pas seulement de la gestion de la configuration
• Prend en charge plusieurs fournisseurs tels que AWS, Azure, GCP, DigitalOcean et beaucoup plus
• Fournir une infrastructure immuable où la configuration change en douceur
• Utilise un langage facile à comprendre, HCL (langage de configuration HashiCorp)
• Facilement portable vers n'importe quel autre fournisseur
• Prend en charge l'architecture client uniquement, donc pas besoin de gestion de configuration supplémentaire sur un serveur

Terraform Core concepts

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

• Variables: Également utilisé comme variable d'entrée, il s'agit d'une paire clé-valeur utilisée par les modules Terraform pour permettre la personnalisation.
• Provider: C'est 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
• Région: Il se compose 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.
• La source de données: Il est implémenté par les fournisseurs pour renvoyer des informations sur les objets externes à terraform.
• 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ù 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ù il applique les changements d'état réel / actuel de l'infrastructure afin de passer à l'état souhaité.

Terraform Lifecycle

Le cycle de vie de Terraform se compose de - init, plan, vous inscrire et détruire.

• Terraform init initialise le répertoire de travail qui comprend tous les fichiers de configuration
• Le plan Terraform est utilisé pour créer un plan d'exécution pour atteindre l'état souhaité de l'infrastructure. Les changements dans les fichiers de configuration sont effectués afin d'atteindre l'état souhaité.
• Terraform apply effectue 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 corrompues après la phase d'application.

How Terraform Works?

Terraform a deux composants principaux qui composent son architecture:

• Noyau Terraform
• Fournisseurs

Noyau Terraform

Terraform Core utilise deux sources d'entrée pour faire son travail.

Les premier la 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é. Et le seconde source d'entrée est un état dans lequel terraform maintient l'état à jour de la configuration actuelle de l'infrastructure.

Donc, ce que fait le noyau de terraform, c'est qu'il prend les entrées, et il élabore 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 cet é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 les 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 services. C'est également un fournisseur de composants de plus haut niveau comme Kubernetes ou d'autres outils de plate-forme en tant que service, même 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.

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 depuis l'infrastructure jusqu'à l'application.

Faisons quelques trucs pratiques. 👨‍💻

Nous installerons Terraform sur Ubuntu et fournirons une infrastructure très basique.

Install Terraform

Téléchargez le dernier package terraform.

Reportez-vous à page officielle de téléchargement pour obtenir la dernière version du système d'exploitation respectif.

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

geekflare@geekflare:~$ 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.

geekflare@geekflare:~$ sudo mv terraform /usr/local/bin/
[sudo] password for geekflare:
geekflare@geekflare:~$ terraform -v
Terraform v0.13.0

Vous pouvez voir que ce sont les commandes disponibles dans terraform pour l'exécution.

geekflare@geekflare:~$ 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

Provision AWS EC2 Instance Using Terraform

Dans cette démo, je vais lancer une nouvelle Instance AWS EC2 en utilisant Terraform.

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

geekflare@geekflare:~$ 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.

geekflare@geekflare:~$ cd terraform_demo/
geekflare@geekflare:~/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. À l'intérieur du fournisseur, je donne les informations d'identification des utilisateurs 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 je 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 pur et dur.

initialisation de terraform

Maintenant, la première étape consiste à initialiser terraform.

geekflare@geekflare:~/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 terraform

Vient ensuite l'étape du plan; il créera le graphe d'exécution pour créer et provisionner l'infrastructure.

geekflare@geekflare:~/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 applique

L'étape d'application exécutera le fichier de configuration et lancera une instance AWS EC2. Lorsque vous exécutez la commande apply, il vous demandera, "Voulez-vous effectuer ces actions?", Vous devez taper oui et appuyer sur Entrée.

geekflare@geekflare:~/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 une nouvelle instance avec l'ID 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 détruire

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

geekflare@geekflare:~/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 s'est arrêté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 vérifier ces logiciel d'automatisation d'infrastructure.

Si vous souhaitez en savoir plus, je vous suggère de vérifier Cours Apprendre DevOps avec Terraform.