TP03 - Déployer un serveur avec Terraform sur AWS

Objectif : Déployer une machine virtuelle sur AWS avec Terraform.

Prérequis :

Accès à un compte AWS
Terraform

Étape 1 : Installer Terraform

Connectez-vous à une machine virtuelle ou un environnement de travail approprié pour réaliser ce TP. Vous pouvez utiliser une VM locale, un serveur sur lequel vous avez accès, ou même une instance EC2 sur AWS.
- Option 1 : Machine locale Utilisez votre propre ordinateur ou une VM locale pour réaliser ce TP.
- Option 2 : VM AWS Si vous préférez travailler directement sur une machine dans le cloud, vous pouvez créer une instance EC2 sur AWS pour y installer Terraform. Veillez à choisir une instance avec suffisamment de ressources (ex : t2.micro pour des tests de base).

Installer Terraform :

sudo apt-get update
sudo apt-get install -y wget unzip
wget https://releases.hashicorp.com/terraform/1.5.0/terraform_1.5.0_linux_amd64.zip
unzip terraform_1.5.0_linux_amd64.zip
sudo mv terraform /usr/local/bin/

Vérifiez l’installation :
```
terraform -v
```
Vous devriez voir la version de Terraform installée.

Étape 2 : Initialiser un projet Terraform

Avant de pouvoir déployer les ressources, vous devez initialiser le répertoire Terraform pour télécharger les plugins nécessaires.

Créez un répertoire de travail pour votre projet Terraform :
```
mkdir terraform-aws-deployment
cd terraform-aws-deployment
```
Initialiser Terraform :
```
terraform init
```
Cette commande va télécharger les plugins pour AWS et préparer le répertoire pour l’utilisation de Terraform.

Étape 3 : Créer un fichier main.tf pour configurer une instance EC2

Créez un fichier main.tf qui contient la configuration de l’instance EC2 à déployer sur AWS. Voici un exemple de configuration :

Ajouter des variables pour rendre la configuration plus flexible

Pour rendre la configuration plus flexible, nous allons utiliser un fichier variables.tf pour définir certaines valeurs paramétrables. Créez un fichier variables.tf avec le contenu suivant :

variable "region" {
  description = "La région AWS dans laquelle déployer les ressources"
  default     = "us-east-1"
}

variable "instance_type" {
  description = "Le type d'instance EC2 à déployer"
  default     = "t3.medium"
}

variable "disk_size" {
  description = "La taille du disque de l'instance EC2 (en Go)"
  default     = 20
}

Configurer le fichier main.tf

Utilisez les variables définies dans variables.tf pour créer un fichier main.tf qui contient la configuration de l’instance EC2 :

provider "aws" {
  region = var.region
}

resource "aws_instance" "example" {
  ami           = "**Installer un serveur Apache :**

```bash
sudo apt-get update
sudo apt-get install -y apache2

Installer des paquets supplémentaires :

sudo apt-get install -y curl vim" # Remplacez par l'AMI souhaitée
  instance_type = var.instance_type

  root_block_device {
    volume_size = var.disk_size # Taille du disque en Go
    volume_type = "gp2"
  }

  tags = {
    Name = "Terraform-EC2-Example"
  }
}

Configurer un groupe de sécurité

Pour sécuriser l’accès à votre instance EC2, vous allez créer un groupe de sécurité qui autorise uniquement certaines adresses IP à accéder à l’instance. Ajoutez la configuration suivante au fichier main.tf :

resource "aws_security_group" "example" {
  name        = "allow_ssh"
  description = "Autoriser uniquement l'accès SSH"
  vpc_id      = "vpc-xxxxxxxx" # Remplacez par l'ID de votre VPC

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["your_ip_address/32"] # Remplacez par votre adresse IP
  }

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

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0" # Remplacez par l'AMI souhaitée
  instance_type = var.instance_type

  root_block_device {
    volume_size = var.disk_size # Taille du disque en Go
    volume_type = "gp2"
  }

  vpc_security_group_ids = [aws_security_group.example.id]

  tags = {
    Name = "Terraform-EC2-Example"
  }
}

Explication :

Le fournisseur AWS est configuré avec la région définie dans le fichier variables.tf.
Une instance EC2 de type t3.medium (ou le type spécifié dans les variables) est créée avec l’AMI spécifiée.
Un volume de 20 Go est configuré pour l’instance.
Un groupe de sécurité est créé pour restreindre l’accès SSH à une adresse IP spécifique.
Un tag Name est ajouté pour identifier facilement l’instance.

Étape 4 : Appliquer la configuration Terraform

Pour déployer la machine virtuelle sur AWS, exécutez la commande suivante :

terraform apply

Terraform vous demandera de confirmer les modifications. Tapez yes pour continuer.

Une fois la commande exécutée, Terraform déploiera l’instance EC2 sur AWS en utilisant les paramètres spécifiés dans le fichier main.tf.

Étape 5 : Connecter à l’instance et installer un serveur

Une fois l’instance créée, vous pouvez vous y connecter via SSH et installer un serveur web comme Apache ou Nginx.

Connectez-vous à l’instance :

ssh -i /chemin/vers/votre/cle.pem ec2-user@your_instance_public_ip

Installer un serveur Apache :

sudo apt-get update
sudo apt-get install -y apache2

Démarrer le service Apache :
```
sudo systemctl start apache2
```
Vérifiez que le serveur fonctionne : Accédez à l’adresse IP publique de l’instance depuis votre navigateur pour vérifier que la page par défaut d’Apache est affichée.

Étape 6 : Vérification

Pour vérifier que l’instance a bien été créée, vous pouvez utiliser la console AWS ou exécuter la commande suivante dans Terraform :

terraform show

Cette commande vous montrera les détails des ressources déployées, y compris l’adresse IP de l’instance.

Conclusion : Vous avez déployé avec succès une instance EC2 sur AWS en utilisant Terraform, puis vous y avez installé un serveur Apache. Vous avez appris à créer un fichier de configuration Terraform, initialiser le projet, appliquer les configurations pour déployer une ressource sur AWS, et installer un serveur web.