Contruction d'images de VM avec Packer
Bienvenue dans ce guide complet sur Packer, un outil open source développé par HashiCorp pour automatiser la création d'images machine de manière cohérente et reproductible. Que vous soyez un administrateur système cherchant à simplifier le déploiement de vos environnements ou un développeur souhaitant garantir la constance de vos configurations, Packer est l'outil qu'il vous faut.
Dans ce guide, je vais vous guider à travers les concepts clés, les fonctionnalités essentielles et les meilleures pratiques pour utiliser Packer efficacement. Vous apprendrez à installer Packer, créer des templates, utiliser des builders pour différentes plateformes et automatiser la configuration de vos images avec des provisioners et des post-processors.
Les fonctionnalités de Packer
Packer a été conçu pour automatiser le processus de création d'images de machines virtuelles pour de multiples plateformes et cela, en parallèle pour optimiser les temps de construction.
Packer prend en charge actuellement pas moins de 42 plateformes dont 10 officiels : AWS, Azure, GCP, QEMU, Parallels, VMware, Vagrant, VirtualBox, Outscale, ...
Mais Packer ne se limite pas à la création d'images de VM, il peut aussi être utilisé pour produire des images de conteneurs.
Utilisation avec d'autres outils HashiCorp
Vagrant
Si vous travaillez en environnement de développement, Packer et Vagrant sont des partenaires idéaux. Packer peut créer des boxes qui sont ensuite utilisées par Vagrant pour créer des environnements de développement locaux. Cela permet aux développeurs de travailler avec des environnements identiques à ceux qui seront déployés en production avec Terraform.
Terraform
Packer et Terraform forment une combinaison puissante. Vous pouvez utiliser Packer pour créer des images VM, puis utiliser Terraform pour déployer ces images sur l'infrastructure de votre choix. Cela garantit une gestion cohérente et automatisée de votre infrastructure, de la création des images jusqu'à leur déploiement.
Installation de Packer
Avant de plonger dans l'installation de Packer, il est essentiel de connaître les systèmes d'exploitation sur lesquels Packer peut être exécuté. Heureusement, Packer est un outil polyvalent qui prend en charge plusieurs systèmes d'exploitation hôtes, notamment Windows, macOS et diverses distributions Linux. Cela signifie que vous pouvez l'utiliser sur la plate-forme de votre choix, ce qui le rend accessible à un large éventail d'utilisateurs.
Si vous prévoyez de créer des images VM, assurez-vous d'avoir accès aux hyperviseurs cibles. Par exemple, QEMU, VirtualBox ou VMware Workstation pour des machines locales, ou les services cloud correspondants (Outscale, AWS, Azure, etc.) pour le cloud.
Installation de Packer sous Linux
Si vous utilisez une distribution Linux, vous pouvez généralement installer Packer à l'aide d'asdf.
Ouvrez votre terminal et exécutez les commandes suivantes :
asdf plugin add packer https://github.com/asdf-community/asdf-hashicorp.git
asdf install packer latest
asdf global packer latest
Installation de Packer sous macOS
Pour installer Packer sur macOS, vous pouvez utiliser Homebrew (recommandée) ou télécharger le binaire depuis le site officiel de HashiCorp.
Copy code
brew install packer
Installation de Packer sous Windows :**
Pour installer Packer sur Windows, vous pouvez télécharger l'exécutable depuis le site officiel de HashiCorp et le configurer.
- Rendez-vous sur la page des téléchargements de Packer
- Sélectionnez la version souhaitée pour Windows, puis téléchargez le fichier binaire (par exemple, "packer_VERSION_windows_amd64.zip").
- Décompressez le contenu du fichier zip téléchargé vers un répertoire de votre choix.
- Ajoutez le chemin d'accès au répertoire où se trouve le binaire Packer à la variable d'environnement PATH de Windows. Pour ce faire, recherchez "Variables d'environnement" dans les paramètres système, puis éditez la variable "PATH" en ajoutant le chemin du répertoire Packer.
Vérification de l'installation de Packer
Ouvrez une nouvelle fenêtre de commande et vérifiez l'installation en exécutant la commande :
packer --version
1.9.4
Concepts de base
Pour bien utiliser Packer, il est essentiel de comprendre ses concepts fondamentaux. Ces concepts forment la base sur laquelle reposent tous les workflows de création d'images. Dans ce chapitre, je vais vous expliquer les éléments clés de Packer : les builders, les provisioners, les post-processors, ainsi que les notions de variables, de fonctions, de blocs et d'expressions.
Builders
Les builders sont responsables de la création des images pour différentes
plateformes. Chaque builder a des configurations spécifiques adaptées à la
plateforme cible. Par exemple, le builder outscale-bsu pour Outscale.
Provisioners
Les provisioners configurent les images après leur création. Ils exécutent des scripts ou des commandes sur les images pour installer des logiciels, appliquer des configurations, etc. Packer supporte plusieurs types de provisioners, y compris shell, ansible, chef et puppet.
Post-processors
Les post-processors effectuent des actions sur les images une fois qu'elles sont créées. Ils peuvent être utilisés pour compresser des fichiers, télécharger des images vers un stockage cloud, ou déclencher des scripts externes. Les post-processors ajoutent une couche supplémentaire de flexibilité et de personnalisation au processus de création d'images.
Variables
Les variables permettent de rendre les templates dynamiques et réutilisables. Elles sont définies dans le bloc variable et peuvent être utilisées dans les configurations de builders, provisioners et post-processors.
Expressions
Les expressions dans HCL permettent de manipuler et de combiner des valeurs de manière dynamique. Elles peuvent être utilisées pour calculer des valeurs, formater des chaînes de caractères et plus encore.
Fonctions
Packer offre plusieurs fonctions intégrées pour manipuler les données. Voici quelques fonctions couramment utilisées :
timestamp(): Génère un horodatage pour nommer les ressources de manière unique.format(): Permet de créer des chaînes de caractères formatées.file(): Lit le contenu d'un fichier.env(): Récupère la valeur d'une variable d'environnement.vault(): Obtient des secrets stockés dans HashiCorp Vault.path(): Manipule des chemins de fichiers ou de répertoires.
Structure d'un projet Packer
Organiser un projet Packer de manière efficace est essentiel pour garantir la maintenabilité, la réutilisabilité et la clarté de vos configurations. Dans ce chapitre, je vais vous guider à travers la structure recommandée pour un projet Packer, en détaillant les répertoires et fichiers clés, ainsi que quelques bonnes pratiques pour organiser votre code.
mon_projet_packer/
│
├── template.pkr.hcl
├── variables.pkrvars.hcl
├── scripts/
│ └── setup.sh
├── modules/
│ └── mon-module/
│ ├── main.pkr.hcl
│ └── variables.pkr.hcl
├── playbooks/
│ └── postgresql.yml
└── README.md
- template.pkr.hcl : Template principal.
- variables.pkrvars.hcl : Fichier de variables.
- scripts/setup.sh : Script de provisioning.
- playbooks/postgresql.yml : Playbook de provisioning.
- README.md : Documentation du projet.
Les fichiers de configurations Packer
Les templates sont au cœur de Packer. Ils définissent comment les images machine doivent être créées, configurées et post-traitées. Dans ce chapitre, je vais vous montrer comment créer un template de base en utilisant le langage HCL (HashiCorp Configuration Language).
Un template Packer en HCL est composé de plusieurs blocs qui définissent les différentes étapes de la création d'une image. Les principaux blocs que nous allons utiliser sont :
- packer : Définit les configurations globales pour Packer.
- variable : Déclare des variables.
- source : Définit les sources d'images pour différentes plateformes.
- build : Regroupe les sources et les provisioners pour créer une image.
- provisioner : Configure l'image après sa création.
- post-processor : Effectue des actions après la création de l'image.
packer {
...
}
variable "var_name" {
...
}
source "type" "name" {
...
}
build {
...
}
Le block packer
Le bloc packer est l'un des blocs fondamentaux dans un template Packer. Il définit les configurations globales et les métadonnées qui s'appliquent à l'ensemble du processus de création d'image. Dans ce chapitre, je vais expliquer en détail le bloc packer, ses attributs et son utilisation.
Le bloc packer est généralement placé au début de votre fichier de configuration HCL. Voici un exemple de base :
packer {
required_version = ">= 1.7.0"
description = "Template for creating an Outscale AMI"
required_plugins = {
outscale = {
version = ">= 1.0.0"
source = "github.com/outscale/outscale"
}
}
}
Le bloc packer peut contenir plusieurs attributs pour configurer des aspects globaux de votre projet. Voici les attributs les plus courants :
- L'attribut required_version spécifie la version minimale de Packer nécessaire pour exécuter le template. Cela permet de s'assurer que toutes les fonctionnalités utilisées dans le template sont disponibles dans la version de Packer installée.
- L'attribut description fournit une description textuelle du template. Cela peut être utile pour documenter l'objectif du template et toute information pertinente sur sa configuration.
- L'attribut required_plugins permet de spécifier les plugins nécessaires pour exécuter le template. Cela inclut le nom du plugin, la version requise et la source du plugin.
Le bloc source
Le bloc source dans un template Packer est crucial car il définit les détails spécifiques de la plateforme pour la création des images. Ce bloc contient les configurations nécessaires pour générer des images sur une cible précise, comme AWS, Outscale, Azure, Google Cloud, etc. Dans ce chapitre, je vais vous expliquer en détail le bloc source, ses attributs et fournir des exemples concrets pour l'utiliser efficacement avec Outscale.
Le bloc source est utilisé pour spécifier comment et où une image machine sera créée. Il contient tous les paramètres spécifiques à la plateforme nécessaire pour générer l'image. Voici un exemple de base pour Outscale :
source "outscale-bsu" "ubuntu_2204" {
region = var.region
vm_type = "tinav5.c2r4p2"
ssh_username = "outscale"
communicator = "ssh"
ssh_interface = "public_ip"
ssh_keypair_name = var.keypair_name
source_omi = var.omi_source
omi_name = "ubuntu_2204_steph"
ssh_private_key_file = "~/.ssh/id_ed25519"
launch_block_device_mappings {
delete_on_vm_deletion = true
device_name = "/dev/sda1"
volume_size = "40"
volume_type = "gp2"
}
}
Les principaux attributs :
- access_key et secret_key : Clés d'accès et clés secrètes pour Outscale.
- region : Région Outscale où l'image sera créée.
- source_ : AMI de base utilisée pour créer la nouvelle image.
- vm_type : Type d'instance pour la création de l'image.
- communicator : SSH ou WinRM
- ssh_username : Nom d'utilisateur pour la connexion SSH.
- omi_name : Nom unique pour l'image créée.
Le bloc build
Le bloc build dans un template Packer est importa t car il regroupe les configurations des sources et définit les provisioners et post-processors à appliquer pour la création d'images. Ce bloc orchestre l'ensemble du processus de création d'une image en combinant les différentes étapes nécessaires. Dans ce chapitre, je vais vous expliquer en détail le bloc build, ses attributs, et fournir des exemples concrets pour l'utiliser efficacement.
Le bloc build est utilisé pour orchestrer les différentes étapes de création d'une image. Il inclut les sources définies précédemment, ainsi que les provisioners et post-processors.
Le bloc build comprend plusieurs attributs essentiels :
- L'attribut sources spécifie les sources à utiliser pour cette build. Les sources sont référencées par leurs noms tels que définis dans les blocs source.
- Les provisioners configurent les images après leur création initiale. Ils
exécutent des scripts ou des commandes sur les images pour installer des
logiciels, appliquer des configurations, etc. Les provisioners les plus courants incluent :
- shell : Exécute des commandes shell sur l'image.
- ansible : Utilise Ansible pour configurer l'image.
- chef : Utilise Chef pour la gestion de la configuration.
- puppet : Applique des manifestes Puppet.
- Les post-processors effectuent des actions sur les images une fois qu'elles ont été créées. Ils peuvent être utilisés pour compresser des fichiers, télécharger des images vers un stockage cloud, ou déclencher des scripts externes.
Voici un exemple de base pour Outscale :
build {
name = "ubuntu_2004-steph"
sources = ["source.outscale-bsu.ubuntu_2004"]
provisioner "shell" {
inline = [
"cloud-init status --wait",
]
}
post-processor "compress" {
output = "output/${build_name}.zip"
}
}
Création d'une image VM avec Packer
Une fois le fichier de configuration créé, il ne reste plus qu'à lancer le processus de build. Ouvrez une fenêtre de terminal et placez-vous dans le répertoire où se trouve votre fichier de configuration Packer. Ensuite, exécutez la commande suivante pour lancer le processus de création de l'image VM :
packer build nom_du_fichier_de_configuration
Par exemple, si votre fichier de configuration se nomme
ma_configuration.pkr.hcl, la commande serait :
packer build ma_configuration.pkr.hcl
Packer commencera à créer l'image VM en fonction des spécifications que vous avez définies dans le fichier de configuration. Pendant ce processus, Packer peut communiquer avec l'hyperviseur ou le fournisseur de cloud cible pour créer la machine virtuelle, y installer un système d'exploitation de base, puis appliquer les scripts de provisionnement pour personnaliser l'image.
Packer affiche en temps réel les étapes du processus de création. Vous pourrez suivre les actions effectuées par Packer, y compris les scripts de provisionnement qui sont en cours d'exécution.
Une fois que Packer a terminé avec succès la création de l'image VM, il générera un fichier de sortie contenant l'ID de l'image ou d'autres informations pertinentes. Cette image est désormais prête à être utilisée dans votre environnement de déploiement.
Intégration dans un pipeline CI/CD
Packer peut être intégré dans un pipeline d'intégration continue pour automatiser la création d'images VM à chaque mise à jour d'une dépendance.
Pour la partie test des images, on peut imaginer détourner l'utilisation de Molecule (je le fais).
Bonnes pratiques et astuces
Lorsque vous travaillez avec Packer, il est essentiel de suivre certaines bonnes pratiques pour garantir l'efficacité, la sécurité et la reproductibilité de votre processus de création d'images VM. En voici quelques-unes :
1. Versionnez votre configuration : Utilisez un système de contrôle de version tel que Git pour gérer vos fichiers de configuration Packer. Cela vous permet de suivre les modifications au fil du temps, de collaborer avec d'autres membres de l'équipe et de revenir à des versions antérieures en cas de besoin.
2. Utilisez des variables : Profitez de la capacité de Packer à utiliser des variables pour rendre votre configuration plus dynamique. Les variables vous permettent de personnaliser les images pour différents environnements ou configurations.
3. Automatisez les mises à jour : Assurez-vous de maintenir régulièrement vos fichiers de configuration Packer pour inclure les dernières mises à jour de sécurité et de logiciels. L'automatisation de ce processus peut vous faire gagner du temps et garantir que vos images sont à jour.
4. Sécurisez vos variables sensibles : Si vous stockez des informations
sensibles dans vos fichiers de configuration, utilisez des solutions telles que
ansible-vault
pour protéger ces informations.
6. Utilisez des outils de gestion de configuration : Utiliser des outils de gestion de configuration tels que Ansible, Chef ou Puppet pour garantir que vos images sont conformes aux normes de sécurité et de configuration.
7. Testez vos scripts de provisionnement : Avant de les déployer en production, testez soigneusement vos scripts de provisionnement pour vous assurer qu'ils fonctionnent comme prévu. Utilisez des environnements de test pour valider vos images.
8. Surveillez et optimisez la taille de vos images : Les images VM peuvent devenir volumineuses. Surveillez leur taille et optimisez-les si nécessaire en supprimant les fichiers inutiles ou en utilisant des techniques de compression.
9. Documentez votre processus : Tenez des notes détaillées sur votre processus de création d'images avec Packer. La documentation peut être précieuse pour comprendre les configurations spécifiques et pour former des membres de l'équipe.
10. Soyez conscient des coûts : Lorsque vous créez des images pour le cloud, tenez compte des coûts associés au stockage et à la bande passante. Supprimez les anciennes images inutilisées pour réduire les coûts.
Des exemples concrets
Je vous propose trois de mes guides où j'ai exposé comment j'utilisais Packer :
Ces fichiers sont écrits en JSON, mais pour information Packer possède une option permettant de convertir les fichiers json en hcl.
packer hcl2_upgrade -with-annotations
- Construire des OMI Outscale avec Packer au format HCL
Conclusion
Vous l'aurez compris Packer offre un moyen puissant et reproductible de créer des images VM pour une variété de plates-formes, qu'il s'agisse de machines locales, de fournisseurs de cloud ou d'environnements d'entreprise. Sa polyvalence et son intégration avec d'autres outils d'HashiCorp tels que Terraform et Vagrant en font un atout précieux pour automatiser et simplifier la gestion de l'infrastructure. L'intégration des outils de gestion de configuration tels qu'Ansible, Chef ou Puppet, apporte des moyens de rendre conforme les images produites.
En utilisant Packer, vous pouvez garantir la cohérence de vos images VM, automatiser les mises à jour du système d'exploitation, créer des environnements de développement cohérents et bien plus encore.
En conclusion, l'utilisation de Packer peut améliorer considérablement renforcer la sécurité de votre infrastructure et faciliter la gestion de vos environnements de développement et de production. Packer est un outil essentiel pour tout professionnel cherchant à automatiser la création d'images VM de manière fiable et reproductible.
Plus d'infos
- Site officiel : HashiCorp Packer
- Documentation