Aller au contenu

Lab 10 : Création d'une OMI avec Packer

À l’issue de ce lab, vous serez capable de :

  • expliquer ce que contient une OMI (OUTSCALE Machine Image) et la différence entre configurer une VM au démarrage avec Cloud-init et construire une OMI déjà configurée ;
  • écrire un modèle Packer avec le builder outscale-bsu, authentifié par le profil octl créé au Lab 05 ;
  • sélectionner automatiquement la dernière OMI Ubuntu officielle comme OMI source ;
  • configurer une image avec les provisioners file et shell, puis la nettoyer avant sa création ;
  • suivre une construction Packer et identifier les ressources temporaires qu’elle crée puis supprime ;
  • retrouver l’OMI et son snapshot avec octl et dans Cockpit ;
  • créer une VM (machine virtuelle) à partir de votre OMI, sans paire de clés ni script de démarrage ;
  • supprimer une OMI et son snapshot.

Dans les Labs 06, 08 et 09, chaque VM web installe Apache et PHP à son premier démarrage, avec un script Cloud-init : la VM a besoin d’un accès à Internet, l’installation prend plusieurs minutes, et son résultat dépend des paquets disponibles ce jour-là. Dans ce lab, vous faites cette installation une seule fois, à l’avance, et vous l’enregistrez dans une OMI. Toutes les VMs créées à partir de cette OMI démarrent avec le serveur web et l’application déjà installés.

Une OMI contient :

  • un ou plusieurs snapshots (instantanés) de volumes BSU, dont celui du volume racine, qui porte le système et les logiciels installés ;
  • le block device mapping, qui indique pour chaque snapshot le nom de périphérique, la taille et le type du volume à créer ;
  • des métadonnées : nom, description, tags, mode de démarrage et permissions de lancement (privée par défaut).

Packer est un outil gratuit de HashiCorp qui construit des images de VM à partir d’un fichier de configuration, le modèle. Le plugin OUTSCALE pour Packer, open source, fournit le builder outscale-bsu, qui procède en cinq temps, tous dans votre compte et dans la Région eu-west-2 :

  1. il recherche l’OMI source, ici la dernière OMI Ubuntu 22.04 publiée par OUTSCALE ;
  2. il crée des ressources temporaires dans le Public Cloud (hors Net) : une paire de clés packer_<UUID>, un Security Group packer_osc_<UUID> qui n’autorise le SSH que depuis votre adresse IP publique, et une VM architecte-lab10-build, qui reçoit automatiquement une IP publique ;
  3. il se connecte en SSH à la VM et exécute les provisioners : copie des pages de l’application, installation d’Apache et de PHP, nettoyage ;
  4. il arrête la VM, puis crée l’OMI architecte-lab10-web-v1 : l’API OUTSCALE prend un snapshot du volume racine et enregistre l’OMI ;
  5. il supprime la VM, le Security Group et la paire de clés temporaires.

Vous créez ensuite, avec octl, une VM architecte-lab10-vm-web-v1 à partir de votre OMI, protégée par le Security Group architecte-lab10-sg-web, qui n’autorise que le HTTP depuis votre adresse IP publique. La VM n’a ni paire de clés, ni script Cloud-init : elle sert la page web dès son démarrage.

Architecture du lab : Packer construit une OMI, octl crée une VM à partir de cette OMI

Avant de commencer, vous devez disposer :

  • d’un compte OUTSCALE actif, dont les quotas permettent de créer deux VMs et deux Security Groups de plus ;
  • d’un accès à Cockpit ;
  • d’un terminal bash avec curl ;
  • d’une connexion Internet ;
  • d’un éditeur de texte, par exemple VS Code avec l’extension HashiCorp HCL, qui colore la syntaxe des fichiers Packer ;
  • d’octl, installé et configuré avec le profil default dans le Lab 05 : Packer utilise ce même profil pour s’authentifier ;
  • des connaissances acquises dans le Lab 05 (octl, recherche d’OMI, Security Group, VM dans le Public Cloud) et le Lab 06 (script Cloud-init d’un serveur web). Le Lab 09 est utile : Packer utilise la même syntaxe HCL que Terraform.

Ce lab ne réutilise aucune ressource OUTSCALE des labs précédents.

Le lab utilise la région eu-west-2.

Remarque : sous Windows, utilisez WSL (Windows Subsystem for Linux), comme dans le Lab 05, pour suivre ce lab avec les mêmes commandes.

