Lab 05 : Création et Utilisation d'un module Terraform

Objectifs

Dans cet atelier, vous allez apprendre à créer un module Terraform qui permet de déployer et configurer un serveur web basique dans une machine virtuelle. Vous allez ensuite vous servir de ce module pour déployer ce serveur web dans divers environnements, par exemple Staging et Production.

Voici une vue globale de l’organisation de dossiers de travail que vous allez créer et y mettre vos fichiers de configuration.

Pré-requis

• Terraform doit être installé et fonctionnel
• Vous devez disposer de vos identifiants API (Acces Key et Secret Access Key) pour authentifier les appels d’API effectués par Terraform.

Etapes à suivre

• L’étape 0 consiste à créer les dossiers de travail susprésentés.
• L’étape 1 consiste à créer le module source, ainsi vous allez :
  • Initier un projet Terraform et le configurer pour utiliser votre compte Outscale
  • Créer une paire de clef SSH
  • Créer les éléments du réseau et de sécurité nécessaires
  • Installer et configurer le serveur web (Apache 2) en utilisant l’attribut user_data de la VM pour lui passer la configuration.
• L’étape 2 consiste à réutiliser le module que vous venez de construire pour créer des instances de serveur web dans les deux environnements cibles Staging et Production.

ETAPE 0: Création de dossiers de travail

Commencez par créer les 3 dossiers :

• ~/modules/webserver-cluster
• ~/stage
• ~/prod

ETAPE 01: Création du module source

Configuration de Terraform avec le cloud provider Outscale

Commencez par créer le fichier de configuration du provider, config.tf

terraform  {
  required_providers  {
    outscale =  {
      source = "outscale/outscale"
      version = ">= 0.11.0"
    }
  }
}

📌 NOTE
Au niveau du module source, on ne définit pas le provider Outscale. Cela sera fait au niveau de la réutilisation de ce module.

Ensuite créez le fichier des variables variables.tf nécessaires pour la connexion avec le provider Outscale selon l’environnement cible Staging ou Production et qui vont contenir :

• L’ID de la clef d’accès au compte Outscale
• L’ID de la clef secrète du compte Outscale
• La région du compte Outscale
• Le nom de l’environnement cible stage ou prod
• L’ID de l’image (OMI) qui va varier en fonction de l’environnement cible
• Le type de la VM qui va varier en fonction de l’environnement cible

variable "access_key_id" {
  type      = string
  sensitive = true
}
variable "secret_key_id" {
  type      = string
  sensitive = true
}
variable "region" {
  default = "eu-west-2"
  type    = string
}
variable env_name {
  type = string
  default = "stage"
}

Création de la paire de clef SSH

Pour la la paire de clef SSH, vous allez utiliser une clé que vous allez créer avec la commande ssh-keygen.

Le contenu du fichier keypair.tf :

resource "outscale_keypair" "keypair01" {
  keypair_name = "lab04"
  public_key   = file("~/.ssh/id_ed25519.pub")
}

Création des éléments du réseau et sécurité nécessaires

Vous allez créer les éléments du réseau et de sécurité nécessaires pour le déploiement du serveur web.

📌 NOTE
on DOIT faire varier le nom des ressources selon l’environnement cible en utilisant la fonction concat.

Vous allez ainsi créer le fichier network.tf avec le contenu suivant:

resource "outscale_net" "lab04-vpc" {
  # A compléter
}
resource "outscale_subnet" "sn1" {
  # A compléter
}
resource "outscale_internet_service" "lab04_igw" {

}
resource "outscale_internet_service_link" "lab04_igw_link" {
  # A compléter
}
resource "outscale_route_table" "rtb-01" {
  # A compléter
}
resource "outscale_route" "outscale_route" {
  # A compléter
}
resource "outscale_route_table_link" "outscale_route_table_link-01" {
  # A compléter
}
resource "outscale_security_group" "seg-vms" {
  # A compléter
}
resource "outscale_security_group_rule" "security_group_vm_rule01" {
  # A compléter
}
resource "outscale_security_group_rule" "security_group_vm_rule02" {
  # A compléter
}

Le groupe de sécurité doit contenir les deux règles ci-dessous qui vont servir pour les tests que vous allez faire à la fin:

• Règle pour autoriser une connexion SSH à partir de votre IP
• Règle pour autoriser une connexion HTTP à partir de partout

Vous pouvez exécuter la commande terraform plan pour voir les modifications que Terraform effectuera et vérifier que vous n’avez pas des erreurs.

Création de la machine virtuelle

Commencez par rajouter les variables qui seront utilisées dans le fichier variables.tf :

