Skip to content

Terraform

HashiCorp Terraform est un outil d'infrastructure as code qui permet de définir à la fois des ressources cloud et sur site dans des fichiers de configuration lisibles par l'homme, versionables, réutilisables et partageables. Il s'utilise dans un workflow cohérent pour provisionner et gérer l'ensemble d'une infrastructure tout au long de son cycle de vie. Terraform peut gérer des composants de bas niveau comme les ressources de calcul, de stockage et de réseau, ainsi que des composants de haut niveau comme les entrées DNS et les fonctionnalités SaaS.

Terraform crée et gère des ressources sur des plates-formes cloud et d'autres services via leurs interfaces de programmation d'applications (API). Les plateformes mettent à disposition des plugins de connexion appelé "provider". Ce sont des binaires go permettant d'interagir avec les API. Les providers permettent à Terraform de fonctionner avec pratiquement n'importe quelle plate-forme ou service possédant une API accessible. Plus de 1700 providers sont accessibles et disponibles via la registry terraform (https://registry.terraform.io/).

Documentation

  • Lien principal: https://www.terraform.io
  • doc terraform: https://www.terraform.io/docs
  • la registry de provider Terraform: https://registry.terraform.io/
  • terraform openstack provider: https://registry.terraform.io/providers/terraform-provider-openstack/openstack/latest/docs
  • terraform openstack rke2: https://github.com/remche/terraform-openstack-rke2

Les 5 étapes

L’objectif principal de Terraform est de déclarer des ressources, qui représentent des objets d’infrastructure. Toutes les autres fonctionnalités de son langage permettent de rendre la définition des ressources plus flexible et pratique.

terraform_workflow

Le workflow de Terraform reposent sur cinq étapes clés : Write/Rédaction, Get/Init, Plan, Apply et Destroy et sur l’enregistrement de l'état de l'infrastructure (state) :

  • Write: Rédaction de la configuration dans un fichier .tf
  • Get/Init: Initialisation de la configuration pour installer les dépendances nécessaires (Get pour les modules locaux).
  • Plan: Audit des changements avec validation
  • Apply: Application des changements à l’infrastructure réelle
  • Destroy: Destruction de toute l'infrastructure

Installation

sous Ubuntu/Debian 

curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install terraform

ou CentOS/Fedora 

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo yum -y install terraform

sous Mac 

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

La CLI terraform

Commandes principales

Commande Description
terraform init Init du répertoire de travail et vérification que les plugins utilisés sont correctement installés.
terraform plan Création du plan d’exécution. Terraform va indiquer quelles actions il doit effectuer pour arriver au résultat décrit dans le fichier de configuration.
terraform apply Mise en place de l’infrastructure désirée
terraform destroy Destruction de l’infrastructure
terraform validate Vérification de la validité de la configuration

Commandes utiles

Commande Description
terraform get Installation et mise à jour des modules et sous-modules
terraform console Cette commande permet de faire du débogage, avant de créer un plan ou de l’appliquer.
terraform refresh Mise à jour de l'état avec les données du système distant
terraform import Importation d'une infrastructure existante
terraform fmt Reformat your configuration in the standard style
terraform force-unlock Release a stuck lock on the current workspace
terraform graph Generate a Graphviz graph of the steps in an operation
terraform login Obtain and save credentials for a remote host
terraform logout Remove locally-stored credentials for a remote host
terraform output Show output values from your root module
terraform providers Show the providers required for this configuration
terraform show Show the current state or a saved plan
terraform state Advanced state management
terraform test Experimental support for module integration testing
terraform taint Mark a resource instance as not fully functional
terraform untaint Remove the 'tainted' state from a resource instance
terraform version Show the current Terraform version and the current providers version
terraform workspace Workspace management

Les fichiers de Terraform

Les templates

Il existe deux types de fichiers template dans terraform|

file.tf : fichier de description de l'infrastructure file.tfvars : fichier de variables passées à un fichier template

les fichiers .tf vont décrire mes ressources à créer pour une infrastructure.

resources = une brique d'infra (instances, containers, switch...) et un cycle de vie : création/lecture/modif/suppression

Généralement un dossier terraform va s'articuler sur l'architecture suivante :

terraform
  ├── main.tf        # Fichier principal qui décrit l'infrastructure
  ├── outputs.tf     # Tous les attributs en sortie
  ├── variables.tf   # Arguments d'entrée et leur valeur par défaut
  ├── locals.tf      # Valeurs spécifiques comme .tfvars
  └── versions.tf    # Providers utilisés et leur version

Tous ces fichiers sont facultatifs et les informations contenues dedans peuvent être mise dans un seul fichier. Les noms n'ont pas d'importance. Terraform lira tous les fichiers avec un .tf et les regroupera dans son plan.

Cette architecture peut être reprise dans des sous-dossiers que l'on appelle des modules. On ajoute à la racine du projet un dossier modules qui contiendra des dossiers pour chaque module.

Il est conseillé d'essayer de créer pas plus de 20 ressources par modules.

Les modules sont ensuite appelés dans le main principal dans des blocs notés "module"

Les states

Terraform garde une trace de l'infrastructure réelle dans un fichier d'état *.tfstate qui agit comme une source de vérité. Il utilise celui-ci pour déterminer les modifications à apporter à votre infrastructure afin qu'elle corresponde à votre configuration.

Terraform va créer plusieurs fichiers lors de la création de l'infrastructure, notamment le fichier d'état terraform.tfstate.
Et lors d'un deuxième déploiement de la même configuration, il va créer un fichier terraform.tfstate.backup qui est une sauvegarde du précédent déploiement. Cela peut permettre de faire un retour en arrière si besoin.

Important: toujours faire un terraform plan avant un terraform apply pour connaitre les modifications qui seront apportés. Terraform indiquera les changements entre ce qui est désiré et les données du fichier terraform.tfstate.

Vue l'importance des fichiers state, terraform permet la sauvegarde à distance de ces fichiers. Cela permet d'avoir un état d'infrastructure partagé entre membre d'une même équipe. Terraform peut utiliser des buckets S3, consul, postgres etc...

Le fichier hcl

Ce fichier est une fichier de travail pour terraform regroupant les hash pour les binaires des providers. Il est créer par terraform init. Les binaires en go sont dans le dossier .terraform/providers/registry.terraform.io. Ils sont téléchargés lors de l'initialisation du projet.

Premiers pas avec Terraform

Mon premier fichier .tf

Prenons un exemple simple, nous allons prendre un hello world:

output "text" {
 value = "hello world"
}

Cette instruction ne fait qu'afficher après une application du plan le texte "hello word" dans la console.

Création d'un fichier contenant des informations

Exemple: 

variable "mylist" {
  default = ["line1", "line2", "line3"]
}

resource "local_file" "list" {
    content  = join("\n", ["nom1", "nom2", "nom3"])
    filename = "list_nom"
}

resource "local_file" "list2" {
    content  = join("\n", var.mylist)
    filename = "list_nom2"
}

resource "local_file" "list_index" {
    count = 2
    content  = join("\n", var.mylist)
    filename = "./list_nom_index_${count.index}"
}

Dans cet exemple, nous créons une variable "mylist" dont nous attribuons une valeur par l'instruction "default" qui est une liste de 3 chaines de caractères.

Nous allons ensuite créer 3 ressources 'local_file'. Cette ressource provient du provider "local" qui est intégré nativement dans terraform et qui permet d'interagir avec le système hôte en local.
local_file permet de créer un fichier sur le système local. Les arguments "content" et "filename" fournissent respectivement le contenu du fichier et le nom celui-ci (il est possible d'utiliser les caractères ., .. et / pour indiquer l'emplacement du fichier )

Il existe plusieurs autres arguments pour cette ressource (https://registry.terraform.io/providers/hashicorp/local/2.2.3)

Utilisation de count
L'argument count dans la 3ème ressource de l'exemple indique qu'il est possible de boucler la création de la ressource (2 fois). L'ajout de count.index dans le nom du fichier permet de créer 3 fichiers avec des noms différents.
count est l'un des paramètres des blocs communs à tous les blocs. La notion de bloc est traitée dans le chapitre suivant.