Lab 09 : Provisionnement de Ressources avec Terraform

Objectifs

Dans cet atelier, vous allez créer, dans un premier temps, un réseau virtuel privé avec un sous-réseau. Ce sous-réseau sera associé avec une table de routage personnalisée, contenant une passerelle internet permettant aux machines virtuelles que vous déploierez dans ce dernier de communiquer avec internet selon les règles définies par leur groupe de sécurité que vous définirez également.

Ensuite, dans un second temps, vous déplorez deux machines virtuelles en une fois et vous créerez un load balancer (équilibreur de charge) qui fera la balance entre ces deux machines virtuelles.

Cet atelier vous expliquera les points suivants :

• Comment installer Terraform et quelques bonnes pratiques
• Comment se connecter à votre provider Outscale et générer une paire de clef via Terrafom
• Comment créer un réseau virtuel et son sous-réseau via Terraform
• Comment créer un groupe de sécurité via Terraform
• Comment créer une et plusieurs machines virtuelles appartenant à un réseau via Terraform
• Comment exécuter un script dans une machine virtuel via Terraform
• Comment créer un load balancer via Terraform
• Quelques bonnes pratiques quand on utilise Terraform

NB : Pour ce lab, vous devrez mettre vos initiales à la fin du nom de chaque ressource crées (ici, j’ai entré les initiales as), idem pour les noms dans les tags.

Installation de Terraform

Rendez-vous sur le site officiel de Terraform, à la page d’installation de ce dernier et suivez les étapes indiquées en prenant bien soin de choisir la bonne distribution, ici Linux pour Ubuntu/Debian :

https://developer.hashicorp.com/terraform/downloads

Une fois installé, rendez-vous sur VSCode pour ajouter l’extension HashiCorp Terraform, cela rendra votre code plus clair et plus simple à écrire.

Enfin, pour ce lab, vous pouvez utiliser la documentation Terraform :

• https://registry.terraform.io/providers/outscale/outscale/latest/docs
• https://registry.terraform.io/providers/hashicorp/tls/latest/docs
• https://registry.terraform.io/providers/hashicorp/local/latest/docs
• https://registry.terraform.io/providers/hashicorp/null/latest/docs

Création d’une machine virtuelle

Pour créer votre machine virtuelle, vous allez :

• Initier un projet Terraform et le configurer pour utiliser votre compte Outscale
• Créer une paire de clef d’accès
• Créer un réseau virtuel avec tout ce qu’il faut pour communiquer avec l’extérieur
• Créer un groupe de sécurité
• Créer la machine virtuelle

Connexion de Terraform avec le cloud provider et création de la clef SSH

Pour se connecter à votre compte Outcale, commencez par créer des variables nécessaires pour cela 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

Ainsi, vous ajouterez dans le fichier variables.tf

variable "access_key_id" {}
variable "secret_key_id" {}
variable "region"  {default = "eu-west-2"}

Dans le fichier terraform.tfvars donnez des valeurs aux variables restées vides.

Dans le fichier outscale.tf vous allez appliquer le code qui suit. C’est ce dernier qui va permettre de faire le lien entre votre projet Terraform et votre cloud provider.

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

provider "outscale"  {
  access_key_id = var.access_key_id
  secret_key_id = var.secret_key_id
  region = var.region
}

Pour la création de la paire de clef, vous allez ajouter le code suivant dans le fichier keypair.tf :

# Création d'une clef privée RSA de 2048 bits
resource "tls_private_key" "my_key"  {
  algorithm = "RSA"
  rsa_bits = "2048"
}

# Stockage de la clef privée
resource "local_file" "my_key"  {
  content = tls_private_key.my_key.private_key_pem
  filename = "${path.module}/my_key.pem"
  file_permission = "0600"
}

# Import de la clef
resource "outscale_keypair" "my_keypair"  {
  keypair_name = "lab_terraform_as"
  public_key = tls_private_key.my_key.public_key_openssh
}

Maintenant, vous allez pouvoir initier votre projet Terraform avec la commande suivante :

terraform init

Vous allez ensuite créer le plan d’exécution, qui va vous permettre de prévisualiser les modifications que va effectuer Terraforme sur votre infrastructure et également vérifier que vous n’avez pas d’erreur dans votre code avec la commande :

