Présentation de cette formation

Packer est l’outil HashiCorp de référence pour créer des images machine identiques sur de multiples plateformes (Docker, AWS, Azure, GCP, Proxmox, etc.). Cette formation vous accompagne du premier template jusqu’à l’automatisation complète de vos workflows de création d’images.

Contrairement à une documentation classique, cette formation suit une progression pédagogique : chaque module s’appuie sur les précédents, avec des exemples pratiques testables immédiatement.

En bref


Public	Développeurs, DevOps, SRE, équipes plateforme
Prérequis	Terminal Linux, bases Docker (pour les exemples)
Durée totale	~4 heures (7 modules)
Approche	Théorie + templates `.pkr.hcl` + labs Docker

Ce que vous apprendrez

À la fin de cette formation, vous serez capable de :

Créer des images reproductibles multi-plateformes
Écrire des templates HCL2 clairs et maintenables
Paramétrer avec variables, locals et fonctions built-in
Configurer provisioners (shell, file, Ansible)
Enchaîner des post-processors (compress, manifest, Docker)
Intégrer Packer dans vos pipelines CI/CD

Vue d’ensemble de la formation

Module	Titre	Niveau	Durée	Ce que vous saurez faire
1	Concepts et cas d’usage	Débutant	30 min	« Je comprends pourquoi Packer et quand l’utiliser »
2	Installation multi-plateforme	Débutant	20 min	« Packer est installé et je peux l’exécuter »
3	Templates HCL2	Débutant	45 min	« Je sais écrire un template HCL2 de base »
4	Variables et fonctions	Intermédiaire	45 min	« Je paramètre mes builds avec variables et fonctions »
5	Provisioners	Intermédiaire	45 min	« Je configure mes images avec shell, file ou Ansible »
6	Post-processors	Intermédiaire	45 min	« J’enchaîne des actions post-build (compress, push Docker) »
7	Bonnes pratiques	Intermédiaire	40 min	« Mes templates sont maintenables et intégrés en CI/CD »

Le parcours de formation

Module 1 · Concepts

Comprendre Packer et son écosystème

Golden images, philosophie HashiCorp, comparaison avec Dockerfile, principaux builders.

Commencer les concepts →

Module 2 · Installation

Installer Packer sur votre système

Binaire officiel, asdf, gestionnaires de paquets, validation de l’installation.

Installer Packer →

Module 3 · Templates HCL2

Écrire votre premier template

Anatomie d’un template, blocs source et build, builder Docker, premier build.

Écrire des templates →

Module 4 · Variables et fonctions

Paramétrer vos builds

Variables, locals, pkrvars, fonctions built-in, expressions conditionnelles.

Utiliser les variables →

Module 5 · Provisioners

Configurer vos images

Shell, file, Ansible, provisioner de nettoyage, bonnes pratiques de configuration.

Configurer avec provisioners →

Module 6 · Post-processors

Actions post-build

Compress, manifest, checksum, docker-import, docker-tag, docker-push, chaînage.

Enchaîner des post-processors →

Module 7 · Bonnes pratiques

Industrialiser vos templates

Structure projet, Makefile, debug, sécurité des secrets, intégration CI/CD.

Appliquer les bonnes pratiques →

FAQ Packer

Questions fréquentes

Réponses aux questions courantes sur Packer, dépannage, comparaisons avec d’autres outils.

Consulter la FAQ →

Programme détaillé

Module 1 — Concepts et cas d’usage

Le premier module pose les fondations. Vous comprendrez pourquoi Packer existe, ce qu’est une « golden image », et quand utiliser Packer plutôt qu’un Dockerfile ou un script shell.

Thème	Contenu
Problématique	Dérive de configuration, images non reproductibles
Golden images	Définition, avantages, immutable infrastructure
Philosophie HashiCorp	Workflow Plan → Apply, idempotence
Builders	Docker, AWS, Azure, GCP, Proxmox, QEMU
Comparaison	Packer vs Dockerfile vs scripts shell

