Installation de Packer et premier build

Ce guide vous accompagne dans l’installation de Packer et la création de votre première image. En 10 minutes, vous aurez un environnement fonctionnel et aurez validé que tout fonctionne avec un premier build Docker.

Ce que vous allez apprendre

Installer Packer sur Linux, macOS ou Windows
Gérer plusieurs versions avec mise ou asdf
Installer des plugins avec packer init
Valider et exécuter votre premier build

Prérequis : accès administrateur sur votre machine. Pour le premier build : Docker installé et démarré.

Pourquoi installer Packer correctement ?

Avant de plonger dans l’installation, comprenons pourquoi la méthode d’installation est importante. Packer est un outil en constante évolution — la version 1.15.0 apporte des fonctionnalités importantes absentes des versions précédentes. Utiliser une version à jour garantit :

L’accès aux dernières fonctionnalités (évaluation DAG, nouvelles fonctions HCL)
Les correctifs de sécurité récents
La compatibilité avec les plugins les plus récents

Installation sur Linux

Linux offre plusieurs méthodes d’installation. Choisissez celle qui correspond à votre workflow habituel.

Méthode 1 : Gestionnaire de paquets APT (Debian/Ubuntu)

Cette méthode utilise le dépôt officiel HashiCorp. Elle est idéale pour les serveurs de CI/CD car les mises à jour se font via apt upgrade. L’inconvénient est que la version peut avoir quelques jours de retard sur la dernière release.

Commencez par ajouter la clé GPG et le dépôt HashiCorp à votre système :

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

La première commande télécharge et installe la clé de signature HashiCorp. La seconde ajoute le dépôt à vos sources APT en détectant automatiquement votre distribution (jammy, focal, etc.).

Installez ensuite Packer :

sudo apt update && sudo apt install packer

Méthode 2 : Téléchargement binaire (toutes distributions)

Cette méthode offre un contrôle total sur la version installée. Elle est recommandée quand vous avez besoin d’une version spécifique ou sur des systèmes sans gestionnaire de paquets compatible.

Téléchargez et installez Packer en une seule commande :

curl -fsSL -o /tmp/packer.zip https://releases.hashicorp.com/packer/1.15.0/packer_1.15.0_linux_amd64.zip
unzip /tmp/packer.zip -d /tmp
sudo mv /tmp/packer /usr/local/bin/
rm /tmp/packer.zip

Ces commandes téléchargent l’archive depuis le site officiel HashiCorp, extraient le binaire et le placent dans /usr/local/bin/ qui est généralement dans votre PATH.

Méthode 3 : mise (recommandée pour le développement)

mise (anciennement rtx) est un gestionnaire de versions polyglotte qui permet d’installer et de basculer entre plusieurs versions de Packer. C’est la méthode recommandée pour les développeurs qui travaillent sur plusieurs projets.

Si mise n’est pas encore installé, commencez par l’installer :

curl https://mise.run | sh
echo 'eval "$(~/.local/bin/mise activate bash)"' >> ~/.bashrc
source ~/.bashrc

Installez ensuite Packer avec mise :

mise use -g packer@1.15.0

L’option -g (global) rend cette version disponible partout sur votre système. Pour utiliser une version spécifique dans un projet, créez un fichier .mise.toml dans le dossier du projet :

[tools]
packer = "1.15.0"

Méthode 4 : asdf (alternative à mise)

asdf est le gestionnaire de versions historique pour les outils de développement. Si vous l’utilisez déjà pour d’autres outils (Node.js, Python, Terraform), restez cohérent :

asdf plugin add packer https://github.com/asdf-community/asdf-hashicorp.git
asdf install packer 1.15.0
asdf global packer 1.15.0

La première commande ajoute le plugin Packer à asdf. La deuxième télécharge la version 1.15.0. La troisième définit cette version comme version par défaut.

Installation sur macOS

macOS offre deux méthodes principales selon que vous préférez Homebrew ou un contrôle plus fin avec mise.

Méthode 1 : Homebrew (recommandée)

Homebrew est le gestionnaire de paquets standard sur macOS. HashiCorp maintient un tap officiel pour garantir des versions à jour :

brew tap hashicorp/tap
brew install hashicorp/tap/packer

La première commande ajoute le dépôt HashiCorp à Homebrew. La seconde installe Packer. Pour mettre à jour ultérieurement, utilisez brew upgrade hashicorp/tap/packer.

Méthode 2 : mise

La méthode est identique à Linux. mise fonctionne parfaitement sur macOS :

brew install mise
mise use -g packer@1.15.0

Installation sur Windows

