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

Q: Qu'est-ce que Packer et à quoi sert-il ?

Packer est un outil open source HashiCorp qui crée des images machine identiques pour plusieurs plateformes (Docker, AWS AMI, Azure, GCP, Proxmox) à partir d'une configuration unique. Il automatise des images reproductibles pour les golden images et l'immutable infrastructure.

Q: Quelle est la différence entre Packer et un Dockerfile ?

Packer est multi-plateforme (Docker, AWS, Azure, GCP) alors que Dockerfile ne produit que des images Docker. Packer utilise HCL2 et des provisioners variés (shell, Ansible) pour créer des formats natifs (AMI, VMDK). Dockerfile est plus simple mais mono-cible.

Q: Comment installer Packer sur Linux, macOS ou Windows ?

Packer est un binaire unique sans dépendances. Sur Linux, utilisez asdf ou téléchargez depuis releases.hashicorp.com. Sur macOS, Homebrew (brew install packer) ; sur Windows, Chocolatey (choco install packer). Vérifiez l'installation avec packer --version.

Q: Qu'est-ce qu'un template HCL2 Packer ?

Un template HCL2 est un fichier .pkr.hcl qui définit comment créer une image. Il contient des blocs : packer (plugins), source (builder Docker ou AWS), build (provisioners et post-processors), variable et locals. HCL2 remplace le format JSON depuis Packer 1.5.

Q: Comment valider un template Packer avant le build ?

Utilisez packer init pour télécharger les plugins, packer fmt -check pour le formatage, puis packer validate pour la syntaxe et la cohérence. En CI/CD, chaînez les trois avec && pour échouer au premier problème. L'option -var passe les variables requises.

Q: Quels sont les principaux builders Packer ?

Packer supporte de nombreux builders : Docker, Amazon EBS (AMI AWS), Azure ARM, Google Compute (GCP), QEMU (QCOW2 pour KVM/Proxmox), VMware ISO, VirtualBox ISO, LXC/LXD et Null (test de provisioners sans créer d'image).

Q: Comment utiliser les variables dans Packer ?

Déclarez avec variable "nom" { default = "valeur" } et utilisez var.nom. Types : string, number, bool, list, map, object. Passez les valeurs via CLI (-var), fichier .pkrvars.hcl (-var-file) ou environnement (PKR_VAR_nom). Les locals sont des valeurs calculées.

Q: Qu'est-ce qu'un provisioner Packer ?

Un provisioner configure l'image après sa création : installation de paquets, copie de fichiers, scripts. Types : shell (commandes bash), file (copie), ansible (playbooks), shell-local (sur l'hôte). Ils s'exécutent dans l'ordre de déclaration du bloc build.

Q: Comment débugger un build Packer qui échoue ?

Activez les logs avec PACKER_LOG=1 packer build. Utilisez -debug pour le mode interactif (pause par étape) et -on-error=ask pour choisir en cas d'erreur (abort, retry, cleanup). Le problème vient souvent du script shell ou de la connexion SSH du provisioner.

Q: Qu'est-ce qu'un post-processor Packer ?

Un post-processor agit sur l'image après le build : compression (compress), métadonnées (manifest), checksum, import Docker (docker-import), tag (docker-tag), push vers un registry (docker-push). Ils se chaînent dans un bloc post-processors pour des workflows complexes.

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, avec un fil conducteur : chaque notion est rejouée sur le builder Docker, sans compte cloud ni coût.

Elle s'adresse aux développeurs, aux DevOps, aux SRE et aux équipes plateforme. Pour la suivre, il suffit de savoir utiliser un terminal Linux et de connaître les bases de Docker, que tous les exemples emploient comme builder. Contrairement à une documentation classique, la formation suit une progression pédagogique : chaque module s'appuie sur les précédents, avec des exemples pratiques testables immédiatement.

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

Le tableau ci-dessous reprend les modules du parcours, avec les intitulés et les durées que le plan de formation affiche dans la colonne de gauche. Chaque ligne indique la capacité concrète acquise à la fin du module. Suivez-les dans l'ordre si vous débutez : le second suppose qu'un premier build Docker a réussi, et le troisième réutilise le template paramétré du second.