Commencer le Module 1 Comprendre Packer et pourquoi l'utiliser

Module 2 — Installation multi-plateforme

Installation de Packer sur Linux, macOS et Windows. Nous recommandons asdf pour gérer plusieurs versions côte à côte.

Méthode	Commande
asdf (recommandé)	`asdf plugin add packer && asdf install packer latest`
Binaire officiel	Téléchargement depuis releases.hashicorp.com
Homebrew (macOS)	`brew install packer`
Chocolatey (Windows)	`choco install packer`

Installer Packer Choisir la méthode d'installation adaptée à votre système

Module 3 — Templates HCL2

Le cœur de Packer : les templates HCL2. Vous apprendrez la structure d’un fichier .pkr.hcl, les blocs source et build, et comment créer votre première image Docker.

Bloc	Rôle
`packer {}`	Configuration Packer, plugins requis
`source`	Définition du builder (Docker, AWS, etc.)
`build`	Orchestration des sources, provisioners, post-processors

source "docker" "ubuntu" {
  image  = "ubuntu:24.04"
  commit = true
}

build {
  sources = ["source.docker.ubuntu"]
}

Écrire des templates HCL2 Anatomie d'un template et premier build Docker

Module 4 — Variables et fonctions

Rendez vos templates flexibles et réutilisables avec les variables, locals et fonctions built-in.

Concept	Exemple
Variables	`variable "image_tag" { default = "latest" }`
Locals	`local { timestamp = formatdate("YYYYMMDDhhmmss", timestamp()) }`
Fonctions	`upper()`, `lower()`, `replace()`, `join()`, `file()`
Conditionnelles	`condition ? true_val : false_val`

Paramétrer avec variables et fonctions Variables, locals, fichiers .pkrvars.hcl et fonctions built-in

Module 5 — Provisioners

Les provisioners configurent l’image après sa création : installation de paquets, copie de fichiers, exécution de playbooks Ansible.

Provisioner	Usage
shell	Commandes bash/sh, scripts
file	Copie de fichiers locaux vers l’image
ansible	Exécution de playbooks Ansible
shell-local	Commandes sur la machine hôte

Configurer avec provisioners Shell, file, Ansible et bonnes pratiques de configuration

Module 6 — Post-processors

Les post-processors agissent après le build : compression, génération de manifest, push vers un registry Docker.

Post-processor	Résultat
compress	Archive `.tar.gz` de l’image
manifest	Fichier JSON avec métadonnées du build
checksum	Hash SHA256 pour vérification d’intégrité
docker-import	Importation dans Docker Engine
docker-tag	Tag de l’image Docker
docker-push	Push vers Docker Hub/Registry privé

Enchaîner des post-processors Actions post-build et chaînage de post-processors

Module 7 — Bonnes pratiques

Industrialisez vos templates avec une structure projet propre, un Makefile, des techniques de debug et l’intégration CI/CD.

Thème	Contenu
Structure projet	Organisation des fichiers `.pkr.hcl`
Makefile	Cibles `validate`, `build`, `clean`
Debug	Variables `PACKER_LOG`, mode step-by-step
Secrets	Variables d’environnement, pas de hardcode
CI/CD	GitHub Actions, GitLab CI/CD

Appliquer les bonnes pratiques Structure, Makefile, debug et intégration CI/CD

Par où commencer ?

Suivez les modules dans l’ordre, en commençant par les concepts. Prenez le temps de créer les labs Docker pour chaque module.

Premier module : Concepts et cas d’usage

Ressources complémentaires

Site officiel : packer.io
Documentation : developer.hashicorp.com/packer/docs
Référence HCL2 : developer.hashicorp.com/packer/docs/templates/hcl_templates
Builders : developer.hashicorp.com/packer/integrations
GitHub Packer : github.com/hashicorp/packer

Formation Packer : du template de base à l'automatisation complète