Windows propose deux approches : le téléchargement manuel ou Chocolatey pour l’automatisation.

Méthode 1 : Téléchargement binaire

Téléchargez Packer depuis le site officiel :

Rendez-vous sur releases.hashicorp.com/packer/1.15.0
Téléchargez packer_1.15.0_windows_amd64.zip
Extrayez le fichier packer.exe vers un dossier, par exemple C:\HashiCorp\packer\

Il faut ensuite ajouter ce dossier au PATH Windows pour pouvoir exécuter packer depuis n’importe quel terminal. Ouvrez PowerShell en tant qu’administrateur et exécutez :

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\HashiCorp\packer", "Machine")

Fermez et rouvrez votre terminal pour que la modification prenne effet.

Méthode 2 : Chocolatey

Si vous utilisez Chocolatey comme gestionnaire de paquets Windows, l’installation est plus simple. Ouvrez PowerShell en tant qu’administrateur :

choco install packer

Chocolatey gère automatiquement le PATH et les mises à jour.

Vérification de l’installation

Quelle que soit la méthode d’installation choisie, vérifiez que Packer est correctement installé. Cette étape est importante car elle confirme que le binaire est accessible et fonctionnel.

Ouvrez un nouveau terminal (important pour que les variables d’environnement soient rechargées) et exécutez :

packer --version

Vous devriez voir s’afficher la version de Packer :

Packer v1.15.0

Pour voir toutes les commandes disponibles, exécutez packer sans argument :

packer

Packer affiche alors la liste des sous-commandes :

Usage: packer [--version] [--help] <command> [<args>]

Available commands are:
    build           build image(s) from template
    console         creates a console for testing variable interpolation
    fix             fixes templates from old versions of packer
    fmt             Rewrites HCL2 config files to canonical format
    hcl2_upgrade    transform a JSON template into an HCL2 configuration
    init            Install missing plugins or upgrade plugins
    inspect         see components of a template
    validate        check that a template is valid
    version         Prints the Packer version

Activer l’autocomplétion

L’autocomplétion facilite grandement l’utilisation quotidienne de Packer. Elle vous suggère les commandes et options disponibles quand vous appuyez sur Tab.

Pour Bash ou Zsh, activez l’autocomplétion avec :

packer -autocomplete-install

Cette commande modifie votre fichier de configuration shell (.bashrc ou .zshrc). Rechargez ensuite votre shell :

source ~/.bashrc  # ou ~/.zshrc

Testez l’autocomplétion en tapant packer b puis Tab — Packer devrait compléter avec build.

Votre premier build

Maintenant que Packer est installé, créons une première image pour valider que tout fonctionne. Nous allons utiliser Docker comme builder car il ne nécessite pas de machine virtuelle et s’exécute en quelques secondes.

Créer le template

Créez un dossier pour votre projet et un fichier template. Le template est un fichier HCL (HashiCorp Configuration Language) qui décrit l’image à construire :

mkdir -p ~/packer-demo
cd ~/packer-demo

Créez le fichier hello-world.pkr.hcl avec le contenu suivant :

# Bloc packer : définit la version minimale et les plugins requis
packer {
  required_version = ">= 1.15.0"

  required_plugins {
    docker = {
      version = ">= 1.1.0"
      source  = "github.com/hashicorp/docker"
    }
  }
}

# Source : définit l'image de base et le builder à utiliser
source "docker" "alpine" {
  image  = "alpine:3.20"
  commit = true
}

# Build : assemble la source et les provisioners
build {
  name    = "hello-packer"
  sources = ["source.docker.alpine"]

  provisioner "shell" {
    inline = [
      "echo '=========================================='",
      "echo '  Félicitations ! Packer fonctionne !'",
      "echo '=========================================='",
      "cat /etc/os-release | grep PRETTY_NAME"
    ]
  }
}

Ce template définit trois éléments essentiels :

Le bloc packer déclare la version minimale requise et le plugin Docker à télécharger
Le bloc source spécifie l’image de base (Alpine Linux 3.20) et le builder Docker
Le bloc build définit ce que Packer doit faire : utiliser la source alpine et exécuter un provisioner shell

Initialiser les plugins

Avant de construire, Packer doit télécharger les plugins déclarés dans le bloc required_plugins. Cette étape est nécessaire une seule fois par projet (ou quand vous ajoutez un nouveau plugin) :

packer init hello-world.pkr.hcl

Packer télécharge le plugin Docker depuis le registry HashiCorp :

Installed plugin github.com/hashicorp/docker v1.1.2 in "/home/user/.config/packer/plugins/..."

Les plugins sont installés globalement dans votre dossier de configuration Packer, ils sont donc disponibles pour tous vos projets.