Module	Leçons	Durée	Ce que vous saurez faire
Découvrir Packer et réussir un premier build	2	1 h 05	« Je sais pourquoi Packer existe, il est installé et j'ai construit une première image Docker »
Écrire un template HCL2 paramétrable	2	1 h	« J'écris un template HCL2 propre et je le paramètre avec variables, locals et fonctions »
Configurer l'image et industrialiser la chaîne de build	3	2 h	« Je configure mes images avec shell, file ou Ansible, j'enchaîne des post-processors et mes templates passent en CI/CD »

Le programme, module par module

Découvrir Packer et réussir un premier build

Le premier module pose les fondations et se termine par une image qui existe réellement. La leçon Concepts et architecture (25 min) explique pourquoi Packer existe, ce qu'est une « golden image », comment s'enchaînent builders, provisioners et post-processors dans un build, et quand utiliser Packer plutôt qu'un Dockerfile ou un outil de gestion de configuration comme Ansible. La leçon Installation (40 min) installe le binaire sur Linux, macOS ou Windows, vérifie la version, puis construit une première image Docker de bout en bout pour valider la chaîne.

Thème	Contenu
Problématique	Dérive de configuration, images non reproductibles
Golden images	Définition, avantages, immutable infrastructure
Workflow	Ce qui se passe pendant un build, étape par étape
Builders	Docker, AWS, Azure, GCP, Proxmox, QEMU
Comparaison	Packer vs Ansible, Chef et Dockerfile

Pour l'installation, la leçon recommande mise quand on développe, parce qu'il gère plusieurs versions côte à côte et se fixe par projet dans un .mise.toml ; le dépôt APT officiel de HashiCorp convient aux serveurs de CI, et Homebrew reste la voie naturelle sur macOS. Avec mise, l'installation tient en une commande :

mise use -g packer@1.15.0

Écrire un template HCL2 paramétrable

Le cœur de Packer : les templates HCL2. La leçon Templates HCL2 (25 min) détaille la structure d'un fichier .pkr.hcl, les blocs packer, source et build, le découpage en plusieurs fichiers et les commandes fmt, validate et inspect qui rattrapent les erreurs avant le build. La leçon Variables et fonctions (35 min) rend ensuite le template flexible : variables d'entrée, locals, fichiers .pkrvars.hcl, data sources et fonctions built-in, pour ne plus recopier un template par environnement.

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

Le template minimal ci-dessous est celui du premier build : une source Docker figée par son digest, et un bloc build qui ne fait que la référencer. Tout le reste de la formation ajoute des blocs à ce squelette.

source "docker" "ubuntu" {
  image  = "ubuntu:24.04@sha256:534baea6a22c03a63003dbc8dbe78fe34bc0d7e595d9a9dc9834884ff530eb55"
  commit = true
}

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

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

Configurer l'image et industrialiser la chaîne de build

Le dernier module installe le système dans l'image, transforme l'artefact produit, puis met la chaîne en production. La leçon Provisioners (40 min) configure l'image après sa création avec les provisioners shell, file, shell-local et Ansible. La leçon Post-processors (35 min) agit après le build : compression, manifest pour la traçabilité, checksum pour l'intégrité, et push vers un registre Docker. La leçon Bonnes pratiques (45 min) industrialise vos templates : structure de projet, Makefile, techniques de debug, gestion des secrets et intégration CI/CD.

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

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 ou un registre privé

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

Par où commencer ?

Suivez les leçons dans l'ordre, en commençant par les concepts. Prenez le temps de rejouer les exemples Docker de chaque module.

Première leçon : Concepts et architecture

FAQ : questions fréquentes

Les questions les plus posées sur Packer : différence avec Dockerfile ou Terraform, licence, installation, provisioners et intégration CI/CD.

Qu'est-ce que Packer et à quoi sert-il ?

Packer est un outil open source développé par HashiCorp qui crée des images machine identiques pour plusieurs plateformes à partir d'une configuration unique.

Ce que Packer fait