variable "image_id" {
  type= "string"
}
variable "vm_type" {
  type = "string"
}

Puis créer un fichier vm.tf où vous écrirez votre code pour créer votre machine virtuelle et un fichier template user-data appelé par exemple webserver-mixte dans le même dossier de travail que les fichiers Terraform précédents.

resource "outscale_vm" "lab04-vm" {
  # A compléter
  user_data = base64encode(data.template_file.user_data.rendered)
}
data "template_file" "user_data" {
  template = file("webserver-mixte")
}
resource "outscale_public_ip" "public_ip01" {
}
resource "outscale_public_ip_link" "public_ip_link01" {
  # A compléter
}

Nous avons ajouté des user data à la machine virtuelle afin de lui modifier le hostname et y installer et configurer le serveur web Apache 2 à l’aide du template_file qui est un mixte de directives cloud-config et de script shel.

Voici le contenu du fichier webserver-mixt.

Content-Type: multipart/mixed; boundary="//"
MIME-Version: 1.0

--//
Content-Type: text/cloud-config; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment; filename="cloud-config.txt"

##Update hostname at first boot
hostname: WEBSERVER

--//
Content-Type: text/x-shellscript; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment; filename="userdata-bash.txt"
#!/bin/bash
sudo apt-get update
sudo apt-get -y install apache2
sudo hown -R outscale:outscale /var/www
sudo chmod 2775 /var/www
sudo find /var/www -type d -exec chmod 2775 {} \;
sudo find /var/www -type f -exec chmod 0664 {} \;
sudo mv /var/www/html/index.html /var/www/html/index.html-orig
sudo touch /var/www/html/index.html
dest="/var/www/html/index.html"
sudo echo "Hello from VM $(curl http://169.254.169.254/latest/meta-data/instance-id) deployed in $(curl http://169.254.169.254/latest/meta-data/placement/availability-zone) " > $dest
--//

Etape 02: Réutilisation du module source pour déployer un serveur web par environnement cible

Nous allons déployer un serveur web dans notre environnement de Staging dans la région eu-west-2. Pour cela, placez-vous dans le dossier stage/webserver-cluster.

Voici la liste de fichiers que vous devez avoir dans ce dossier:

📌 NOTE
N’oubliez pas de copier le fichier webserver-mixte depuis le dossier du module source.

Connexion de Terraform avec le cloud provider Outscale

Commencez par créer le fichier de configuration du provider, config.tf

terraform  {
  required_providers  {
    outscale =  {
      source = "outscale/outscale"
      version = ">= 0.12.0"
    }
  }
}
provider "outscale" {
  access_key_id = var.access_key_id
  secret_key_id = var.secret_key_id
  region = var.region
}

Création et initiation de variables

Ensuite créez le fichier des variables `variables.tf“ nécessaires pour la connexion avec le provider Outscale avec les identifiants clef d’accès API et clef secrète API appropriés à l’environnement Staging :

variable "access_key_id" {
  type      = string
  sensitive = true
}
variable "secret_key_id" {
  type      = string
  sensitive = true
}
variable "region" {
  default = "eu-west-2"
  type    = string
}
variable env_name {
  type = string
  default = "staging"
}

Puis, dans le fichier terraform.tfvars donnez des valeurs aux variables.

access_key_id = "your_AK_ID"
secret_key_id = "your_SK_ID"
region = "eu-west-2"
image_id = "ami-bb490c7e" # OMI ubun-22-04 dans eu-west-2
vm_type = "tinav6.c1r1p1" // Petite VM pour tester

Réutilisation du module

Vous allez ensuite créer le fichier main.tf qui va permettre de réutiliser le module source que vous avez créé dans l’étape précédente en spécifiant les variables appropriées à l’environnement Staging.

Voici le contenu de ce fichier:

module "webserver_cluster" {
  source = "../modules/webserver_cluster"
  # A compléter
}

Maintenant, vous allez devoir initier votre projet Terraform avec la commande terraform init puis terraform plan.

Exécution et test du bon fonctionnement

Si tout est bon, exécutez la commande terraform apply et ainsi vous aurez réutilisé le module pré-créé pour déployer un serveur web dans l’environnement Staging.

Une fois l’exécution terminée, rendez-vous sur la page listant les machines virtuelles sur Cockpit et copier l’IP publique de la machine qui héberge votre serveur web.

Puis sur votre navigateur entrez l’IP publique de votre machine virtuelle.

Challenge

Utilisez un moyen plus automatisé permettant de récupérer l’adresse IP publique de la vm.