Terraform AWS transforme radicalement la façon dont les organisations gèrent leurs environnements cloud grâce à l’infrastructure as code (IaC). Fini le temps où les équipes configuraient manuellement des serveurs, avec les erreurs humaines, la lenteur et l’impossibilité de reproduire les configurations. L’outil d’automatisation développé par HashiCorp permet aux DevOps engineers de définir, versionner et déployer leur infrastructure AWS comme du code applicatif. Les avantages sont considérables : reproductibilité parfaite des environnements, scalabilité simplifiée, collaboration fluide entre équipes, versioning complet avec Git et documentation vivante évoluant avec votre infrastructure.
Dans cet article technique, nous explorons en profondeur comment utiliser Terraform AWS, de l’installation à la création de clusters EKS, en passant par la gestion de l’état et les meilleures pratiques essentielles pour tout professionnel cloud moderne. Si vous aspirez à devenir un sysadmin compétent, maîtriser l’infrastructure as code est devenu incontournable.

🎓 Devenez un expert cloud recherché avec notre formation administrateur réseau → Maîtrisez Terraform, Kubernetes, AWS et l'automatisation infrastructure

Qu'est-ce que Terraform et comment ça fonctionne ?

Définition de Terraform

Terraform est un outil open source d'infrastructure as code (IaC) créé par HashiCorp qui révolutionne la gestion des ressources cloud. Le concept d'Infrastructure as Code consiste à gérer l'infrastructure via du code plutôt que par des processus manuels, permettant ainsi d'appliquer les mêmes principes de développement logiciel à l'infrastructure elle-même.

L'une des forces majeures de Terraform réside dans sa nature multi-cloud : il supporte non seulement AWS, mais également Azure, Google Cloud Platform, et plus de 3000 providers différents. Cette approche déclarative change la donne : vous décrivez l'état souhaité de votre infrastructure, et Terraform détermine automatiquement les actions nécessaires pour atteindre cet état.

Pourquoi Terraform est incontournable :

• Reproductibilité : Déployez exactement la même infrastructure dans différents environnements (development, staging, production) sans variation
• Versioning : Votre infrastructure est versionnée avec Git, offrant un historique complet des modifications et la possibilité de rollback
• Collaboration : Toute l'équipe travaille sur le même code source, éliminant les silos de connaissance
• Documentation : Le code Terraform devient la documentation technique de votre infrastructure, toujours à jour

Architecture et concepts clés

Pour maîtriser Terraform, il est essentiel de comprendre ses composants principaux :

Provider : Plugin permettant à Terraform d'interagir avec un cloud provider spécifique (AWS, Azure, GCP). Le provider aws donne accès à l'ensemble des services Amazon Web Services.

Resource : Représente un composant d'infrastructure concret comme une instance EC2, un VPC, un bucket S3, ou un cluster EKS. Chaque ressource est définie dans un fichier de configuration avec ses attributs spécifiques.

Module : Ensemble réutilisable de ressources permettant d'encapsuler et de standardiser des configurations complexes. Les modules facilitent le partage de bonnes pratiques au sein des équipes.

State : Fichier représentant l'état actuel de votre infrastructure. Le terraform state file contient le mapping entre vos déclarations Terraform et les ressources réelles déployées dans le cloud.

Plan : Prévisualisation des changements que Terraform va appliquer à votre infrastructure. La commande terraform plan permet de valider les modifications avant leur exécution.

Apply : Application effective des changements à l'infrastructure. Terraform apply exécute les actions nécessaires pour atteindre l'état souhaité.

Workflow Terraform :Write (écrire le code) → Init (initialiser le provider) → Plan (prévisualiser) → Apply (appliquer) → Destroy (détruire si nécessaire)

Terraform AWS vs CloudFormation vs Pulumi

Le choix d’un outil d’infrastructure as code dépend de vos besoins spécifiques et de votre environnement cloud. Si vous travaillez sur Amazon Web Services, la comparaison entre Terraform AWS et CloudFormation est incontournable. Voici un tableau comparatif pour vous guider :

Terraform AWS se distingue par sa flexibilité multi-cloud et son approche ouverte, permettant d’automatiser le déploiement d’infrastructures complexes sur AWS mais aussi sur d’autres plateformes cloud. Sa communauté très active, sa syntaxe claire et ses modules réutilisables en font un outil incontournable pour tout ingénieur DevOps souhaitant unifier ses workflows cloud.