Fonction	Exemple
Création d'images	AMI AWS, images Docker, VM Azure
Multi-plateforme	1 template → plusieurs images
Automatisation	Build reproductible sans intervention
Golden images	Image de base standardisée

Exemple rapide

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

build {
  sources = ["source.docker.ubuntu"]
  provisioner "shell" {
    inline = ["apt-get update && apt-get install -y curl"]
  }
}

Quelle est la différence entre Packer et un Dockerfile ?

La différence principale est le périmètre d'utilisation :

Comparaison

Critère	Packer	Dockerfile
Cible	Multi-plateforme	Docker uniquement
Format	HCL2	DSL spécifique
Provisioners	Shell, Ansible, Chef, Puppet	RUN uniquement
Sortie	AMI, VMDK, OCI, Docker...	Image Docker
Écosystème	HashiCorp	Docker/OCI
Cas d'usage	Golden images multi-cloud	Conteneurs applicatifs

Quand utiliser quoi ?

Dockerfile : applications conteneurisées, développement local
Packer : golden images multi-cloud, immutable infrastructure
Les deux : Packer peut utiliser Docker comme builder de test

Exemple identique

# Dockerfile
FROM ubuntu:24.04
RUN apt-get update && apt-get install -y curl

# Packer HCL2
source "docker" "ubuntu" {
  image  = "ubuntu:24.04"
  commit = true
}
build {
  sources = ["source.docker.ubuntu"]
  provisioner "shell" {
    inline = ["apt-get update && apt-get install -y curl"]
  }
}

Comment installer Packer sur Linux, macOS ou Windows ?

Packer s'installe facilement car c'est un binaire unique sans dépendances.

Linux (recommandé : asdf)

# Avec asdf (gestion de versions)
asdf plugin add packer
asdf install packer latest
asdf set --home packer latest

# Ou téléchargement direct
wget https://releases.hashicorp.com/packer/1.15.0/packer_1.15.0_linux_amd64.zip
unzip packer_1.15.0_linux_amd64.zip
sudo mv packer /usr/local/bin/

macOS

# Homebrew
brew install packer

Windows

# Chocolatey
choco install packer

# Ou Scoop
scoop install packer

Vérification

packer --version
# Packer v1.15.0

Qu'est-ce qu'un template HCL2 Packer ?

Un template HCL2 est un fichier .pkr.hcl qui définit comment créer une image.

Blocs principaux

Bloc	Rôle	Obligatoire
`packer {}`	Configuration, plugins requis	Optionnel
`source`	Définition du builder	Oui
`build`	Orchestration du build	Oui
`variable`	Paramètres d'entrée	Optionnel
`locals`	Valeurs calculées	Optionnel

Exemple minimal

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

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

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

HCL2 vs JSON

Aspect	HCL2	JSON (legacy)
Lisibilité	Excellente	Difficile
Commentaires	`#` ou `//`	Non supportés
Fonctions	Built-in	Limitées
Statut	Recommandé	Déprécié

Comment valider un template Packer avant le build ?

Packer propose plusieurs commandes pour valider vos templates avant de builder.

Workflow de validation

# 1. Télécharger les plugins requis
packer init .

# 2. Vérifier le formatage
packer fmt -check .

# 3. Valider la syntaxe et la cohérence
packer validate .

# Optionnel : avec des variables
packer validate -var "image_tag=latest" .

Ce que valide Packer

Commande	Vérifie
`packer init`	Plugins disponibles et téléchargés
`packer fmt -check`	Formatage HCL conforme
`packer validate`	Syntaxe, références, cohérence

En CI/CD

# Échouer au premier problème
packer init . && packer fmt -check . && packer validate .

Exemple de sortie

$ packer validate .
The configuration is valid.

$ packer validate broken.pkr.hcl
Error: Unknown source type "docker.ubuntu"

Quels sont les principaux builders Packer ?

Packer supporte de nombreux builders pour créer des images sur différentes plateformes.

Builders principaux

