NTRODUCTION À PACKER DANS UN PROCESSUS D'INTÉGRATION CONTINUE

Introduction à Packer dans un processus d’intégration continue

Qu’est-ce que Packer ?

Packer est une solution opensource permettant de construire des images machine pour de multiples plateforme cloud. Il est utilisé dans une approche « d’infrastructure as code » afin de pouvoir maintenir facilement les logiciels déployés sur les serveurs. Nous allons voir dans cet article comment utiliser Packer de façon efficace dans un processus d’intégration et de déploiement continu (CI/CD).

Construction des images

Pour définir une image avec Packer, on a besoin d’un fichier clé/valeur au format hcl ou json. Ce fichier va décrire les variables, les constructeurs (builders) et les approvisionneurs (provisioners). Les constructeurs permettent de créer les images pour de nombreuses plateformes comme des hébergeurs ou des outils de virtualisation ; ici nous avons utilisé Amazon Web Services.

Les approvisionneurs permettent de configurer l’image et d’y installer les dépendances de l’application, des outils comme Shell, Ansible, Chef ou Puppet sont supportés.

Afin d’optimiser le temps de construction des images, nous avons choisi des les découper en deux parties : une première partie, l’image de base, contenant les dépendances de l’application qui n’ont pas besoin d’être installées à chaque fois et une seconde partie, l’image applicative, contenant l’application elle-même et qui doit être mise à jour à chaque nouvelle version du code et sera construite à partir de la première partie.

Exemple de template pour l’image de base et l’opérateur AWS :

json
{
  "variables": {
    "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
    "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}",
    "region":         "{{env `AWS_REGION`}}",
    "instance_type":  "t2.micro",
    "ami_name":       "base_example",
  },
  "builders": [
    {
      "type": "amazon-ebs",
      "region": "{{user `region`}}",
      "access_key": "{{user `aws_access_key`}}",
      "secret_key": "{{user `aws_secret_key`}}",
      "ami_name": "{{user `ami_name`}}-{{timestamp}}",
      "instance_type": "{{user `instance_type`}}",
      // Retrieve latest ubuntu image
      "source_ami_filter": {
        "filters": {
          "virtualization-type": "hvm",
          "name": "ubuntu/images/hvm-ssd/ubuntu-bionic-18.04-amd64-server-*",
          "root-device-type": "ebs"
        },
        "owners": ["099720109477"],
        "most_recent": true
      },
  	  "ssh_username": "ubuntu",
      "tags": {
        "Name": "{{user `ami_name`}}-{{timestamp}}"
      }
    }
  ],
  "provisioners": [
    {
      "type": "shell",
      "script": "dependencies_install.sh"
    }
  ]
}

Processus d’intégration continue

Pour intégrer la construction de nos images dans notre processus d’intégration continue, nous avons défini deux pipelines.

Le premier construit l’image de base chaque semaine afin d’intégrer les mises à jour régulièrement. Nous pouvons également déclencher ce pipeline manuellement en cas de besoin.

Le deuxième construit l’image applicative à partir de la dernière image de base et se déclenche à chaque modification du code source.

Code permettant de construire l’image machine de l’application :

bash
latest_base_ami=$(python3 get_latest_base_ami.py)
SOURCE_AMI=${latest_base_ami} packer build application_ami.json

L’application est ensuite déployée avec [Terraform](https://www.terraform.io/).

Construire nos images machine de cette façon nous permet d’obtenir un résultat fiable en un temps optimal, nous espérons que cette méthode saura vous inspirer !

Partage

Laisser un commentaire

Inscrivez-vous à la newsletter Syloé !

Recevez gratuitement les analyses de nos experts