Terragrunt, l'outil de gestion de configurations pour Terraform, a récemment introduit une fonctionnalité majeure : les stacks. Cette nouveauté vise à simplifier et optimiser la gestion des infrastructures en réduisant la répétition et en améliorant l'organisation des configurations. Dans cet article, nous explorerons en détail cette fonctionnalité, en la rendant accessible aux débutants tout en fournissant des informations approfondies pour les experts.
Qu'est-ce qu'une Stack dans Terragrunt ?
Dans le contexte de Terragrunt, une stack est une collection d'unités gérées ensemble. Elle peut représenter un environnement complet, tel que dev, staging ou prod, ou un projet entier. Les stacks permettent de gérer la complexité liée à la gestion de multiples unités à travers différents environnements.
Pourquoi les Stacks ?
Avant l'introduction des stacks, les utilisateurs de Terragrunt devaient souvent gérer un grand nombre de fichiers terragrunt.hcl, ce qui entraînait une répétition et une complexité accrues. Les stacks offrent une abstraction au-dessus de ces fichiers, permettant de regrouper et de gérer plusieurs unités au sein d'une seule configuration. Cette approche réduit la redondance et facilite la maintenance des configurations.
Fonctionnalités clés des Stacks
Fichier terragrunt.stack.hcl
Le fichier terragrunt.stack.hcl est au cœur de cette nouvelle fonctionnalité. Il sert de raccourci pour définir une stack, similaire à la manière dont les unités peuvent être définies directement dans un dossier. Ce fichier permet de centraliser la configuration de plusieurs unités, simplifiant ainsi la gestion et la lisibilité.
Bloc unit
Au sein du fichier terragrunt.stack.hcl, le bloc unit est utilisé pour définir une unité de déploiement. Chaque unité représente un composant d'infrastructure distinct à déployer dans le cadre de la stack. Le bloc unit prend en charge plusieurs arguments, permettant une configuration détaillée et flexible de chaque composant.
Commande terragrunt stack output
Terragrunt introduit la commande terragrunt stack output, qui permet aux utilisateurs de récupérer et d'interagir avec les sorties de plusieurs unités au sein d'une stack. Cette fonctionnalité simplifie la gestion des sorties d'infrastructure en les consolidant en une vue unique.
Avantages des Stacks
Réduction de la répétition : En consolidant les configurations, les stacks diminuent la duplication de code, rendant les configurations plus propres et plus faciles à maintenir.
Gestion simplifiée des dépendances : Les stacks permettent de définir clairement les dépendances entre les unités, assurant que les composants d'infrastructure sont déployés dans le bon ordre.
Visualisation améliorée : Avec les stacks, il est plus facile de visualiser et de comprendre la structure et les relations au sein de l'infrastructure, ce qui facilite la planification et le dépannage.
Considérations actuelles
Bien que les stacks apportent de nombreux avantages, il est important de noter que cette fonctionnalité est encore en phase expérimentale. Pour qu'elle soit stabilisée, plusieurs aspects doivent être abordés, notamment :
Support des commandes stack : Ajouter la prise en charge des commandes
stack run *pour étendre les opérations au niveau des stacks.Support des sorties stack : Intégrer les commandes
stack outputpour améliorer l'interaction avec les sorties des stacks.Support des valeurs de stack : Introduire la gestion des "valeurs" au niveau des stacks pour une configuration plus flexible.
Support des stacks récursives : Permettre la gestion de stacks imbriquées pour des architectures d'infrastructure plus complexes.
Tests d'intégration : Effectuer des tests approfondis pour assurer une gestion fluide des stacks dans divers scénarios opérationnels.
Compatibilité avec le parallélisme : Vérifier la compatibilité avec les indicateurs de parallélisme, en particulier pour les stacks avec des dépendances.
Exemple d'application
Voici un exemple de stack Terragrunt sur Google Cloud Platform (GCP). Cette stack va gérer :
- Un VPC avec un sous-réseau
- Une instance Compute Engine (VM)
- Une base de données Cloud SQL
Structure du projet
On va organiser le projet en trois modules Terraform :
gcp-stack/
│── modules/
│ │── vpc/
│ │ ├── main.tf
│ │ ├── variables.tf
│ │ ├── outputs.tf
│ │── compute/
│ │ ├── main.tf
│ │ ├── variables.tf
│ │ ├── outputs.tf
│ │── database/
│ ├── main.tf
│ ├── variables.tf
│ ├── outputs.tf
│── terragrunt.stack.hcl
│── terragrunt.hcl
1. Définition de la stack (terragrunt.stack.hcl)
Dans Terragrunt, une stack est définie dans le fichier terragrunt.stack.hcl. Voici un exemple :
# Activer la fonctionnalité expérimentale des stacks
experiments = ["stacks"]
stack "gcp-infra" {
description = "Infrastructure GCP avec VPC, VM et base de données"
unit "vpc" {
path = "./modules/vpc"
}
unit "compute" {
path = "./modules/compute"
dependencies = ["vpc"]
}
unit "database" {
path = "./modules/database"
dependencies = ["vpc"]
}
}
Explications
- La stack "gcp-infra" regroupe trois units :
vpc,compute,database - Chaque unit représente un module Terraform
-
computeetdatabasedépendent duvpc, donc ils ne seront déployés qu'après
2. Configuration Terragrunt (terragrunt.hcl)
Ce fichier permet d'éviter les répétitions et de centraliser certaines configurations :
terraform {
source = "${path_relative_to_include()}"
}
remote_state {
backend = "gcs"
config = {
bucket = "my-terraform-state-bucket"
prefix = "${path_relative_to_include()}"
}
}
inputs = {
project_id = "my-gcp-project"
region = "us-central1"
}
3. Module VPC (modules/vpc/main.tf)
Ce module crée un VPC avec un sous-réseau :
resource "google_compute_network" "vpc" {
name = "my-vpc"
auto_create_subnetworks = false
}
resource "google_compute_subnetwork" "subnet" {
name = "my-subnet"
region = var.region
network = google_compute_network.vpc.id
ip_cidr_range = "10.0.0.0/24"
}
output "vpc_id" {
value = google_compute_network.vpc.id
}
output "subnet_id" {
value = google_compute_subnetwork.subnet.id
}
4. Module Compute Engine (modules/compute/main.tf)
Ce module déploie une VM qui utilise le VPC créé :
resource "google_compute_instance" "vm" {
name = "my-vm"
machine_type = "e2-medium"
zone = "${var.region}-a"
boot_disk {
initialize_params {
image = "debian-cloud/debian-11"
}
}
network_interface {
network = var.vpc_id
subnetwork = var.subnet_id
}
}
output "vm_ip" {
value = google_compute_instance.vm.network_interface[0].network_ip
}
5. Module Cloud SQL (modules/database/main.tf)
Ce module crée une base de données Cloud SQL :
resource "google_sql_database_instance" "db" {
name = "my-database"
database_version = "MYSQL_8_0"
region = var.region
settings {
tier = "db-f1-micro"
ip_configuration {
private_network = var.vpc_id
}
}
}
output "db_instance" {
value = google_sql_database_instance.db.connection_name
}
6. Déploiement de la stack
Avec Terragrunt, il est possible d'exécuter toutes les unités de la stack en une seule commande :
terragrunt run-all apply
Cette commande :
- Déploie d'abord le VPC
- Puis la VM et la base de données
- Gère les dépendances automatiquement
Pour voir les outputs de toute la stack :
terragrunt stack output
Les stacks dans Terragrunt offrent une organisation claire et une gestion automatique des dépendances entre les modules. Sur GCP, elles permettent de déployer une infrastructure complète en une seule commande, tout en centralisant la configuration.
Conclusion
L'introduction des stacks dans Terragrunt représente une avancée significative pour la gestion des infrastructures en tant que code. En offrant une abstraction au-dessus des configurations existantes, les stacks simplifient la gestion, réduisent la répétition et améliorent la clarté des infrastructures complexes. Bien que la fonctionnalité soit encore en phase expérimentale, elle offre déjà des outils puissants pour les praticiens du cloud, qu'ils soient novices ou experts.
Pour ceux qui souhaitent explorer davantage cette fonctionnalité, il est recommandé de consulter la documentation officielle de Terragrunt et de participer aux discussions communautaires pour rester informés des évolutions futures.
Top comments (0)