Builder	Plateforme	Sortie
docker	Docker Engine	Image OCI
amazon-ebs	AWS	AMI
azure-arm	Azure	Managed Image
googlecompute	GCP	Compute Image
qemu	KVM/Proxmox	QCOW2
vmware-iso	VMware	VMDK
virtualbox-iso	VirtualBox	OVA
lxc / lxd	Conteneurs Linux	Image LXC/LXD
null	Test	Aucune (dry-run)

Installation des plugins

packer {
  required_plugins {
    docker = {
      version = ">= 1.0.0"
      source  = "github.com/hashicorp/docker"
    }
    amazon = {
      version = ">= 1.0.0"
      source  = "github.com/hashicorp/amazon"
    }
  }
}

Multi-plateforme

Un même template peut cibler plusieurs builders :

build {
  sources = [
    "source.docker.ubuntu",
    "source.amazon-ebs.ubuntu"
  ]
}

Comment utiliser les variables dans Packer ?

Les variables rendent vos templates flexibles et réutilisables.

Déclaration

variable "image_tag" {
  type        = string
  default     = "latest"
  description = "Tag de l'image Docker"
}

variable "packages" {
  type    = list(string)
  default = ["curl", "wget", "vim"]
}

Utilisation

source "docker" "app" {
  image  = "ubuntu:${var.image_tag}"
  commit = true
}

Fournir des valeurs

Méthode	Exemple
CLI	`packer build -var "image_tag=1.0" .`
Fichier	`packer build -var-file=prod.pkrvars.hcl .`
Environnement	`export PKR_VAR_image_tag=1.0`

Locals (valeurs calculées)

locals {
  timestamp  = formatdate("YYYYMMDDhhmmss", timestamp())
  image_name = "app-${var.image_tag}-${local.timestamp}"
}

Qu'est-ce qu'un provisioner Packer ?

Un provisioner configure l'image après sa création par le builder.

Provisioners principaux

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

Exemple

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

  provisioner "file" {
    source      = "config/app.conf"
    destination = "/etc/app/app.conf"
  }

  provisioner "shell" {
    inline = [
      "apt-get update",
      "apt-get install -y nginx"
    ]
  }

  provisioner "ansible" {
    playbook_file = "playbooks/configure.yml"
  }
}

Ordre d'exécution

Les provisioners s'exécutent dans l'ordre de déclaration :

file → copie les fichiers
shell → installe les paquets
ansible → configure l'application

Comment débugger un build Packer qui échoue ?

Plusieurs techniques pour débugger un build qui échoue.

Logs détaillés

# Activer tous les logs
export PACKER_LOG=1
packer build .

# Ou en une ligne
PACKER_LOG=1 packer build .

Mode interactif

# Pause entre chaque étape
packer build -debug .

# Pause configurable
PACKER_LOG=1 PACKER_LOG_PATH=packer.log packer build -debug .

Gestion des erreurs

# Demander quoi faire en cas d'erreur
packer build -on-error=ask .
# Options : abort, retry, cleanup

Problèmes courants

Symptôme	Cause probable
Timeout SSH	Firewall, clé SSH incorrecte
Command not found	Chemin non dans PATH
Permission denied	Utilisateur non root, sudo requis
Plugin not found	`packer init .` pas exécuté
Variable undefined	Variable déclarée mais non valorisée

Qu'est-ce qu'un post-processor Packer ?

Un post-processor agit sur l'image après le build : transformation, métadonnées, publication.

Post-processors principaux

Post-processor	Action
compress	Archive `.tar.gz` de l'image
manifest	Fichier JSON avec métadonnées
checksum	Hash SHA256 pour intégrité
docker-import	Import dans Docker Engine
docker-tag	Ajout de tags à l'image
docker-push	Push vers registry

Exemple simple

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

  post-processor "manifest" {
    output = "manifest.json"
  }
}

Chaînage de post-processors

post-processors {
  post-processor "docker-import" {
    repository = "myapp"
    tag        = "latest"
  }
  post-processor "docker-push" {
    login          = true
    login_server   = "registry.example.com"
    login_username = var.registry_user
    login_password = var.registry_pass
  }
}

Le chaînage garantit que chaque étape utilise le résultat de la précédente.

Comment intégrer Packer dans un pipeline CI/CD ?

GitHub Actions