terraform plan

Et enfin, exécuter votre projet Terraform avec la commande : terraform apply

Terraform ayant effectué ses modifications, on se retrouve côté VSCode avec un nouveau fichier my_key.pem qui est une clef d’accès pour connexion SSH.

Et vous la retrouvez également côté Outscale :

Création d’un réseau virtuel

Allez dans le fichier variables.tf et ajouter les variables par défaut relative à votre réseau virtuel :

variable "ip_range_net" {
  default = "10.0.0.0/16"
}

variable "ip_range_sub" {
  default = "10.0.0.0/24"
}

variable "ip_range_full" {
  default = "0.0.0.0/0"
}

Créez un fichier net.tf qui va contenir toutes les instructions pour la création du réseau :

# Création du réseau virtuel
resource "outscale_net" "net_as"  {
  ip_range = var.ip_range_net

  tags  {
    key = "name"
    value = "net_as"
  }
}

# Création du sous réseau
resource "outscale_subnet" "subnet_as"  {
  net_id = outscale_net.net_as.net_id
  ip_range = var.ip_range_sub
  subregion_name = "${var.region}a"
}

# Création d'un service internet ou passerelle virtuelle
resource "outscale_internet_service" "internet_service_as"  {
}

# Liaison du service internet avec le réseau
resource "outscale_internet_service_link" "internet_service_link_as"  {
  internet_service_id = outscale_internet_service.internet_service_as.internet_service_id
  net_id = outscale_net.net_as.net_id
}

# Création d'une table de routage sur notre réseau
resource "outscale_route_table" "route_table_as"  {
  net_id = outscale_net.net_as.net_id
}

# Liaison de la table de routage avec le sous-réseau
resource "outscale_route_table_link" "route_table_link_as"  {
  subnet_id = outscale_subnet.subnet_as.subnet_id
  route_table_id = outscale_route_table.route_table_as.route_table_id
}

# Ajout de la passerelle internet à notre table de routage
resource "outscale_route" "default_route_as"  {
  destination_ip_range = var.ip_range_full
  gateway_id = outscale_internet_service.internet_service_as.internet_service_id
  route_table_id = outscale_route_table.route_table_as.route_table_id
}

Une fois toutes les instructions entrées, exécutez la commande terraform plan pour voir les modifications que Terraform effectuera et vérifier que vous n’avez pas des erreurs.

Création d’un groupe de sécurité

Allez dans votre fichier variable.tf pour entrer les variables par défaut pour la création de votre groupe de sécurité.

variable "decription"  { default = "Groupe de sécurité pour le lab Outscale Terraform" }
variable "security_group_name"  { default = "terraform-security-group" }

Puis dans le fichier terraform.tfvars modifier la valeur de nom du groupe de sécurité.

security_group_name = "security_group_as"

Créez un nouveau fichier security_group.tf qui va contenir toutes les instructions pour la création du groupe de sécurité.

# Création du groupe de sécurité
resource "outscale_security_group" "security_group_as"  {
  description = var.decription
  security_group_name = var.security_group_name
  net_id = outscale_net.net_as.net_id
}

# Première règle pour autoriser une connexion ICMP à partir de partout
resource "outscale_security_group_rule" "security_group_rule01_as"  {
  flow = "Inbound"
  security_group_id = outscale_security_group.security_group_as.security_group_id
  from_port_range = "-1"
  to_port_range = "-1"
  ip_protocol = "icmp"
  ip_range = var.ip_range_full
}

# Seconde règle pour autoriser une connexion SSH à partir de partout
resource "outscale_security_group_rule" "security_group_rule02_as"  {
  flow = "Inbound"
  security_group_id = outscale_security_group.security_group_as.security_group_id
  from_port_range = "22"
  to_port_range = "22"
  ip_protocol= "tcp"
  ip_range = var.ip_range_full
}

# Troisième règle pour autoriser une connexion HTTP à partir de partout
resource "outscale_security_group_rule" "security_group_rule03_as"  {
flow = "Inbound"
  security_group_id = outscale_security_group.security_group_as.security_group_id
  from_port_range = "80"
  to_port_range = "80"
  ip_protocol = "tcp"
  ip_range = var.ip_range_full
}

