Terraform

Terraform est une plateforme d'Infrastructure as Code (IaC) qui permet de définir, provisionner et gérer l'infrastructure cloud à travers des fichiers de configuration déclaratifs. Utilisant le langage HCL (HashiCorp Configuration Language), Terraform automatise le déploiement d'infrastructures complexes sur plus de 3000 fournisseurs cloud et services, garantissant reproductibilité, versioning et collaboration entre équipes.

Fondements de Terraform

• Architecture déclarative : définition de l'état souhaité plutôt que des étapes d'exécution
• Gestion d'état (state) : suivi précis des ressources déployées et de leurs configurations
• Providers multiples : support natif d'AWS, Azure, GCP, Kubernetes et centaines d'autres services
• Plan d'exécution : prévisualisation des changements avant application effective

Avantages stratégiques

• Reproductibilité garantie : infrastructures identiques en dev, staging et production
• Versioning Git : historique complet des modifications d'infrastructure avec rollback possible
• Collaboration équipe : revue de code et validation via pull requests pour les changements infra
• Réduction des erreurs : élimination des configurations manuelles et dérives de configuration
• Multi-cloud facilité : syntaxe unifiée pour gérer plusieurs fournisseurs cloud simultanément
• Documentation vivante : le code Terraform documente automatiquement l'architecture

Exemple concret d'infrastructure AWS

# Configuration du provider AWS
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC pour l'isolation réseau
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.project_name}-vpc"
    Environment = var.environment
  }
}

# Subnet public pour les ressources accessibles
resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "${var.aws_region}a"
  map_public_ip_on_launch = true

  tags = {
    Name = "${var.project_name}-public-subnet"
  }
}

# Instance EC2 avec configuration automatisée
resource "aws_instance" "web_server" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = var.instance_type
  subnet_id     = aws_subnet.public.id

  vpc_security_group_ids = [aws_security_group.web.id]

  user_data = <<-EOF
              #!/bin/bash
              apt-get update
              apt-get install -y nginx
              systemctl start nginx
              EOF

  tags = {
    Name        = "${var.project_name}-web"
    Environment = var.environment
  }
}

# Security Group pour contrôler les accès
resource "aws_security_group" "web" {
  name        = "${var.project_name}-web-sg"
  description = "Security group for web server"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Output pour récupérer l'IP publique
output "web_server_ip" {
  value       = aws_instance.web_server.public_ip
  description = "Adresse IP publique du serveur web"
}

variable "aws_region" {
  description = "Région AWS pour le déploiement"
  type        = string
  default     = "eu-west-1"
}

variable "project_name" {
  description = "Nom du projet pour le tagging"
  type        = string
}

variable "environment" {
  description = "Environnement de déploiement"
  type        = string
  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "Environment doit être dev, staging ou prod."
  }
}

variable "instance_type" {
  description = "Type d'instance EC2"
  type        = string
  default     = "t3.micro"
}

Mise en œuvre d'un workflow Terraform

1. Initialisation du projet : exécuter `terraform init` pour télécharger les providers nécessaires
2. Validation de la configuration : utiliser `terraform validate` pour vérifier la syntaxe HCL
3. Planification des changements : générer le plan avec `terraform plan` pour prévisualiser les modifications
4. Revue du plan : analyser les ressources à créer, modifier ou détruire avant application
5. Application des changements : déployer avec `terraform apply` après validation du plan
6. Gestion de l'état : stocker le fichier state dans un backend distant (S3, Terraform Cloud) pour la collaboration
7. Modules réutilisables : créer des modules Terraform pour standardiser les patterns d'infrastructure
8. CI/CD Integration : automatiser les déploiements via GitLab CI, GitHub Actions ou Jenkins

Outils et écosystème associés

• Terraform Cloud/Enterprise : plateforme SaaS de HashiCorp pour gestion collaborative et governance
• Terragrunt : wrapper pour gérer les configurations Terraform DRY et multi-environnements
• tflint : linter pour détecter les erreurs et appliquer les bonnes pratiques Terraform
• Infracost : estimation des coûts cloud directement depuis le code Terraform
• terraform-docs : génération automatique de documentation à partir des modules
• Checkov : scanner de sécurité pour détecter les vulnérabilités et misconfigurations
• Atlantis : automatisation des workflows Terraform via pull requests GitHub/GitLab

Terraform transforme la gestion d'infrastructure en pratique logicielle rigoureuse, permettant aux équipes DevOps de déployer des environnements complexes en quelques minutes avec une traçabilité complète. En standardisant l'infrastructure via du code versionné, les organisations réduisent significativement les erreurs de configuration, accélèrent les déploiements et garantissent la conformité entre environnements, tout en maîtrisant les coûts cloud grâce à une visibilité totale sur les ressources provisionnées.