5 hacks et tips pour tirer le maximum de Terraform

Même si nos conseils vous aideront, une formation Terraform reste le meilleur moyen d’acquérir une maitrise complète de l’outil. Vous y apprendrez l’utilisation et la configuration de Terraform avec des outils cloud afin d’automatiser votre infrastructure de manière performante.

L’équipe Ambient IT

Utiliser « Count » comme boutons On-Off des ressources

Le grand avantage de Terraform est sa capacité à transformer des blocs de ressources et de données en modules réutilisables. Dans le cadre de ce processus, vous aurez souvent besoin d’un moyen de désactiver la création de certaines ressources en fonction d’une variable d’entrée.

S’il n’existe pas de commande telle que « enabled = false » sur Terraform, count peut être utilisé pour créer un tableau de ressources. Ainsi, en définissant « count = 0« , vous créerez un tableau de ressources de longueur 0, ce qui désactivera effectivement la ressource. Vous n’aurez qu’à définir « count = 1 » pour les réactiver.

resource "aws_launch_configuration" "this" {
  count = var.create_lc ? 1 : 0

  image_id                    = var.image_id
  instance_type               = var.instance_type
  # ...
}

Il faut néanmoins noter qu’en définissant count, la ressource devient alors un tableau. Si vous avez besoin d’accéder aux propriétés de cette ressource, vous devrez alors le faire sous la forme d’un tableau.

Exécuter des commandes locales avec null_ressource

Lors de l’utilisation de Terraform, il n’est pas rare d’avoir besoin d’exécuter une commande localement sur la machine qui l’exécute. Ce que peu de débutants savent, c’est qu’il est possible de le faire en utilisant « null_resource« . Elle agit alors comme une ressource normale dans le graphe Terraform, mais ne fait rien en réalité.

Cette technique est particulièrement utile parce que « null_resource » peut exécuter des provisionneurs comme n’importe quelle ressource normale, qui exécute une commande sur une machine locale. Vous pouvez contrôler le moment où ce provisionneur est exécuté en passant une carte de déclencheurs.

Décomposer les fournisseurs en exécutions échelonnées

Lorsque vous gérez de grandes infrastructures dans Terraform, il est généralement conseillé de créer un service, puis configurer ce service via un fournisseur distinct. C’est un outil très doué pour gérer les dépendances entre les ressources.

Terraform gère parfaitement les ressources, mais éprouve des difficultés lorsqu’il doit gérer une situation où un fournisseur dépend de la création d’une ressource dans un autre fournisseur.

Par exemple, si vous devez créer un cluster Kubernetes à l’aide de Terraform, puis configurer ce même cluster à l’aide du fournisseur Kubernetes une fois qu’il a été créé, cela causera sans doute des problèmes. Terraform essaiera de se connecter à tous les provissionneurs définis et de lire l’état des ressources. Ce qu’il ne pourra pas faire pour Kubernetes, car le cluster n’existe pas encore.

Ce problème de « l’œuf ou la poule » peut être résolu en divisant votre projet Terraform en projets plus petits qui peuvent être exécutés en chaîne. En utilisant l’état distant, vous pouvez importer l’état Terraform des exécutions précédentes à partir de la source de données « terraform_remote_state« .

Cela permet aux sorties des exécutions terraforms de devenir des entrées pour les exécutions suivantes.

Gérer les dépendances de fichiers entre ressources avec Templatefile

Si Terraform permet facilement de prendre les sorties d’une ressource et de les acheminer en tant qu’entrée vers une autre, il rencontre des difficultés lorsqu’une ressource écrit un fichier sur le système de fichiers local qu’une autre ressource doit lire en tant qu’entrée.

Cette pratique est loin d’être idéale et ne correspond pas vraiment aux bonnes pratiques de l’outil si l’on s’arrête à la théorie. Cependant, dans la réalité, les fournisseurs écrivent parfois des sorties dans des fichiers locaux au lieu de renvoyer la sortie sous forme de chaîne. Terraform n’a alors aucun moyen de déterminer qu’il existe une dépendance entre les ressources lorsqu’elle prend la forme d’une écriture et d’une lecture à partir d’un fichier local.

La fonction templatefile() permet à Terraform de prendre conscience de cette dépendance. Elle permet de lire un fichier à partir du système de fichiers et substitue toutes les variables que vous lui passez dans le fichier au fur et à mesure de la lecture.

Utiliser les modules pour les réutiliser

La réutilisation est l’un des principes fondamentaux de Terraform. Créer des modèles personnalisés qui encapsulent les configurations de ressources vous permettent de réutiliser facilement du code, et ainsi de gagner énormément de temps dans vos opérations.

module "my_vpc" {
  source     = "./modules/vpc"
  cidr_block = "10.0.0.0/16"
  region     = "us-east-1"
}

module "my_subnet" {
  source      = "./modules/subnet"
  vpc_id      = module.my_vpc.vpc_id
  cidr_block  = "10.0.1.0/24"
  subnet_name = "MySubnet"
}
variable "cidr_block" {
  type        = string
  description = "CIDR block for the VPC"
}

variable "region" {
  type        = string
  description = "AWS Region"
}
provider "aws" {
  region = var.region
}

resource "aws_vpc" "main" {
  cidr_block = var.cidr_block
  tags = {
    Name = "MyVPC"
  }
}

output "vpc_id" {
  value = aws_vpc.main.id
}

Dans cet exemple, Le Module VPC est utilisé pour créer un VPC dans AWS. Le CIDR block et la région AWS sont passés comme variables. L’ID du VPC créé est exposé en tant que sortie (output) pour pouvoir être utilisé par d’autres ressources ou modules.

En espérant que ces techniques vous servent dans votre utilisation quotidienne de Terraform. N’hésitez pas à partager les vôtres en commentaire.