Comment installer et configurer Terraform AWS pour AWS Cloud

L’installation de Terraform AWS est la première étape pour gérer vos infrastructures Amazon Web Services via l’infrastructure as code. Une fois installé, Terraform AWS vous permet de provisionner, modifier et versionner vos ressources AWS de manière automatisée et sécurisée.

Installation de Terraform AWS sur Linux (Ubuntu/Debian)

Pour installer Terraform AWS sur Linux :

# Ajouter le repository HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

# Installer Terraform AWS
sudo apt update
sudo apt install terraform

# Vérifier l'installation
terraform --version

Installation de Terraform AWS sur macOS

# Via Homebrew
brew tap hashicorp/tap
brew install hashicorp/tap/terraform

# Vérifier l'installation
terraform --version

Installation de Terraform AWS sur Windows

1. Télécharger le binaire depuis terraform.io/downloads

2. Extraire le fichier ZIP

3. Ajouter le dossier au PATH système

4. Vérifier l’installation :

terraform --version

Configurer AWS CLI pour Terraform AWS

Avant d’utiliser Terraform AWS, il est essentiel de configurer AWS CLI pour que Terraform puisse accéder aux ressources AWS de manière sécurisée.

Installer AWS CLI pour Terraform AWS

# Linux
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Vérifier l'installation
aws --version

Configurer les credentials AWS pour Terraform AWS

aws configure

Entrez vos informations AWS :

• AWS Access Key ID

• AWS Secret Access Key

• Default region name

• Default output format

Vérifiez la configuration avec :

aws sts get-caller-identity

Cette vérification confirme que Terraform AWS est correctement configuré et peut interagir avec vos ressources AWS pour créer, modifier et gérer votre infrastructure cloud.

Comment configurer le provider AWS dans Terraform ?

Structure d'un projet Terraform

Une organisation claire de votre projet Terraform facilite la maintenance et la collaboration. Voici l'architecture recommandée :

projet-terraform/
├── main.tf              # Ressources principales
├── variables.tf         # Déclaration des variables
├── outputs.tf          # Outputs exposés
├── terraform.tfvars    # Valeurs des variables (ne pas committer si sensible)
├── provider.tf         # Configuration provider
└── .gitignore          # Exclure .terraform/ et *.tfstate

Cette structure modulaire sépare les responsabilités : la configuration du fournisseur, la définition des ressources, la gestion des variables et les sorties utilisables par d'autres outils ou modules.

Configuration du provider AWS

Le fichier provider.tf établit la connexion entre Terraform et votre compte AWS :

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

provider "aws" {
  region = var.aws_region
  
  # Optionnel : profil AWS CLI spécifique
  # profile = "mon-profil"
  
  # Tags par défaut appliqués à toutes les ressources
  default_tags {
    tags = {
      Environment = var.environment
      ManagedBy   = "Terraform"
      Project     = var.project_name
    }
  }
}

Le bloc required_providers spécifie la source et la version du provider aws. La notation ~> 5.0 autorise les mises à jour mineures automatiques tout en évitant les changements majeurs potentiellement incompatibles.

Fichier variables.tf :

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

variable "environment" {
  description = "Environnement (dev, staging, prod)"
  type        = string
  default     = "dev"
}

variable "project_name" {
  description = "Nom du projet"
  type        = string
  default     = "mon-projet"
}

Ces variables rendent votre configuration flexible et réutilisable dans différents contextes sans modifier le code principal.

Initialiser le projet

Une fois vos fichiers de configuration créés, initialisez votre projet :

# Initialiser Terraform (télécharge les providers)
terraform init

# Valider la syntaxe du code
terraform validate

# Formater automatiquement le code
terraform fmt

La commande terraform init télécharge le provider AWS et prépare votre environnement. Le résultat affiche la version du provider installé et confirme l'initialisation réussie.

💼 Lancez votre carrière cloud avec notre formation administrateur réseau → Terraform, AWS, Kubernetes et DevOps

Comment créer une instance EC2 avec Terraform ?

Créer une instance EC2 basique

La création d'une instance ec2 avec Terraform illustre parfaitement la puissance de l'infrastructure as code. Commençons par un exemple complet dans le fichier main.tf :

# Data source : récupérer l'AMI Ubuntu la plus récente
data "aws_ami" "ubuntu" {
  most_recent = true
  owners      = ["099720109477"] # Canonical (Ubuntu)

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }
}