Valider le template

Avant de lancer un build qui peut prendre du temps, validez que le template est syntaxiquement correct. Cette commande ne crée rien, elle vérifie simplement la cohérence :

packer validate hello-world.pkr.hcl

Si tout est correct, Packer affiche :

The configuration is valid.

Si vous avez une erreur, Packer indique la ligne et le type de problème. Corrigez et re-validez avant de continuer.

Construire l’image

C’est le moment de vérité. Lancez le build avec :

packer build hello-world.pkr.hcl

Packer exécute alors les étapes suivantes :

Télécharge l’image Alpine depuis Docker Hub (si pas en cache)
Démarre un conteneur temporaire
Exécute le provisioner shell dans le conteneur
Crée une nouvelle image Docker à partir du conteneur modifié
Supprime le conteneur temporaire

Vous devriez voir une sortie similaire à :

hello-packer.docker.alpine: output will be in this color.

==> hello-packer.docker.alpine: Creating a temporary directory for sharing data...
==> hello-packer.docker.alpine: Pulling Docker image: alpine:3.20
...
==> hello-packer.docker.alpine: Provisioning with shell script: /tmp/packer-shell...
==> hello-packer.docker.alpine: ==========================================
==> hello-packer.docker.alpine:   Félicitations ! Packer fonctionne !
==> hello-packer.docker.alpine: ==========================================
==> hello-packer.docker.alpine: PRETTY_NAME="Alpine Linux v3.20"
==> hello-packer.docker.alpine: Committing the container
==> hello-packer.docker.alpine: Image ID: sha256:abc123...
Build 'hello-packer.docker.alpine' finished after 3 seconds.

==> Builds finished. The artifacts of successful builds are:
--> hello-packer.docker.alpine: Imported Docker image: sha256:abc123...

Félicitations ! Vous avez créé votre première image avec Packer.

Les commandes essentielles

Maintenant que vous avez un environnement fonctionnel, voici un récapitulatif des commandes que vous utiliserez quotidiennement :

Commande	Description	Quand l’utiliser
`packer init`	Télécharge les plugins requis	Une fois par projet, ou après ajout d’un plugin
`packer validate`	Vérifie la syntaxe du template	Avant chaque build, obligatoire
`packer build`	Construit l’image	Quand le template est validé
`packer fmt`	Formate le code HCL	Pour maintenir un style cohérent
`packer inspect`	Affiche les détails du template	Pour debug ou documentation

Options utiles de packer build

La commande build accepte plusieurs options qui modifient son comportement :

# Construire avec des variables personnalisées
packer build -var="image_name=mon-app" template.pkr.hcl

# Construire uniquement certaines sources (si plusieurs définies)
packer build -only="docker.ubuntu" template.pkr.hcl

# Mode debug : pause entre chaque étape
packer build -debug template.pkr.hcl

# Afficher les logs détaillés
PACKER_LOG=1 packer build template.pkr.hcl

Dépannage

Voici les problèmes les plus fréquents lors de l’installation et leurs solutions :

Symptôme	Cause probable	Solution
`packer: command not found`	Binaire pas dans le PATH	Vérifiez l’installation, ouvrez un nouveau terminal
`Permission denied` sur `/usr/share/cracklib/`	Conflit avec un autre outil `packer`	Utilisez le chemin complet `/usr/local/bin/packer` ou créez un alias
`Error initializing plugin`	Pas d’accès internet ou proxy	Configurez `HTTPS_PROXY` ou téléchargez le plugin manuellement
`Docker daemon not running`	Docker pas démarré	`sudo systemctl start docker`
`dial unix /var/run/docker.sock: permission denied`	Utilisateur pas dans le groupe docker	`sudo usermod -aG docker $USER` puis déconnexion/reconnexion

À retenir

Packer v1.15.0 est la version actuelle, téléchargez-la depuis releases.hashicorp.com
mise ou asdf permettent de gérer plusieurs versions (recommandé pour le développement)
Homebrew est la méthode la plus simple sur macOS
packer init télécharge les plugins déclarés dans required_plugins
packer validate vérifie la syntaxe avant de construire
packer build crée l’image — toujours valider avant !
L’autocomplétion s’active avec packer -autocomplete-install

Prochaines étapes

Concepts Packer Comprenez les builders, provisioners et post-processors

Templates HCL2 Maîtrisez la syntaxe des fichiers .pkr.hcl

Variables et fonctions Rendez vos templates dynamiques et réutilisables

Provisioners Configurez vos images avec Shell, Ansible et File

Post-processors Transformez vos artefacts : compression, checksums, Docker