Une fois toutes les instructions entrées, exécuter la commande terraform plan pour voir les modifications que Terraform effectuera et si vous n’avez pas d’erreurs.

Création de la machine virtuelle

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

variable "image_id" {
  default = "ami-70f5d073" // image ubuntu 22
}
variable "vm_type" {
  default = "tinav6.c2r2p2" // t1.micro
}

Puis créer un fichier vm.tf où vous écrirez votre code pour créer votre machine virtuelle.

# Création de la VM
resource "outscale_vm" "vm_as"  {
  image_id = var.image_id
  vm_type = var.vm_type
  keypair_name = outscale_keypair.my_keypair.keypair_name
  security_group_ids = [outscale_security_group.security_group_as.security_group_id]
  subnet_id = outscale_subnet.subnet_as.subnet_id

  tags  {
    key = "name"
    value = "vm_as"
  }
}

# Création d'une IP public
resource "outscale_public_ip" "public_ip_as"  {

  tags  {
    key = "name"
    value = "public_ip_as"
  }
}

# Liaison de notre IP public avec notre VM
resource "outscale_public_ip_link" "public_ip_link_as"  {
  vm_id = outscale_vm.vm_as.vm_id
  public_ip = outscale_public_ip.public_ip_as.public_ip
}

Une fois toutes les instructions entrées, exécutez la commande terraform plan pour voir les modifications que Terraform effectuera et si vous n’avez pas d’erreurs.

Si tout est bon, exécutez la commande terraform apply et ainsi vous aurez créé votre réseau, votre groupe de sécurité et votre machine virtuelle.

Sur la plateforme de votre cloud provider, rendez-vous sur la page listant les machines virtuelles et copier l’IP publique de cette dernière.

Si vous avez un doute et que vous vous demandez si vous avez bien sélectionné la bonne VM, vous pouvez cliquer sur l’ID de cette dernière et vérifier si les tags sur cette dernière sont bien les bons.

Testez la première règle de votre groupe de sécurité en faisant un ping sur votre machine virtuelle.

Testez la seconde règle de votre groupe de sécurité en vous connectant à votre machine virtuelle en SSH.

Enfin, testez la troisième règle de votre groupe de sécurité en installant apache sur votre VM avec les commandes :

sudo apt update -y
sudo apt install apache2 -y

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

Si tout est bon, supprimez toutes les ressources créées via Terraform avec la commande suivante :

terraform destroy

Création d’un Load Balancer (Équilibreur de Charge)

Reprenez votre projet et ajoutez les variables dont vous aurez besoin pour la création de votre load balancer.

Pour cette partie de lab, vous allez créer deux machines virtuelles dans un même réseau et un load balancer qui va gérer ces deux machines virtuelles.

Préparation au déploiement du load balancer et des machines virtuelles

Reprenez votre projet et déclarez les différentes variables dont vous aurez besoin dans votre fichier variables.tf :

variable "vm_count" {
  default = 1
}
variable "load_balancer_my_name" {
  default = "terraform-public-load-balancer"
}

Ensuite, dans votre fichier terraform.tfvars modifiez les valeurs par défaut de vos deux variables.

vm_count = 2
load_balancer_my_name = "public-lb-as"

Puis, créez un fichier vm_startup.sh qui va vous contenir un script permettant de tester votre load balance.

#!/bin/bash
node_number=$1
colors=("blue" "red")
node_color=${colors[node_number]}
dest="/var/www/html/index.html"
apt-get update -y
apt-get install -y lighttpd
echo "<html><body style=\"background-color:${node_color};color:white;text-align:center;font-size:80px;\">Node ${node_number}</body></html>" > $dest
chmod a+r $dest

Déploiement des deux machines virtuelles

Modifiez le fichier vm.tf pour déployer deux machines virtuelles en une exécution. Vous obtiendrez le fichier suivant :

# Création des VMs
resource "outscale_vm" "vm_as"  {
  count = var.vm_count
  image_id = var.image_id
  vm_type = var.vm_type
  keypair_name = outscale_keypair.my_keypair.keypair_name
  security_group_ids = [outscale_security_group.security_group_as.security_group_id]
  subnet_id = outscale_subnet.subnet_as.subnet_id

}