# Création de l'instance EC2
resource "aws_instance" "web_server" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = var.instance_type
  
  tags = {
    Name = "${var.project_name}-web-server"
  }

  # Configuration du stockage
  root_block_device {
    volume_size = 20
    volume_type = "gp3"
  }

  # User data pour configuration initiale
  user_data = <<-EOF
              #!/bin/bash
              apt update
              apt install -y nginx
              systemctl start nginx
              systemctl enable nginx
              EOF
}

Ce code terraform utilise un data source pour récupérer automatiquement l'AMI Ubuntu la plus récente, garantissant que votre instance utilise toujours une image à jour. La ressource aws_instance définit le type d'instance (via une variable pour la flexibilité), configure le stockage, et inclut un script user_data qui installe et démarre nginx automatiquement au lancement.

Ajout dans variables.tf :

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

Fichier outputs.tf :

output "instance_id" {
  description = "ID de l'instance EC2"
  value       = aws_instance.web_server.id
}

output "instance_public_ip" {
  description = "IP publique de l'instance"
  value       = aws_instance.web_server.public_ip
}

Les outputs permettent d'exposer des informations sur les ressources créées, facilitant leur utilisation par d'autres outils ou modules.

Déployer l'infrastructure

Le workflow de déploiement suit une séquence logique garantissant la sécurité :

# 1. Plan : prévisualiser les changements
terraform plan

# Output exemple :
# Terraform will perform the following actions:
#   # aws_instance.web_server will be created
#   + resource "aws_instance" "web_server" {
#       + ami           = "ami-0c55b159cbfafe1f0"
#       + instance_type = "t3.micro"
#       ...
#     }
# Plan: 1 to add, 0 to change, 0 to destroy.

# 2. Apply : créer les ressources
terraform apply

# Confirmer avec 'yes'

# 3. Vérifier les outputs
terraform output

La commande terraform plan est cruciale : elle affiche un aperçu détaillé de toutes les actions que Terraform va exécuter, permettant de détecter les erreurs avant leur application.

Ajouter un Security Group

Une instance ec2 sans configuration réseau appropriée reste vulnérable. Ajoutons un security group pour contrôler le trafic :

# Security group pour autoriser HTTP et SSH
resource "aws_security_group" "web_sg" {
  name        = "${var.project_name}-web-sg"
  description = "Security group pour serveur web"

  # Règle entrante : HTTP
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow HTTP"
  }

  # Règle entrante : HTTPS
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow HTTPS"
  }

  # Règle entrante : SSH
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.admin_ip]
    description = "Allow SSH from admin IP"
  }

  # Règle sortante : tout autoriser
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

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

# Modifier l'instance pour utiliser le security group
resource "aws_instance" "web_server" {
  ami                    = data.aws_ami.ubuntu.id
  instance_type          = var.instance_type
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  
  # ... reste de la configuration
}

Cette configuration sécurise votre serveur web en autorisant uniquement le trafic HTTP, HTTPS et SSH (depuis une IP spécifique). Les attributs from_port et to_port définissent les plages de ports, tandis que cidr_blocks contrôle les adresses IP autorisées. Pour comprendre les concepts réseau sous-jacents, consultez notre guide sur c'est quoi wan.

Comment créer un VPC complet avec Terraform ?

Architecture VPC AWS

Un Virtual Private Cloud (VPC) constitue le fondement de toute infrastructure réseau AWS. Terraform simplifie considérablement la création de VPC complexes avec subnets publics et privés.

Fichier main.tf - Configuration VPC :

# VPC
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"
  }
}

# Subnet public
resource "aws_subnet" "public" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  map_public_ip_on_launch = true

  tags = {
    Name = "${var.project_name}-public-subnet-${count.index + 1}"
  }
}

# Subnet privé
resource "aws_subnet" "private" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 10}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  tags = {
    Name = "${var.project_name}-private-subnet-${count.index + 1}"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "${var.project_name}-igw"
  }
}

# Route table pour subnet public
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }

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