name: Build Image
on: [push]

jobs:
  packer:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Packer
        uses: hashicorp/setup-packer@v3
        with:
          version: "1.15.0"

      - name: Init
        run: packer init .

      - name: Validate
        run: packer fmt -check . && packer validate .

      - name: Build
        run: packer build .
        env:
          PKR_VAR_image_tag: ${{ github.sha }}

GitLab CI/CD

packer-build:
  image: hashicorp/packer:1.15.0
  script:
    - packer init .
    - packer fmt -check .
    - packer validate .
    - packer build .
  variables:
    PKR_VAR_image_tag: $CI_COMMIT_SHORT_SHA
  cache:
    paths:
      - .packer.d/

Bonnes pratiques CI/CD

Cacher le répertoire des plugins
Variables d'environnement pour les secrets
Validation avant le build
Manifest pour traçabilité

Comment créer une AMI AWS avec Packer ?

Créer une AMI AWS avec le builder amazon-ebs.

Template minimal

packer {
  required_plugins {
    amazon = {
      version = ">= 1.0.0"
      source  = "github.com/hashicorp/amazon"
    }
  }
}

variable "aws_region" {
  default = "eu-west-3"
}

source "amazon-ebs" "ubuntu" {
  region        = var.aws_region
  instance_type = "t3.micro"

  source_ami_filter {
    filters = {
      name                = "ubuntu/images/*ubuntu-jammy-22.04-amd64-server-*"
      root-device-type    = "ebs"
      virtualization-type = "hvm"
    }
    most_recent = true
    owners      = ["099720109477"]  # Canonical
  }

  ssh_username = "ubuntu"
  ami_name     = "my-app-{{timestamp}}"
}

build {
  sources = ["source.amazon-ebs.ubuntu"]

  provisioner "shell" {
    inline = ["sudo apt-get update && sudo apt-get install -y nginx"]
  }
}

Authentification

export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG..."
packer build .

Comment structurer un projet Packer avec plusieurs templates ?

Structure recommandée pour un projet Packer maintenable.

Arborescence

projet-packer/
├── common.pkr.hcl       # Plugins, config commune
├── variables.pkr.hcl    # Déclarations de variables
├── locals.pkr.hcl       # Valeurs calculées
├── docker.pkr.hcl       # Source Docker
├── aws.pkr.hcl          # Source AWS (optionnel)
├── build.pkr.hcl        # Blocs build
├── dev.pkrvars.hcl      # Variables dev
├── prod.pkrvars.hcl     # Variables prod
├── scripts/
│   ├── setup.sh
│   └── cleanup.sh
├── config/
│   └── app.conf
└── Makefile

Makefile

.PHONY: init validate build clean

init:
	packer init .

validate: init
	packer fmt -check .
	packer validate .

build: validate
	packer build -var-file=dev.pkrvars.hcl .

build-prod: validate
	packer build -var-file=prod.pkrvars.hcl .

clean:
	rm -f manifest.json *.tar.gz

Utilisation

make build        # Build dev
make build-prod   # Build prod

Comment gérer les secrets dans Packer sans les exposer ?

Plusieurs techniques pour sécuriser les secrets dans Packer.

Variables sensibles

variable "docker_password" {
  type      = string
  sensitive = true  # Masqué dans les logs
}

Bonnes pratiques

Méthode	Sécurité	Usage
Env vars	✅ Bonne	`PKR_VAR_password=xxx packer build .`
CI Secrets	✅ Excellente	GitHub Secrets, GitLab CI Variables
Vault	✅ Enterprise	HashiCorp Vault integration
CLI -var	⚠️ Risquée	Visible dans historique shell
Fichier committé	❌ Dangereuse	Jamais en production

En CI/CD

# GitHub Actions
env:
  PKR_VAR_docker_password: ${{ secrets.DOCKER_PASSWORD }}

# GitLab CI
variables:
  PKR_VAR_docker_password: $DOCKER_PASSWORD

.gitignore

# Ne jamais committer
*.pkrvars.hcl
!example.pkrvars.hcl

Packer peut-il créer plusieurs images en parallèle ?