# Création des IP public
resource "outscale_public_ip" "public_ip_as"  {
  count = var.vm_count
  tags  {
    key = "name"
    value = "public_ip_as"
  }
}

# Liaison de nos IP public avec leur VM
resource "outscale_public_ip_link" "public_ip_link_as"  {
  count = var.vm_count
  vm_id = outscale_vm.vm_as[count.index].vm_id
  public_ip = outscale_public_ip.public_ip_as[count.index].public_ip
}

# Importation du script et exécution de ce dernier dans les VMs
resource "null_resource" remoteExecProvisionerWFolder  {
  count = var.vm_count
  # On importe le fichier vm_startup.sh qui sera placer dans le dossier tmp sous le nom vm_startup.sh
  provisioner "file"  {
    source = "vm_startup.sh"
    destination = "/tmp/vm_startup.sh"
    #Connection à nos VMs
    connection  {
      type = "ssh"
      user = "outscale"
      host = outscale_public_ip.public_ip_as[count.index].public_ip
      private_key = tls_private_key.my_key.private_key_pem
    }
  }

# On exécute le script
  provisioner "remote-exec"  {
    #Commande exécuté dans nos VMs
    inline = [
      "sudo bash /tmp/vm_startup.sh ${count.index}"
    ]
    #Connection à nos VMs
    connection  {
      type = "ssh"
      user = "outscale"
      host = outscale_public_ip.public_ip_as[count.index].public_ip
      private_key = tls_private_key.my_key.private_key_pem
    }
  }
}

Une fois les modifications sur le fichier effectuées, tapez la commande terraform plan.

La commande effectuée, il est possible que vous vous retrouviez avec une erreur, pour résoudre cela exécuter la commande terraform init -upgrade.

Déploiement du load balancer

Créez un fichier load_balancer.tf qui va contenir votre code pour la création et la configuration de votre load balancer. Ce dernier devra ressembler à cela :

# Création d'un LB public dans notre réseau privé
resource "outscale_load_balancer" "public_lb_as"  {
  load_balancer_name = var.load_balancer_my_name

  listeners  {
    backend_port = 80
    backend_protocol = "TCP"
    load_balancer_protocol = "TCP"
    load_balancer_port = 80
  }
  listeners  {
    backend_port = 8080
    backend_protocol = "HTTP"
    load_balancer_protocol = "HTTP"
    load_balancer_port = 8080
  }
  subnets = [outscale_subnet.subnet_as.subnet_id]
  load_balancer_type = "internet-facing"
  security_groups = [outscale_security_group.security_group_as.security_group_id]
  tags  {
    key = "name"
    value = "terraform-internet-private-lb"
  }
  depends_on = [outscale_route.default_route_as,outscale_route_table_link.route_table_link_as]
}

# Enregistrement des VMs dans le LB
resource "outscale_load_balancer_vms" "backend_vms_as"  {
  count = length(outscale_vm.vm_as)
  load_balancer_name = outscale_load_balancer.public_lb_as.load_balancer_name
  backend_vm_ids = [outscale_vm.vm_as[count.index].vm_id]
}

# Configuration de la vérification de l'état de santé des VM
resource "outscale_load_balancer_attributes" "health_check_as"  {
load_balancer_name = outscale_load_balancer.public_lb_as.load_balancer_name
  health_check  {
    healthy_threshold = 10
    check_interval = 30
    path = "/"
    port = 80
    protocol = "HTTP"
    timeout = 5
    unhealthy_threshold = 5
  }
}

Après un terraform plan*, vous pourrez exécuter les modifications apportées par Terraform grâce à la commande terraform apply.

Retournez sur la plateforme de votre provider Outscale. Dans le tableau listant les différentes machines virtuelles vous retrouverez les deux machines virtuelles que vous venez de créer.

Copiez les adresses IP de vos machines virtuelles dans le navigateur, vous obtiendrez les résultats suivants :

Enfin, dans l’onglet Load Balancing Unit vous retrouverez votre load balancer.