# Association route table <> subnet public
resource "aws_route_table_association" "public" {
  count          = 2
  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

Cette configuration crée une architecture réseau complète : un VPC avec un bloc CIDR /16, deux subnets publics et deux subnets privés répartis dans différentes zones de disponibilité pour la haute disponibilité, un Internet Gateway pour la connectivité externe, et une table de routage configurant le trafic sortant.

L'utilisation de count permet de créer plusieurs ressources similaires de manière élégante, évitant la duplication de code.

Data sources utiles

Les data sources permettent de récupérer des informations dynamiques sur votre environnement AWS :

# Récupérer les zones de disponibilité
data "aws_availability_zones" "available" {
  state = "available"
}

# Récupérer l'account ID
data "aws_caller_identity" "current" {}

Ces data sources rendent votre code portable entre différentes régions AWS, s'adaptant automatiquement aux zones de disponibilité locales.

Comment déployer un cluster EKS avec Terraform ?

Configuration EKS de base

Amazon Elastic Kubernetes Service (EKS) simplifie le déploiement et la gestion de clusters Kubernetes. Terraform automatise entièrement cette configuration complexe.

Fichier eks.tf :

# IAM role pour le cluster EKS
resource "aws_iam_role" "eks_cluster" {
  name = "${var.project_name}-eks-cluster-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "eks.amazonaws.com"
      }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "eks_cluster_policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
  role       = aws_iam_role.eks_cluster.name
}

# Cluster EKS
resource "aws_eks_cluster" "main" {
  name     = "${var.project_name}-eks"
  role_arn = aws_iam_role.eks_cluster.arn
  version  = "1.28"

  vpc_config {
    subnet_ids = concat(
      aws_subnet.public[*].id,
      aws_subnet.private[*].id
    )
  }

  depends_on = [
    aws_iam_role_policy_attachment.eks_cluster_policy
  ]

  tags = {
    Name = "${var.project_name}-eks-cluster"
  }
}

# Node group IAM role
resource "aws_iam_role" "eks_nodes" {
  name = "${var.project_name}-eks-node-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "ec2.amazonaws.com"
      }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "eks_worker_node_policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "eks_cni_policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "eks_container_registry" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
  role       = aws_iam_role.eks_nodes.name
}

# Managed node group
resource "aws_eks_node_group" "main" {
  cluster_name    = aws_eks_cluster.main.name
  node_group_name = "${var.project_name}-node-group"
  node_role_arn   = aws_iam_role.eks_nodes.arn
  subnet_ids      = aws_subnet.private[*].id

  scaling_config {
    desired_size = 2
    max_size     = 4
    min_size     = 1
  }

  instance_types = ["t3.medium"]

  depends_on = [
    aws_iam_role_policy_attachment.eks_worker_node_policy,
    aws_iam_role_policy_attachment.eks_cni_policy,
    aws_iam_role_policy_attachment.eks_container_registry
  ]

  tags = {
    Name = "${var.project_name}-eks-nodes"
  }
}

Cette configuration crée un cluster eks complet avec les IAM roles nécessaires, un cluster security group automatique, et un managed node group évolutif. Le bloc depends_on garantit que toutes les dépendances sont créées dans le bon ordre.

Ajout dans outputs.tf :

output "eks_cluster_endpoint" {
  description = "Endpoint du cluster EKS"
  value       = aws_eks_cluster.main.endpoint
}

output "eks_cluster_name" {
  description = "Nom du cluster EKS"
  value       = aws_eks_cluster.main.name
}

Déployer un cluster Kubernetes via Terraform plutôt que manuellement garantit la reproductibilité et facilite les mises à jour d'infrastructure.

⚡ Devenez freelance IT avec des compétences cloud ! Notre formation Tech Support vous prépare à devenir Freelance IT → Terraform, Kubernetes, DevOps

Comment gérer l'état des ressources avec Terraform ?

Qu'est-ce que le Terraform State ?

Le state file (terraform.tfstate) constitue l'élément central du fonctionnement de Terraform. Ce fichier JSON contient l'état actuel complet de votre infrastructure et remplit plusieurs rôles essentiels :

• Mapping : Établit la correspondance entre les ressources Terraform et les ressources réelles dans le cloud
• Performance : Met en cache les attributs des ressources, évitant des appels API répétitifs
• Collaboration : Permet à plusieurs développeurs de travailler sur la même infrastructure
• Tracking : Suit les métadonnées et dépendances entre ressources

Le terraform state représente la source de vérité sur l'état de votre infrastructure.

State local vs State distant

State local (par défaut) :

# Fichiers créés automatiquement
terraform.tfstate
terraform.tfstate.backup

❌ Problèmes du state local :

• Impossible de collaborer efficacement en équipe
• Risque élevé de perte de données (suppression accidentelle)
• Absence de locking (risque de conflits lors de modifications simultanées)
• Secrets stockés en clair dans le fichier
• Pas de versioning des changements d'état

