Construire des images de conteneurs

Ce cours prend la suite de Docker : les fondamentaux. Vous savez écrire un Dockerfile propre, sans défaut de conception ; il s'agit maintenant de produire des images dignes de la production : légères, rapides à reconstruire, sans secret ni outil superflu, identiques d'une construction à l'autre, publiées pour plusieurs architectures, et accompagnées des preuves de leur origine.

L'approche

Chaque leçon part de l'image de l'application Signalements, construite dans le cours précédent, et en améliore une propriété mesurable : sa taille, son temps de construction, le nombre de vulnérabilités qu'elle embarque, sa reproductibilité, sa traçabilité. Les gains sont mesurés avant et après, avec les sorties réelles des commandes. Un petit outil en Go, signalements-export, sert d'exemple pour les images construites depuis scratch et pour la compilation croisée.

Le fil conducteur est la chaîne d'approvisionnement logicielle : une image est un artefact que d'autres vont exécuter en lui faisant confiance. Ce cours vous apprend à mériter cette confiance, et à la vérifier quand c'est vous qui consommez l'image d'un autre.

Ce qu'il faut installer

• Docker Engine 29 avec le greffon Buildx (installé avec Docker, voir la leçon 4 du cours précédent).
• Environ 5 Go d'espace disque pour les images et le cache de construction.
• Les autres outils (Trivy, Syft, Cosign, Hadolint) s'utilisent sous forme d'images de conteneurs ou de binaires autonomes, présentés au fil des leçons.

Plan du cours

1. Choisir son image de base 1 h 200 Pratiquer
   Debian, slim, Alpine, Ubuntu, UBI, distroless, Chainguard, scratch : comparer réellement les images de base sur la taille, la surface d'attaque, les vulnérabilités, la compatibilité et le rythme de mise à jour, puis choisir en connaissance de cause.
2. Les constructions multi-étapes 1 h 200 Pratiquer
   Construire avec une image complète, exécuter avec une image minimale : séparer les étapes, copier seulement le résultat, tester pendant la construction, et mesurer ce que l'on gagne en taille, en temps et en vulnérabilités.
3. Le cache de BuildKit en profondeur 1 h 10 300 Concevoir
   Comprendre comment BuildKit décide de réutiliser une étape, accélérer les installations avec les montages de cache, découpler les couches avec COPY --link, et partager le cache entre agents de CI qui partent de zéro.
4. Les secrets pendant la construction 55 min 200 Pratiquer
   Démontrer comment un jeton fuit par ARG, ENV ou COPY, jusque dans l'historique et l'attestation de provenance, puis utiliser correctement les montages de secrets et l'agent SSH de BuildKit, et vérifier qu'il ne reste rien.
5. Images minimales : distroless et scratch 1 h 05 300 Concevoir
   Construire un binaire Go statique dans une image scratch de 10 Mo, sans oublier certificats, fuseaux horaires et utilisateur, puis faire tourner l'API Python sur une image distroless sans shell ni gestionnaire de paquets, et la déboguer quand même.
6. Des constructions reproductibles 1 h 10 300 Concevoir
   Pourquoi deux constructions identiques donnent deux images différentes, comment traquer chaque source d'écart jusqu'au fichier près, et comment obtenir la même empreinte à chaque construction : SOURCE_DATE_EPOCH, épinglage, verrouillage par empreintes, instantanés Debian.
7. Images multi-architectures 55 min 200 Pratiquer
   Publier une même image pour amd64, arm64 et d'autres processeurs : comprendre l'index OCI, éviter le piège de l'émulation, compiler en croisé en Go, et même construire une application Python pour ARM sans exécuter une seule instruction ARM.
8. SBOM et attestations de provenance 1 h 05 300 Concevoir
   Dire précisément ce que contient une image (SBOM) et comment elle a été construite (provenance) : les produire avec BuildKit et Syft, lire une attestation in-toto, s'en servir pour répondre à une alerte, et connaître les limites d'interopérabilité des outils.
9. Signer et vérifier ses images 1 h 05 300 Concevoir
   Pourquoi l'empreinte ne suffit pas, signer une image et ses attestations avec Cosign, vérifier, constater les échecs qui protègent, comprendre la signature sans clé de Sigstore, et faire respecter la vérification au déploiement.
10. Construire en intégration continue 1 h 10 300 Concevoir
    Assembler toute la chaîne du cours dans un workflow GitHub Actions : tests, construction reproductible, cache partagé, SBOM et provenance, analyse bloquante, signature sans clé et publication sur le registre Scaleway, avec des droits minimaux.