Important : ce lab a été rédigé avec Packer 1.16.1, la version 1.6.1 du plugin OUTSCALE pour Packer et octl v0.0.35. Si une commande ne se comporte pas comme décrit, consultez la documentation du plugin OUTSCALE et l’aide intégrée d’octl (octl iaas <commande> --help).

  1. Installez Packer en suivant uniquement la méthode de votre système.

    Sous macOS : installez Packer avec Homebrew, depuis le dépôt officiel de HashiCorp.

    Terminal window
    brew tap hashicorp/tap
    brew install hashicorp/tap/packer

    Sous Linux (Ubuntu ou Debian) : ajoutez le dépôt de paquets officiel de HashiCorp, puis installez Packer. Si vous avez fait le Lab 09 sur ce poste, le dépôt est déjà configuré : lancez seulement la dernière commande.

    Terminal window
    wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
    echo "deb [arch=$(dpkg --print-architecture) 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
    sudo apt update && sudo apt install packer
  2. Vérifiez l’installation :

    Terminal window
    packer version

    La commande affiche la version de Packer, par exemple Packer v1.16.1. Ce lab nécessite Packer 1.10.0 ou une version plus récente.

Remarque : les autres méthodes d’installation, dont celle pour Windows, sont détaillées dans le Lab 01 du parcours Packer.

1.2 Vérifier le profil octl et relever votre adresse IP

Section intitulée « 1.2 Vérifier le profil octl et relever votre adresse IP »