Configurer un backend S3 (recommandé)

Pour une utilisation professionnelle, un backend distant s'impose. AWS S3 combiné avec DynamoDB offre une solution robuste :

Fichier backend.tf :

terraform {
  backend "s3" {
    bucket         = "mon-projet-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "eu-west-1"
    encrypt        = true
    dynamodb_table = "terraform-state-lock"
  }
}

Créer le bucket S3 et la table DynamoDB :

# S3 bucket pour le state
resource "aws_s3_bucket" "terraform_state" {
  bucket = "mon-projet-terraform-state"

  lifecycle {
    prevent_destroy = true
  }

  tags = {
    Name = "Terraform State"
  }
}

resource "aws_s3_bucket_versioning" "terraform_state" {
  bucket = aws_s3_bucket.terraform_state.id

  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "terraform_state" {
  bucket = aws_s3_bucket.terraform_state.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

# DynamoDB table pour le locking
resource "aws_dynamodb_table" "terraform_locks" {
  name         = "terraform-state-lock"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"

  attribute {
    name = "LockID"
    type = "S"
  }

  tags = {
    Name = "Terraform State Lock"
  }
}

Cette configuration assure le chiffrement du state file, le versioning pour l'historique des modifications, et le locking via DynamoDB pour éviter les conflits.

Commandes de gestion du state

Terraform fournit des commandes puissantes pour manipuler le state :

# Lister les ressources dans le state
terraform state list

# Voir les détails d'une ressource
terraform state show aws_instance.web_server

# Importer une ressource existante
terraform import aws_instance.web_server i-1234567890abcdef0

# Supprimer une ressource du state (sans la détruire)
terraform state rm aws_instance.web_server

# Déplacer une ressource dans le state
terraform state mv aws_instance.web_server aws_instance.web_server_new

# Synchroniser le state avec la réalité
terraform refresh

La commande terraform import permet d'intégrer des ressources créées manuellement dans votre gestion Terraform, tandis que terraform state rm retire une ressource de la gestion sans la supprimer physiquement.

Quelles sont les meilleures pratiques Terraform ?

Organisation du code

✅ Structure modulaire :

projet/
├── modules/
│   ├── vpc/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   └── outputs.tf
│   ├── ec2/
│   └── eks/
├── environments/
│   ├── dev/
│   │   ├── main.tf
│   │   ├── terraform.tfvars
│   │   └── backend.tf
│   ├── staging/
│   └── prod/
└── README.md

Cette architecture sépare les modules réutilisables des environnements spécifiques, facilitant la maintenance et réduisant la duplication.

✅ Nommage des ressources :

# Format : <project>-<environment>-<resource>-<name>
resource "aws_instance" "web" {
  tags = {
    Name = "${var.project}-${var.environment}-ec2-web"
  }
}

Un nommage cohérent améliore considérablement la lisibilité et la gestion à long terme.

Sécurité

✅ Ne jamais committer :

# .gitignore
*.tfstate
*.tfstate.backup
*.tfvars  # Si contient des secrets
.terraform/
.terraform.lock.hcl

Le fichier .gitignore protège vos credentials et votre state file contre les fuites accidentelles.

✅ Utiliser des variables pour les secrets :

# variables.tf
variable "db_password" {
  description = "Mot de passe de la base de données"
  type        = string
  sensitive   = true
}

# Passer via variable d'environnement
# export TF_VAR_db

Retrouver de nombreuses vidéos de cours sur la chaîne Youtube Formip :

provider "aws" {
  region = "eu-west-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "terraform-ec2-demo"
  }
}

terraform init
terraform apply

provider "aws" {
  region     = "eu-west-3"
  access_key = var.aws_access_key
  secret_key = var.aws_secret_key
}

export AWS_ACCESS_KEY_ID="votre_cle"
export AWS_SECRET_ACCESS_KEY="votre_secret"

provider "aws" {
  region     = "eu-west-3"
  access_key = var.aws_access_key
  secret_key = var.aws_secret_key
}

export AWS_ACCESS_KEY_ID="votre_cle"
export AWS_SECRET_ACCESS_KEY="votre_secret"

module "eks" {
  source          = "terraform-aws-modules/eks/aws"
  cluster_name    = "eks-demo"
  cluster_version = "1.30"
  subnets         = var.subnets
  vpc_id          = var.vpc_id
}