Images Packer

Introduction à Packer

Packer est un outil open source permettant de créer des images machine identiques pour plusieurs plateformes à partir d’une seule configuration source. Packer est léger, fonctionne sur tous les principaux systèmes d’exploitation et est très performant, créant des images machine pour plusieurs plates-formes en parallèle. Packer ne remplace pas la gestion de configuration comme Chef ou Puppet. En fait, lors de la création d’images, Packer est capable d’utiliser des outils comme Chef ou Puppet pour installer un logiciel sur l’image.

Terminologie Packer

Il y a une série de termes utilisés dans la documentation de Packer dont la signification n’est pas immédiatement évidente si vous n’avez pas utilisé Packer auparavant. Heureusement, il y en a relativement peu. Cette page documente toute la terminologie nécessaire pour comprendre et utiliser Packer. La terminologie est en ordre alphabétique pour une référence rapide.

Les artefacts sont le résultat d’une seule compilation, et sont généralement un ensemble d’identifiants ou de fichiers pour représenter une image machine. Chaque builder produit un artefact unique. Par exemple, dans le cas du constructeur Amazon EC2, l’artefact est un ensemble d’ID AMI (un par région). Pour le constructeur VMware, l’artefact est un répertoire de fichiers comprenant la machine virtuelle créée.

Les builds sont une tâche unique qui finit par produire une image pour une seule plate-forme. Plusieurs builds s’exécutent en parallèle. Exemple d’utilisation dans une phrase : “Le build Packer a produit un AMI pour faire tourner notre application web.” Ou encore : “Packer exécute les builds maintenant pour VMware, AWS, et VirtualBox.”

Les builders sont des composants de Packer capables de créer une image de machine pour une seule plateforme. Les builders lisent une certaine configuration et l’utilisent pour exécuter et générer une image de machine. Un builder est invoqué dans le cadre d’un build afin de créer les images résultantes. Les exemples de builders incluent VirtualBox, VMware et Amazon EC2. Les builders peuvent être créés et ajoutés à Packer sous la forme de plugins.

Les commands sont des sous-commandes pour le programme Packer qui effectuent un certain travail. Un exemple de commande est “build”, qui est invoqué comme build du packer. Packer est livré avec un ensemble de commandes incluses afin de définir son interface de ligne de commande.

Les post-procesors sont des composants de Packer qui prennent le résultat d’un builder ou d’un autre post-processeur et le traitent pour créer un nouvel artefact. Des exemples de post-processeurs sont “compress” pour compresser les artefacts, “upload” pour uploader les artefacts, etc.

Les provisionners sont des composants de Packer qui installent et configurent des logiciels dans une machine en cours d’exécution avant que cette machine ne soit transformée en une image statique. Ils effectuent le travail principal qui consiste à faire en sorte que l’image contienne des logiciels utiles. Les exemples de provisionneurs incluent les scripts shell, Chef, Puppet, etc.

Les modèles templates sont des fichiers JSON qui définissent un ou plusieurs builds en configurant les différents composants de Packer. Packer est capable de lire un modèle et d’utiliser cette information pour créer plusieurs images de machine en parallèle.

Pourquoi Packer ?

Fabriquer une image AMI pour une instance EC2

  • Fabriquer une image AMI avec Packer
  • Fabriquer une image AMI avec Packer en intégration continue

comme :

Installation de packer

sudo yum -y install wget unzip || sudo apt update && sudo apt -y install wget unzip
latest=$(curl -L -s https://releases.hashicorp.com/packer | grep 'packer_' | sed 's/^.*<.*\">packer_\(.*\)<\/a>/\1/' | head -1)\n
wget https://releases.hashicorp.com/packer/${latest}/packer_${latest}_linux_amd64.zip
unzip packer*.zip
chmod +x packer
sudo mv packer /usr/local/bin/
echo Latest Packer version is $latest at $(date)
Latest Packer version is 1.5.1 at Ven 27 déc 2019 21:02:23 CET

Builders

Un fichier déclaratif en format JSON : ami.json.

{
  "variables": {
    "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
    "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
  },
  "builders": [
    {
      "type": "amazon-ebs",
      "access_key": "{{user `aws_access_key`}}",
      "secret_key": "{{user `aws_secret_key`}}",
      "region": "eu-west-3",
      "source_ami": "ami-0c4224e392ec4e440",
      "instance_type": "t2.micro",
      "ssh_username": "{{env `USER`}}",
      "ami_name": "packer_AWS {{timestamp}}"
    }
  ]
}

Création de l’AMI.

packer build ami-ubuntu.json
...
==> Builds finished. The artifacts of successful builds are:
--> amazon-ebs: AMIs were created:
eu-west-3: ami-077dc62244c80aac7

Provisioners

Approvisionnement : des logiciels intégrés et tiers installent et configurent l’image après son démarrage sur la VM de construction.

  "provisioners": [
    {
      "type": "shell",
      "execute_command": "{{ .Vars }} sudo -E bash '{{ .Path }}'",
      "inline": [
        "sudo apt-get update",
        "sudo apt-get -y install software-properties-common",
        "sudo apt-add-repository --yes --update ppa:ansible/ansible",
        "sudo apt update",
        "sudo apt -y install ansible"
      ]
    },
    {
      "type": "ansible-local",
      "playbook_file": "ansible/playbook.yml",
      "playbook_dir": "ansible"
    },
    {
      "type": "shell",
      "execute_command": "{{ .Vars }} sudo -E bash '{{ .Path }}'",
      "inline": [
        "sudo apt -y remove ansible",
        "sudo apt-get clean",
        "sudo apt-get -y autoremove --purge"
      ]
    }
  ]

Post-processor

Post-traitement :

Packer et Ansible pour fabriquer des images KVM

Create VM templates with Packer for usage with Libvirt/KVM virtualization : centos 7, ubuntu 1804, debian 9.

Introduction

Ceci est un “Proof of Concept” de

  • qemu/kvm comme “image builder”
  • shell and ansible-local comme “provisionners”
  • shell-local comme “post-processor” pour générer un fichier d’appliance gns3a, calcul du checksum et le placement sur un serveur distant.

De manière optionnelle, j’ai placé l’application dans un conteneur Docker.

Construction (build)

Prérequis :

  • libvirt/KVM
  • Packer (dans /opt/packer)

Par exemple :

packer build centos7.json
packer build ubuntu1804.json

Construction avec une image Docker Qemu

goffinet/packer-qemu est une image Docker avec Qemu pour fabriquer les images avec Docker.

docker run --rm                                      \
  -e PACKER_LOG=1                                    \
  -e PACKER_LOG_PATH="centos-packer-docker.log" \
  -it                                                \
  --privileged                                       \
  --cap-add=ALL -v /lib/modules:/lib/modules         \
  -v `pwd`:/opt/                                     \
  -v $HOME/.ssh/id_rsa:/root/.ssh/id_rsa             \
  -v $HOME/.ssh/id_rsa.pub:/root/.ssh/id_rsa.pub     \
  -w /opt/ goffinet/packer-qemu build centos7.json

Pour construire localement cette image Docker avec le fichier Dockerfile :

docker build -t packer-qemu .

Le script build.sh lance la construction avec le nom du modèle comme premier argument.

./build.sh centos7.json