Packer s’authentifie auprès de l’API OUTSCALE avec la même access key qu’octl, lue dans le même fichier ~/.osc/config.json.

  1. Affichez le profil actif :

    Terminal window
    octl profile current

    Le profil default s’affiche, avec la Région eu-west-2. Si la commande échoue, reprenez la partie 2 du Lab 05.

  2. Récupérez votre adresse IP publique :

    Terminal window
    MON_IP=$(curl -s https://api.ipify.org)
    echo $MON_IP

    Vous transmettrez cette adresse à Packer, qui n’autorisera le SSH vers sa VM temporaire que depuis votre poste. Vous l’utiliserez aussi pour le Security Group de la VM de test.

Attention : n’écrivez jamais votre access key ni votre Secret Key dans un fichier .pkr.hcl, et ne les exportez pas dans des variables d’environnement de votre terminal. Le profil octl suffit.

Un projet Packer est un dossier : la commande packer build . lit tous les fichiers .pkr.hcl qu’il contient, quel que soit leur nom. Comme au Lab 09, vous répartissez la configuration en un fichier par thème.

  1. Créez le dossier du projet et placez-vous dedans :

    Terminal window
    mkdir ~/architecte-lab10
    cd ~/architecte-lab10

    Ouvrez ensuite le dossier ~/architecte-lab10 dans votre éditeur : vous y créerez tous les fichiers du lab.

  1. Créez le fichier plugins.pkr.hcl avec le contenu suivant :

    packer {
    required_version = ">= 1.10.0"
    required_plugins {
    outscale = {
    source = "github.com/outscale/outscale"
    version = "~> 1.6"
    }
    }
    }
    • required_version : la version minimale de Packer.
    • source : l’adresse du plugin OUTSCALE, publié sur GitHub.
    • version = "~> 1.6" : toute version 1.x à partir de 1.6, mais jamais une version 2.0. La version 1.6 est la première qui lit le profil octl.
  2. Installez le plugin :

    Terminal window
    packer init .

    Packer télécharge le plugin OUTSCALE et affiche une ligne qui ressemble à :

    Terminal window
    Installed plugin github.com/outscale/outscale v1.6.1 in "/home/<UTILISATEUR>/.config/packer/plugins/github.com/outscale/outscale/packer-plugin-outscale_v1.6.1_x5.0_linux_amd64"

    Contrairement à Terraform, Packer n’installe pas le plugin dans le dossier du projet, mais dans votre répertoire personnel : il est partagé par tous vos projets Packer.

  1. Créez le fichier variables.pkr.hcl avec le contenu suivant :

    variable "prefixe" {
    description = "Préfixe du nom des ressources du lab"
    type = string
    default = "architecte-lab10"
    }
    variable "version_app" {
    description = "Version de l'application installée dans l'OMI"
    type = string
    default = "1"
    }
    variable "mon_ip" {
    description = "Adresse IP publique du poste, seule autorisée en SSH pendant la construction"
    type = string
    }
    • prefixe et version_app ont une valeur par défaut, que l’option -var permet de remplacer.
    • mon_ip n’a pas de valeur par défaut : vous devrez la fournir à chaque commande, avec l’option -var "mon_ip=$MON_IP".

Remarque : si plusieurs stagiaires partagent le même compte OUTSCALE, chacun doit utiliser un préfixe différent, car le nom d’une OMI est unique dans un compte. Ajoutez alors l’option -var "prefixe=architecte-lab10-<VOS_INITIALES>" aux commandes packer validate et packer build, et adaptez les noms dans les commandes octl du lab.

2.4 Préparer l’application et le script d’installation

Section intitulée « 2.4 Préparer l’application et le script d’installation »
  1. Créez le fichier index.php avec le contenu suivant :

    <!DOCTYPE html>
    <html lang="fr">
    <head>
    <meta charset="UTF-8">
    <title>OUTSCALE - Lab 10</title>
    </head>
    <body>
    <h1>Lab 10 - VM créée depuis une OMI construite avec Packer</h1>
    <p>Version de l'application : v@VERSION_APP@</p>
    <p>VM web : <?php echo htmlspecialchars(gethostname()); ?></p>
    </body>
    </html>

    Le texte @VERSION_APP@ sera remplacé par le numéro de version au moment de la construction. Le nom d’hôte, lui, est calculé par PHP à chaque affichage : il sera différent sur chaque VM créée à partir de l’OMI.

  2. Créez le fichier health.html, réservé au health check d’un load balancer, comme aux Labs 08 et 09 :

    Terminal window
    echo OK > health.html
  3. Créez le fichier install-web.sh avec le contenu suivant :

    #!/bin/bash
    # Arrête le script à la première erreur : Packer annule alors la construction
    set -euo pipefail
    export DEBIAN_FRONTEND=noninteractive
    echo "--- Installation d'Apache et de PHP"
    # Attend jusqu'à 5 minutes si une mise à jour automatique utilise déjà apt
    apt-get -o DPkg::Lock::Timeout=300 update
    apt-get -o DPkg::Lock::Timeout=300 install -y apache2 php libapache2-mod-php
    echo "--- Installation de l'application v${VERSION_APP}"
    rm -f /var/www/html/index.html
    install -m 0644 -o www-data -g www-data /tmp/index.php /var/www/html/index.php
    install -m 0644 -o www-data -g www-data /tmp/health.html /var/www/html/health.html
    sed -i "s/@VERSION_APP@/${VERSION_APP}/" /var/www/html/index.php
    systemctl enable apache2
    echo "--- Nettoyage de l'image"
    apt-get clean
    rm -f /tmp/index.php /tmp/health.html
    cloud-init clean --logs
    • Les paquets sont les mêmes que dans le script Cloud-init du Lab 09. L’option DPkg::Lock::Timeout fait patienter apt-get si les mises à jour automatiques d’Ubuntu utilisent déjà le gestionnaire de paquets, au lieu d’échouer immédiatement.
    • systemctl enable apache2 active le démarrage automatique d’Apache. C’est la seule chose qui compte : la VM temporaire est arrêtée avant la création de l’OMI, et Apache doit démarrer tout seul sur les VMs créées ensuite.
    • Le nettoyage retire de l’image ce qui ne doit pas se retrouver sur toutes les VMs : le cache des paquets téléchargés, les fichiers temporaires, et l’état de Cloud-init. Avec cloud-init clean, Cloud-init considère le prochain démarrage comme un premier démarrage : chaque VM créée à partir de l’OMI génère ses propres clés d’hôte SSH et reçoit la paire de clés choisie à sa création.
  1. Créez le fichier web.pkr.hcl avec le contenu suivant :

    source "outscale-bsu" "web" {
    # Authentification : profil octl du Lab 05, lu dans ~/.osc/config.json
    profile = "default"
    region = "eu-west-2"
    # OMI source : la plus récente des OMI Ubuntu 22.04 publiées par OUTSCALE
    source_omi_filter {
    filters = {
    image-name = "Ubuntu-22.04-*"
    }
    owners = ["Outscale"]
    most_recent = true
    }
    # VM temporaire de construction
    vm_type = "tinav5.c1r1p2"
    subregion_name = "eu-west-2a"
    run_tags = {
    Name = "${var.prefixe}-build"
    }
    # Connexion SSH de Packer à la VM temporaire
    communicator = "ssh"
    ssh_username = "outscale"
    ssh_interface = "public_ip"
    temporary_security_group_source_cidr = "${var.mon_ip}/32"
    ssh_clear_authorized_keys = true
    # OMI produite
    omi_name = "${var.prefixe}-web-v${var.version_app}"
    omi_description = "Lab 10 - Ubuntu 22.04, Apache, PHP, application v${var.version_app}"
    tags = {
    Name = "${var.prefixe}-web-v${var.version_app}"
    Application = "v${var.version_app}"
    }
    snapshot_tags = {
    Name = "${var.prefixe}-web-v${var.version_app}"
    }
    }
    build {
    sources = ["source.outscale-bsu.web"]
    # 1. Attendre la fin du premier démarrage de la VM temporaire
    provisioner "shell" {
    inline = ["cloud-init status --wait"]
    }
    # 2. Copier les pages de l'application sur la VM temporaire
    provisioner "file" {
    sources = ["index.php", "health.html"]
    destination = "/tmp/"
    }
    # 3. Installer le serveur web et l'application, puis nettoyer l'image
    provisioner "shell" {
    script = "install-web.sh"
    environment_vars = ["VERSION_APP=${var.version_app}"]
    execute_command = "chmod +x {{ .Path }}; sudo {{ .Vars }} {{ .Path }}"
    }
    # Enregistrer l'identifiant de l'OMI produite dans manifest.json
    post-processor "manifest" {
    output = "manifest.json"
    strip_path = true
    }
    }

    Le fichier contient deux blocs.

    Le bloc source configure le builder outscale-bsu. Il porte deux étiquettes : le type de builder (outscale-bsu) et un nom local (web).

    • profile et region : Packer lit l’access key et la Secret Key du profil default, et travaille dans la Région eu-west-2.
    • source_omi_filter : Packer recherche les OMI dont le nom commence par Ubuntu-22.04- et dont le propriétaire est OUTSCALE (owners), puis retient la plus récente (most_recent). C’est la recherche de l’étape 3.3 du Lab 05, sans identifiant d’OMI codé en dur.
    • vm_type, subregion_name, run_tags : le type, la Sous-région et le tag Name de la VM temporaire. Packer ne précise ni Net ni Subnet : la VM est créée dans le Public Cloud et reçoit automatiquement une IP publique.
    • ssh_username = "outscale" : l’utilisateur par défaut des OMI Ubuntu officielles OUTSCALE, comme au Lab 01.
    • temporary_security_group_source_cidr : la règle SSH du Security Group temporaire. Par défaut, Packer ouvre le port 22 à 0.0.0.0/0, c’est-à-dire à tout Internet ; ici, seule votre adresse IP est autorisée.
    • ssh_clear_authorized_keys = true : à la fin des provisioners, Packer retire sa clé publique temporaire du fichier ~/.ssh/authorized_keys de l’utilisateur outscale, pour qu’elle ne soit pas copiée dans l’OMI.
    • omi_name : le nom de l’OMI, qui doit être unique dans votre compte. Il contient le numéro de version de l’application.
    • tags et snapshot_tags : les tags de l’OMI et de son snapshot, pour les retrouver avec l’option --tag-value d’octl.

    Le bloc build décrit ce que Packer fait sur la VM temporaire, dans l’ordre :

    • le premier provisioner shell attend que Cloud-init ait terminé le premier démarrage de la VM temporaire. Sans cette attente, apt-get pourrait se heurter à Cloud-init, qui met lui aussi à jour la liste des paquets au démarrage ;
    • le provisioner file copie index.php et health.html de votre poste vers le dossier /tmp/ de la VM ;
    • le second provisioner shell copie install-web.sh sur la VM et l’exécute avec sudo, en lui transmettant la variable VERSION_APP ;
    • le post-processor manifest s’exécute après la création de l’OMI : il écrit son identifiant dans le fichier manifest.json.
  1. Mettez en forme les fichiers selon les conventions de Packer :

    Terminal window
    packer fmt .

    La commande aligne les signes = et affiche le nom des fichiers modifiés, ou rien s’ils étaient déjà bien formatés.

  2. Vérifiez la syntaxe et la cohérence du modèle :

    Terminal window
    packer validate -var "mon_ip=$MON_IP" .

    Le message The configuration is valid. s’affiche.

Remarque : sans l’option -var "mon_ip=$MON_IP", Packer refuse le modèle avec l’erreur Unset variable "mon_ip". Comme terraform validate au Lab 09, packer validate ne vérifie pas que l’OMI source existe ni que vos quotas suffisent : ces erreurs n’apparaissent qu’au moment de la construction.

  1. Lancez la construction :

    Terminal window
    packer build -var "mon_ip=$MON_IP" .

    La construction dure environ 10 minutes. Ne fermez pas le terminal : si vous interrompez Packer avec Ctrl + C, il supprime les ressources temporaires et ne crée pas l’OMI.

  2. Suivez les étapes dans la sortie de Packer. Le début ressemble à ceci, avec vos propres valeurs :

    Terminal window
    ==> outscale-bsu.web: Validating configured credentials
    ==> outscale-bsu.web: Prevalidating OMI Name: architecte-lab10-web-v1
    ==> outscale-bsu.web: Found Image ID: ami-12345678
    ==> outscale-bsu.web: Creating temporary keypair: packer_6751790a-2ff6-87ef-bca2-54dd34ed735d
    ==> outscale-bsu.web: Creating temporary security group for this instance: packer_osc_6751790a-fb55-ee29-5f79-a4ba74a2cb40
    ==> outscale-bsu.web: Authorizing access to port 22 from 203.0.113.10/32 in the temporary security group...
    ==> outscale-bsu.web: Launching a source OUTSCALE vm...
    ==> outscale-bsu.web: Adding tags to source vm
    ==> outscale-bsu.web: Vm ID: i-12345678
    ==> outscale-bsu.web: Waiting for vm (i-12345678) to become ready...
    ==> outscale-bsu.web: Using SSH communicator to connect: 198.51.100.25
    ==> outscale-bsu.web: Waiting for SSH to become available...
    ==> outscale-bsu.web: Connected to SSH!

    Repérez :

    • Validating configured credentials : Packer a lu le profil default et l’API OUTSCALE a accepté l’access key ;
    • Prevalidating OMI Name : Packer vérifie qu’aucune OMI de votre compte ne porte déjà ce nom ;
    • Found Image ID : l’identifiant de l’OMI Ubuntu 22.04 la plus récente, trouvée par source_omi_filter ;
    • les noms de la paire de clés et du Security Group temporaires, qui commencent par packer_ ;
    • Authorizing access to port 22 from <VOTRE_IP>/32 : la règle SSH est limitée à votre adresse IP.
  3. Laissez la construction se poursuivre. Les lignes suivantes, en vert, sont la sortie des provisioners : l’attente de Cloud-init (status: done), la copie des fichiers, puis l’installation des paquets et les messages --- Installation... et --- Nettoyage... du script.

Pendant que les provisioners s’exécutent, vous observez avec octl les ressources temporaires que Packer a créées dans votre compte.

  1. Ouvrez un second terminal.

  2. Affichez la VM temporaire :

    Terminal window
    octl iaas vm list --tag-value architecte-lab10-build

    La VM architecte-lab10-build apparaît à l’état running, avec une IP publique. Les colonnes NetId et SubnetId sont vides : la VM est dans le Public Cloud.

  3. Affichez la paire de clés et le Security Group temporaires :

    Terminal window
    octl iaas keypair list --filter KeypairName:packer
    octl iaas securitygroup list --filter SecurityGroupName:packer

    L’option --filter d’octl n’affiche que les lignes dont le champ indiqué contient le texte packer.

  4. Affichez les règles du Security Group temporaire, en remplaçant <ID_SG_PACKER> par l’identifiant affiché dans la colonne ID (il commence par sg-) :

    Terminal window
    octl iaas securitygroup rules <ID_SG_PACKER>

    Le tableau affiche une règle Inbound, protocole tcp, port 22, depuis votre adresse IP suivie de /32.

Gardez ce second terminal ouvert pour l’étape 4.3.

  1. Revenez au premier terminal. La fin de la construction ressemble à ceci :

    Terminal window
    ==> outscale-bsu.web: Trying to remove ephemeral keys from authorized_keys files
    ==> outscale-bsu.web: Stopping the source vm...
    ==> outscale-bsu.web: Waiting for the vm to stop...
    ==> outscale-bsu.web: Creating OMI architecte-lab10-web-v1 from vm i-12345678
    ==> outscale-bsu.web: OMI: ami-87654321
    ==> outscale-bsu.web: Waiting for OMI to become ready...
    ==> outscale-bsu.web: Adding tags to OMI (ami-87654321)...
    ==> outscale-bsu.web: Terminating the source OUTSCALE vm...
    ==> outscale-bsu.web: Deleting temporary security group...
    ==> outscale-bsu.web: Deleting temporary keypair...
    Build 'outscale-bsu.web' finished after 9 minutes 32 seconds.
    ==> Builds finished. The artifacts of successful builds are:
    --> outscale-bsu.web: OMIs were created:
    eu-west-2: ami-87654321

    Repérez l’ordre des opérations :

    • Packer retire sa clé publique temporaire de la VM (ssh_clear_authorized_keys) ;
    • il arrête la VM, pour que le système de fichiers soit dans un état cohérent au moment du snapshot ;
    • il crée l’OMI à partir de la VM arrêtée et attend qu’elle soit disponible ;
    • il supprime la VM, puis le Security Group et la paire de clés temporaires.

    La dernière ligne, l’artefact de la construction, donne la Région et l’identifiant de votre OMI.

  2. Affichez le fichier écrit par le post-processor manifest :

    Terminal window
    cat manifest.json

    Le champ artifact_id contient la même valeur, eu-west-2:ami-87654321. Un pipeline CI/CD peut lire ce fichier pour transmettre l’identifiant de l’OMI à l’étape suivante, par exemple à Terraform.

Remarque : si la construction échoue, Packer supprime les ressources temporaires et n’enregistre aucune OMI. Lisez la première ligne en rouge : elle indique l’étape et la cause de l’échec. Relancez la commande avec la variable PACKER_LOG=1 devant packer build pour obtenir le détail des appels à l’API OUTSCALE.

Vous revenez dans le premier terminal, où la variable MON_IP est définie.

  1. Affichez votre OMI :

    Terminal window
    octl iaas image list --name architecte-lab10-web-v1

    La colonne Account affiche l’identifiant de votre compte, alors que les OMI officielles affichent Outscale.

  2. Enregistrez l’identifiant de l’OMI dans la variable OMI_ID :

    Terminal window
    OMI_ID=$(octl iaas image list --name architecte-lab10-web-v1 -o text --jq '.ImageId')
    echo $OMI_ID
  3. Affichez le détail de l’OMI :

    Terminal window
    octl iaas image describe $OMI_ID

    Repérez les champs suivants :

    • ImageName et Description : les valeurs de omi_name et omi_description ;
    • State : available, l’OMI peut servir à créer des VMs ;
    • BlockDeviceMappings : le volume racine /dev/sda1, avec sa taille (VolumeSize), son type (VolumeType) et l’identifiant du snapshot (SnapshotId, qui commence par snap-) ;
    • PermissionsToLaunch : GlobalPermission: false et aucune liste de comptes, l’OMI est privée, réservée à votre compte ;
    • Tags : les tags Name et Application déclarés dans le modèle.
  1. Enregistrez l’identifiant du snapshot dans la variable SNAP_ID :

    Terminal window
    SNAP_ID=$(octl iaas image describe $OMI_ID -o text --jq '.BlockDeviceMappings[0].Bsu.SnapshotId')
    echo $SNAP_ID
  2. Affichez le snapshot :

    Terminal window
    octl iaas snapshot list --tag-value architecte-lab10-web-v1

    Le snapshot apparaît à l’état completed, avec le tag Name déclaré dans snapshot_tags. La colonne Volume affiche l’identifiant du volume racine de la VM temporaire : ce volume a été supprimé avec la VM, mais son contenu est conservé dans le snapshot.

Important : une OMI ne contient pas de données à elle seule : elle référence un snapshot, stocké et facturé dans votre compte. Supprimer l’OMI ne supprime pas le snapshot : vous supprimerez les deux au nettoyage.

4.3 Vérifier la suppression des ressources temporaires

Section intitulée « 4.3 Vérifier la suppression des ressources temporaires »
  1. Dans le second terminal, relancez les commandes de l’étape 3.2 :

    Terminal window
    octl iaas vm list --tag-value architecte-lab10-build
    octl iaas keypair list --filter KeypairName:packer
    octl iaas securitygroup list --filter SecurityGroupName:packer

    La VM architecte-lab10-build est à l’état terminated, ou n’apparaît plus. La paire de clés et le Security Group temporaires n’apparaissent plus.

  2. Fermez le second terminal.

  1. Dans Cockpit, sélectionnez Compute > Images.

  2. Recherchez architecte-lab10 : votre OMI apparaît, avec votre compte comme propriétaire et une permission privée.

  3. Recherchez Ubuntu-22.04 : les OMI officielles apparaissent, avec OUTSCALE comme propriétaire et une permission publique. Votre OMI est construite à partir de la plus récente.

Remarque : l’interface Cockpit peut évoluer. Les noms ou l’emplacement de certains menus peuvent différer légèrement de ceux indiqués dans ce lab.

  1. Créez le Security Group architecte-lab10-sg-web dans le Public Cloud et enregistrez son identifiant dans la variable SG_ID :

    Terminal window
    SG_ID=$(octl iaas securitygroup create \
    --name architecte-lab10-sg-web \
    --description "Lab 10 - HTTP depuis le poste du stagiaire" \
    -o text --jq '.SecurityGroupId')
    echo $SG_ID
  2. Ajoutez une règle entrante qui autorise le HTTP (TCP 80) uniquement depuis votre adresse IP :

    Terminal window
    octl iaas securitygrouprule create \
    --group-id $SG_ID \
    --flow Inbound \
    --ports tcp/80 \
    --remote-ranges $MON_IP/32
  3. Vérifiez les règles du Security Group :

    Terminal window
    octl iaas securitygroup rules $SG_ID

    Le tableau affiche une seule règle entrante, TCP 80, depuis votre adresse IP. Le Security Group n’autorise pas le SSH : vous n’avez pas besoin de vous connecter à la VM pour l’installer, tout est déjà dans l’OMI.

  1. Créez la VM à partir de votre OMI et enregistrez son identifiant dans la variable VM_ID :

    Terminal window
    VM_ID=$(octl iaas vm create \
    --image-id $OMI_ID \
    --type tinav5.c1r1p2 \
    --security-group-id $SG_ID \
    --placement-subregion eu-west-2a \
    -o text --jq '.VmId')
    echo $VM_ID

    Comparez avec la commande de l’étape 3.4 du Lab 05 : l’option --image-id désigne votre OMI, et il n’y a ni option --keypair-name, ni script Cloud-init.

  2. Nommez la VM en lui ajoutant le tag Name :

    Terminal window
    octl iaas tag create --resource-id $VM_ID --key Name --value architecte-lab10-vm-web-v1
  3. Attendez que la VM passe à l’état running :

    Terminal window
    octl iaas vm describe $VM_ID --waitfor '.State=="running"'
  4. Récupérez l’IP publique de la VM :

    Terminal window
    VM_IP=$(octl iaas vm describe $VM_ID -o text --jq '.PublicIp')
    echo $VM_IP
  1. Interrogez la page de health check toutes les 5 secondes, jusqu’à ce qu’elle réponde :

    Terminal window
    until curl -s --max-time 3 http://$VM_IP/health.html; do sleep 5; done

    La commande affiche OK dès qu’Apache répond, une trentaine de secondes après le passage à l’état running : le temps que le système démarre. Au Lab 09, il fallait attendre plusieurs minutes de plus, le temps que Cloud-init installe Apache et PHP.

  2. Affichez la page de l’application :

    Terminal window
    curl -s http://$VM_IP/

    Le résultat ressemble à ceci, avec vos propres valeurs :

    Terminal window
    <!DOCTYPE html>
    <html lang="fr">
    <head>
    <meta charset="UTF-8">
    <title>OUTSCALE - Lab 10</title>
    </head>
    <body>
    <h1>Lab 10 - VM créée depuis une OMI construite avec Packer</h1>
    <p>Version de l'application : v1</p>
    <p>VM web : ip-10-9-42-117</p>
    </body>
    </html>
    • v1 : la version enregistrée dans l’OMI au moment de la construction.
    • Le nom d’hôte est celui de la nouvelle VM, et non celui de la VM temporaire de Packer : il est calculé par PHP à chaque affichage.
  3. Ouvrez l’URL http://<VM_IP> dans votre navigateur, en remplaçant <VM_IP> par la valeur de la variable VM_IP.

Remarque : si curl ne répond toujours pas au bout de deux minutes, vérifiez que votre adresse IP publique n’a pas changé depuis l’étape 1.2 (curl -s https://api.ipify.org), puis la règle du Security Group (étape 5.1).

Pour valider votre lab, vérifiez les points suivants :

  • packer validate -var "mon_ip=$MON_IP" . affiche The configuration is valid.
  • Aucun fichier du projet ne contient votre access key ni votre Secret Key.
  • La sortie de packer build affiche Authorizing access to port 22 from <VOTRE_IP>/32 et se termine par OMIs were created.
  • octl iaas image describe $OMI_ID affiche l’OMI architecte-lab10-web-v1 à l’état available, privée, avec un snapshot dans BlockDeviceMappings.
  • octl iaas snapshot list --tag-value architecte-lab10-web-v1 affiche un snapshot à l’état completed.
  • Aucune ressource temporaire packer_ ne subsiste dans votre compte.
  • La VM architecte-lab10-vm-web-v1 n’a pas de paire de clés, et curl -s http://$VM_IP/ affiche Version de l'application : v1.

Votre équipe publie une nouvelle version de l’application. Vous construisez une nouvelle OMI, sans modifier ni supprimer la VM architecte-lab10-vm-web-v1.

  1. Construisez l’OMI de la version 2 :

    Terminal window
    packer build -var "mon_ip=$MON_IP" -var "version_app=2" .
  2. Créez une VM architecte-lab10-vm-web-v2 à partir de cette OMI, avec le même type de VM et le même Security Group, et enregistrez son IP publique dans la variable VM2_IP.

  3. Comparez les pages des deux VMs :

    Terminal window
    curl -s http://$VM_IP/ | grep Version
    curl -s http://$VM2_IP/ | grep Version
  4. Relancez la construction de la version 1, sans l’option version_app :

    Terminal window
    packer build -var "mon_ip=$MON_IP" .

Question : La VM architecte-lab10-vm-web-v1 affiche-t-elle la version 2 ? Comment mettriez-vous à jour l’application d’une VM existante avec cette méthode ?

Question : Pourquoi la construction de l’étape 4 échoue-t-elle dès le début ? Pourquoi est-ce une bonne chose ?

Question : Pour la suite du parcours, comment utiliseriez-vous votre OMI dans la configuration Terraform du Lab 09 ?

💡 Correction — Création de la VM de la version 2
Terminal window
OMI2_ID=$(octl iaas image list --name architecte-lab10-web-v2 -o text --jq '.ImageId')
VM2_ID=$(octl iaas vm create \
--image-id $OMI2_ID \
--type tinav5.c1r1p2 \
--security-group-id $SG_ID \
--placement-subregion eu-west-2a \
-o text --jq '.VmId')
octl iaas tag create --resource-id $VM2_ID --key Name --value architecte-lab10-vm-web-v2
octl iaas vm describe $VM2_ID --waitfor '.State=="running"'
VM2_IP=$(octl iaas vm describe $VM2_ID -o text --jq '.PublicIp')
until curl -s --max-time 3 http://$VM2_IP/health.html; do sleep 5; done

La première commande curl de l’étape 3 affiche v1, la seconde v2.

💡 Correction — Questions du challenge

La VM v1 reste en version 1. Une OMI ne sert qu’au moment de la création d’une VM : la VM reçoit une copie du snapshot comme volume racine, puis vit indépendamment de l’OMI. Construire une nouvelle OMI ne change aucune VM existante. Pour mettre à jour l’application, on ne modifie pas la VM : on la remplace par une VM créée à partir de la nouvelle OMI. Derrière un load balancer, comme aux Labs 06 et 09, on enregistre la VM v2 comme VM backend, puis on retire et on supprime la VM v1, sans interruption de service. C’est le principe de l’infrastructure immuable : une VM n’est jamais modifiée après sa création.

La construction échoue à l’étape Prevalidating OMI Name, avec l’erreur name conflicts with an existing OMI: architecte-lab10-web-v1. Le nom d’une OMI est unique dans un compte, et Packer le vérifie avant de créer la moindre ressource. C’est une protection : une OMI publiée sous un nom donné garde toujours le même contenu, et une VM créée « depuis la v1 » aujourd’hui est identique à celle créée hier. Pour une nouvelle version, on change le nom. L’option force_deregister = true du builder supprime l’ancienne OMI avant d’en créer une nouvelle sous le même nom : elle est pratique pendant la mise au point d’un modèle, mais elle fait perdre cette garantie.

Dans le Lab 09, on remplace la recherche de l’OMI Ubuntu officielle par celle de votre OMI, en filtrant par nom et par propriétaire, pour ne jamais sélectionner l’OMI d’un autre compte qui porterait le même nom :

data "outscale_image" "web" {
filter {
name = "account_ids"
values = ["<ID_COMPTE>"]
}
filter {
name = "image_names"
values = ["architecte-lab10-web-v1"]
}
}

Remplacez <ID_COMPTE> par l’identifiant de votre compte, affiché par octl iaas image describe $OMI_ID -o text --jq '.AccountId'. Dans la ressource outscale_vm, image_id utilise alors data.outscale_image.web.image_id, et l’attribut user_data devient inutile : les VMs n’ont plus besoin du NAT Service pour installer leurs paquets. Changer de version de l’application revient à changer le nom de l’OMI : le plan Terraform annonce alors le remplacement des VMs, que vous lisez avant de l’appliquer.

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Les ressources de ce lab ne sont pas réutilisées dans les labs suivants. Conservez uniquement :

  • octl et son profil default ;
  • Packer et son plugin OUTSCALE ;
  • le dossier ~/architecte-lab10, si vous souhaitez garder le modèle Packer. Supprimez-le sinon.

Supprimez les ressources dans cet ordre avec octl. L’option -y répond automatiquement Yes à la confirmation de suppression.

  1. Supprimer les VMs :

    • architecte-lab10-vm-web-v1
    • architecte-lab10-vm-web-v2 (si vous avez fait le challenge)
    Terminal window
    octl iaas vm delete $VM_ID -y

    Si vous avez fait le challenge, supprimez aussi la deuxième VM :

    Terminal window
    octl iaas vm delete $VM2_ID -y

    Relancez la commande suivante jusqu’à ce que les VMs soient à l’état terminated ou n’apparaissent plus :

    Terminal window
    octl iaas vm list --tag-value architecte-lab10-vm-web-v1,architecte-lab10-vm-web-v2
  2. Supprimer le Security Group :

    • architecte-lab10-sg-web
    Terminal window
    octl iaas securitygroup delete $SG_ID -y
  3. Supprimer les OMI, puis leurs snapshots. Une OMI doit être supprimée avant son snapshot : l’API OUTSCALE refuse de supprimer un snapshot utilisé par une OMI.

    • OMI architecte-lab10-web-v1 et son snapshot
    Terminal window
    octl iaas image delete $OMI_ID -y
    octl iaas snapshot delete $SNAP_ID -y

    Si vous avez fait le challenge, supprimez aussi l’OMI architecte-lab10-web-v2 et son snapshot :

    Terminal window
    SNAP2_ID=$(octl iaas image describe $OMI2_ID -o text --jq '.BlockDeviceMappings[0].Bsu.SnapshotId')
    octl iaas image delete $OMI2_ID -y
    octl iaas snapshot delete $SNAP2_ID -y
  4. Vérifier la suppression :

    Terminal window
    octl iaas image list --name architecte-lab10-web-v1,architecte-lab10-web-v2
    octl iaas snapshot list --tag-value architecte-lab10-web-v1,architecte-lab10-web-v2
    octl iaas keypair list --filter KeypairName:packer
    octl iaas securitygroup list --filter SecurityGroupName:packer

    Les commandes n’affichent plus aucune ressource.

Remarque : si la suppression du Security Group échoue avec une erreur de dépendance, la VM n’est pas encore entièrement supprimée : attendez une minute, puis relancez la commande.

Remarque : si une construction Packer a été interrompue brutalement (terminal fermé, coupure réseau), des ressources temporaires peuvent subsister. Supprimez-les avec octl : la VM architecte-lab10-build, puis le Security Group et la paire de clés dont le nom commence par packer_.