J'ai pas mal travaillé sur la CI/CD de [Garage](https://garagehq.deuxfleurs.fr/), et force est de constater qu'on a rencontré un nombre incroyable de problèmes. Entre autre, on a noté que les builds Rust sans cache sont trop lents par rapport à nos attentes, qu'il n'y avait pas de solution légère pour gérer les artefacts binaires et enfin que construire un conteneur quand on a un CI/CD à base de Docker, ça n'était pas possible car on n'avait pas accès au daemon docker ni la possibilité de faire du “docker in docker” de manière à peu près sécurisée.
Si la question du cache et des artefacts binaires est passionnante, nous allons la garder pour un autre billet de blog, et nous focaliser sur **comment construire des conteneurs légers, multi-plateforme et les publier** dans ce billet. Si vous ne voyez pas ce que j'entends par registre statique, allez donc [jeter un coup d'oeil à mon précédent billet !](https://quentin.dufour.io/blog/2023-04-06/un-registre-statique-docker-avec-garage/)
- **léger** : c'est à dire qui embarque le strict minimum. Bien souvent, on peut se contenter d'un binaire statique.
- **multi-plateforme :** un seul tag d'image permettra à des gens sur ARM comme sur X86_64 d'utiliser votre logiciel
- **publier** : on publier les conteneurs sur un registre, ici nous verrons comment faire sur le docker hub mais aussi sur notre registre statique à base de Garage
_À noter qu'il y a un dernier point qui ne sera pas abordé dans ce billet qui sera sans aucun doute beaucoup trop long de toute manière, c'est comment gérer la garbage collection de nos artifacts._
Pour ce billet, on va prendre comme un exemple un programme en go que j'ai écrit, Albatros, ma propre CI/CD (ça devient déjà meta). L'avantage de prendre comme exemple un programme en Go, c'est que ça se cross compile facilement. Voilà un extrait du fichier `flake.nix` de notre projet :
_On peut consulter le fichier en entier_ [_sur la forge_](https://git.deuxfleurs.fr/quentin/albatros/src/commit/d9facbb79c4551d90359c46b9f5d485c1503253a/flake.nix) _d'Albatros_.
En fait on construit par rafinement successif. Le premier bloc consiste en une fonction qui permet de compiler un module Go à partir de la recette fournie par la bibliothèque standard NixOS. Je dis bien une fonction, car ce bloc prend en paramètre `arch` qui contient l'architecture cible de notre module. Ainsi, si on lui passe `arm64` on aura un binaire qui fonctionne sur les processeurs ARM 64 bits, si on passe `386`, on aura un binaire pour les vieux PC x86 32 bits, etc.
Dans les blocs suivants, on raffine donc ce premier module. On va d'abord avoir une fonction qui va extraire le binaire statique du module généré par Go, ensuite une fonction Docker qui va mettre ce binaire statique dans un conteneur.
Enfin, une fois notre logique définie, on va déclarer quelles architectures on choisit de supporter, là j'en ai choisi 4. On va donc faire une boucle (`mapAttrs`) pour générer le conteneur Docker qui va bien pour chaque architecture.
Dans le monde des conteneurs, une image multiarch est juste une indirection, un fichier qui contient une liste de manifest avec des tags pour leur OS et leur architecture. Il faut donc créer un fichier qui liste le manifest de chacune de nos 4 images.
_Problème : aujourd'hui il n'y a pas vraiment d'outils clé en main. Typiquement,_ [_une issue sur skopeo_](https://github.com/containers/skopeo/issues/1136) _traine depuis 3 ans maintenant (2020) sans qu'elle n'ait jamais été résolue. On va essayer de bidouiller un truc de notre côté._
_Il y a deux façons de représenter des images de conteneur sous forme de dossier avec skopeo : via le transport_ `_dir_`_et le transport_`_oci_`_. Le premier est un format interne non spécifié à skopeo. Le second est standardisé et a donc_ [_une spécification en bonne et due forme_](https://github.com/opencontainers/image-spec/blob/main/image-layout.md)_. Nous, on va préférer utiliser un standard pour éviter les mauvaises surprises à l'avenir (changement de format, abandon du support, interopérabilité, etc.)._
Maintenant il ne nous reste plus qu'à créer un manifeste depuis les informations qu'on a collecté ! Pour se faire, deux choix : soit on copie, soit on va voir la spec.
Pour copier, on peut aller zyeuter du côté d'une image officielle de Docker, comme celle de redis par exemple :
L'autre option, c'est d'aller voir la specification OCI sur [les index d'images](https://github.com/opencontainers/image-spec/blob/main/image-index.md).
À noter par contre que NixOS génère des manifests version 1 et non version 2, on peut s'en apercevoir en allant regarder l'index de nos images, exemple avec `/tmp/oci/amd64/index.json` :
En réalité, il nous faut simplement fusionner ces 4 fichiers d'index et les tagger avec la platform qui va bien ! Dans cet exemple, je vais le faire plus ou moins à la main avec `jq` :
Encore une fois, on ne veut toujours pas utiliser de daemon Docker. On va utiliser plutôt à la place [crane](https://github.com/google/go-containerregistry/tree/main/cmd/crane), un outil développé par Google. C'est pas plus compliqué que de lancer cette commande :
On a vu comment construire plusieurs images Docker simples avec NixOS, une pour chaque plateforme qu'on supporte. Ensuite on a vu comment les manipuler au format OCI pour les fusionner et créer une image multiarch. Enfin, on a vu comment l'envoyer sur le hub Docker avec crane et sur notre registre statique. Aucune de ces opérations n'a nécessité d'élévation de privilège, ni le daemon Docker, ni même Docker tout court.
Bien entendu, si j'ai semi-automatisé les opérations avec des scripts bash, il reste que cette opération reste encore quelque peu fastidieuse. Il ne devrait pas être trop compliqué de porter ces différents bouts de bash vers un binaire Go qui se chargerait alors de l'envoi de ces images.
Reste la question du périmètre de ce binaire : est-ce qu'il doit supporter le hub docker et mon registre statique ? est-ce qu'il doit être possible de supprimer une image ? est-ce qu'il doit supporter les binaires statiques aussi ? est-ce qu'il doit faire une garbage collection automatique, et si oui, selon quelles règles ? est-il bien judicieux de générer une archive docker depuis NixOS pour ensuite la convertir en OCI, puis manipuler cette image, avant de l'envoyer, ou alors mieux vaudrait réaliser le plus possible ces tâches au sein de NixOS ? Est-ce que NixOS ne devrait pas générer notre image multarch ?