Oui ! Packer exécute les builds de plusieurs sources en parallèle par défaut.

Multi-sources

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

source "amazon-ebs" "app" {
  region        = "eu-west-3"
  instance_type = "t3.micro"
  # ...
}

build {
  sources = [
    "source.docker.app",
    "source.amazon-ebs.app"
  ]

  provisioner "shell" {
    inline = ["echo 'Hello from ${source.type}'"]
  }
}

Contrôle du parallélisme

# Limiter à 2 builds simultanés
packer build -parallel-builds=2 .

# Un seul build à la fois
packer build -parallel-builds=1 .

Avantages

Gain de temps : Docker et AWS se buildent simultanément
Même configuration : provisioners partagés
Artefacts séparés : chaque builder produit son image

Quelle est la différence entre Packer et Terraform ?

Packer et Terraform sont deux outils HashiCorp complémentaires, pas concurrents.

Critère	Packer	Terraform
Rôle	Construire des images machine	Provisionner l'infrastructure
Produit	AMI, image Docker, QCOW2, VMDK	VM, réseau, stockage, DNS
Moment	Avant le déploiement (build)	Au déploiement (apply)
Langage	HCL2	HCL2

Workflow combiné

Packer crée une image durcie et pré-configurée (golden image).
Terraform déploie des instances à partir de cette image.

Cette séparation applique le principe d'immutable infrastructure : on ne modifie pas un serveur en place, on redéploie une nouvelle image versionnée.

Packer est-il gratuit ?

Quelle est la différence entre Packer et Vagrant ?

Les deux sont signés HashiCorp mais répondent à des besoins différents.

Aspect	Packer	Vagrant
Objectif	Construire des images machine	Orchestrer des VMs de dev
Cible	Production, cloud, multi-plateforme	Poste de développement local
Produit	AMI, image Docker, QCOW2, box	VM lancée depuis une box
Cycle de vie	Build ponctuel d'un artefact	`up`, `ssh`, `halt`, `destroy`

Comment ils s'articulent

Packer peut générer les box que Vagrant consomme, grâce à son post-processor vagrant :

post-processor "vagrant" {
  output = "ma-box.box"
}

En pratique : Packer standardise l'image de base une fois pour toutes, Vagrant l'instancie en local pour que chaque développeur travaille dans le même environnement.

Ressources complémentaires

Gardez ces adresses sous la main pendant la formation. La documentation officielle et la référence HCL2 répondent à la plupart des questions de syntaxe, la page des builders liste les plugins disponibles pour chaque plateforme, et la FAQ HashiCorp traite les cas de dépannage et les comparaisons avec d'autres outils.

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
FAQ HashiCorp : developer.hashicorp.com/packer/docs/faq
GitHub Packer : github.com/hashicorp/packer

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

Ce que vous apprendrez

Vue d'ensemble de la formation

Le programme, module par module

Découvrir Packer et réussir un premier build

Écrire un template HCL2 paramétrable

Configurer l'image et industrialiser la chaîne de build

Par où commencer ?

FAQ : questions fréquentes

Ce que Packer fait

Exemple rapide

Comparaison

Quand utiliser quoi ?

Exemple identique

Linux (recommandé : asdf)

macOS

Windows

Vérification

Blocs principaux

Exemple minimal

HCL2 vs JSON

Workflow de validation

Ce que valide Packer

En CI/CD

Exemple de sortie

Builders principaux

Installation des plugins

Multi-plateforme

Déclaration

Utilisation

Fournir des valeurs

Locals (valeurs calculées)

Provisioners principaux

Exemple

Ordre d'exécution

Logs détaillés

Mode interactif

Gestion des erreurs

Problèmes courants

Post-processors principaux

Exemple simple

Chaînage de post-processors

GitHub Actions

GitLab CI/CD

Bonnes pratiques CI/CD

Template minimal

Authentification

Arborescence

Makefile

Utilisation

Variables sensibles

Bonnes pratiques

En CI/CD

.gitignore

Multi-sources

Contrôle du parallélisme

Avantages

Workflow combiné

Licence

Comment ils s'articulent

Ressources complémentaires