TP : Conteneurisation de votre application Node.js et intégration dans GitLab CI¶
Ce TP a pour objectif de vous faire pratiquer la création d'images Docker pour une application Node.js et l'automatisation de sa construction dans GitLab CI
Objectifs du TP¶
- Rédiger un Dockerfile pour une application Node.js
- Optimiser une image Docker avec le multi-stage build
- Construire une image dans GitLab CI avec BuildKit en mode rootless, sans démon Docker
- Accélérer les builds avec un cache distant stocké dans le registre
- Automatiser la création et la publication de l'image dans le pipeline CI
Étape 1 : Création du Dockerfile basique¶
Nous allons créer une image Docker pour l'application Node.js développée au TP précédent
- À la racine de votre projet, créez un fichier nommé
Dockerfile - Utilisez l'image de base
node:24-alpine(plus légère que l'image node standard) - Définissez le répertoire de travail dans le conteneur avec
WORKDIR(par exemple/usr/src/app) - Copiez les fichiers
package.jsonetpackage-lock.jsonouyarn.lock - Exécutez la commande d'installation des dépendances avec
RUN npm ci - Copiez le reste de votre code source dans le conteneur
- Exposez le port 3000 utilisé par votre application avec
EXPOSE - Définissez la commande de démarrage de votre application avec
CMD - N'oubliez pas d'ajouter un fichier
.dockerignorecontenantnode_moduleset.gitpour ne pas alourdir le contexte de build
Étape 2 : Test de l'image localement (Optionnel)¶
Si vous disposez de Docker sur votre machine, vous pouvez vérifier que l'image se construit correctement avant de l'envoyer sur GitLab
- Construisez votre image en lui donnant un nom avec la commande
docker build -t mon-app-node . - Lancez un conteneur à partir de cette image avec
docker run -p 3000:3000 mon-app-node - Vérifiez dans votre navigateur que l'application répond sur
http://localhost:3000
Étape 3 : Optimisation avec le Multi-stage Build¶
Pour avoir une image de production la plus légère possible, nous allons séparer l'étape de build de l'étape d'exécution
- Modifiez votre
Dockerfilepour introduire une première étape nomméebuilder(ex:FROM node:24-alpine AS builder) - Dans cette étape
builder, installez toutes les dépendances et générez les fichiers nécessaires au bon fonctionnement de votre application - Créez une seconde étape en utilisant à nouveau
node:24-alpine - Définissez la variable d'environnement
NODE_ENVàproduction - Utilisez l'instruction
COPY --from=builderpour ne récupérer que le code compilé et les dossiers nécessaires depuis l'étape précédente - Pour des raisons de sécurité (principe du moindre privilège), configurez le conteneur pour s'exécuter en tant qu'utilisateur non-privilégié en ajoutant la directive
USER nodejuste avant l'instructionCMD(l'utilisateurnodeest déjà présent dans les images officiellesnode, y compris les variantes Alpine) - Observez la réduction de taille de l'image finale si vous la buildez localement
Étape 4 : Automatisation de la construction de l'image sur GitLab CI¶
Maintenant que le Dockerfile est prêt, nous allons demander à GitLab CI de construire notre image Docker à chaque modification du code
Nous utiliserons BuildKit, le moteur de build de Docker, en mode rootless : aucun démon Docker à lancer, et un build qui s'exécute en utilisateur non-root
- Dans votre fichier
.gitlab-ci.yml, ajoutez une étapebuild_imageà vos stages existants - Créez un job
build:imagerattaché à cette nouvelle étape - Utilisez l'image
moby/buildkit:v0.34.0-rootlessavec l'entrypoint vide[""] - Définissez la variable
BUILDKITD_FLAGSà--oci-worker-no-process-sandbox -
Dans le
before_script, créez le fichier d'authentification~/.docker/config.jsonà partir des variables prédéfinies du registre GitLab : -
Dans le
script, lancez le build et le push sans démon avecbuildctl-daemonless.sh: -
Commitez vos changements et vérifiez dans l'interface GitLab que le pipeline réussit et que l'image est bien présente dans Deploy > Container Registry
Rootless ne veut pas dire sans aucun droit
BuildKit rootless crée un user namespace, ce que le profil seccomp par défaut de Docker interdit. Les runners hébergés de GitLab.com autorisent le mode privilégié (c'est ce qui permet d'y faire du Docker-in-Docker) : le job fonctionne tel quel. Sur un runner auto-hébergé non privilégié, le conteneur de build doit tourner avec seccomp et AppArmor en unconfined, sinon le job échoue avec rootlesskit ... operation not permitted
Et Kaniko ?
Kaniko (GoogleContainerTools), longtemps l'outil de référence pour builder sans démon, est archivé depuis juin 2025. Un fork communautaire maintenu existe : vous pourrez le comparer à BuildKit dans le bonus de l'étape 8
Pour aller plus loin
Plutôt qu'un BuildKit lancé à chaque job, un service BuildKit peut tourner en permanence dans Kubernetes et être appelé par les jobs via Buildx : voir l'article optimiser les builds Docker sur Kubernetes avec BuildKit
Étape 5 : Validation de la qualité et de la sécurité (Linting)¶
Pour garantir la qualité et la sécurité de notre Dockerfile dans un cadre industriel, nous allons ajouter une étape de validation automatique dans notre pipeline CI. Trois approches courantes sont possibles (vous pouvez choisir l'une d'entre elles) :
Option A : Hadolint (Linter historique et spécialisé)¶
- Dans votre
.gitlab-ci.yml, ajoutez une étapelintau tout début de vos stages existants - Créez un job nommé
lint_hadolintrattaché à cette étape - Utilisez l'image officielle
hadolint/hadolint:v2.15.1-alpine - Dans la section
script, lancez la commandehadolint Dockerfile
Option B : Trivy (Scanner de vulnérabilités et de conformité)¶
Trivy permet de scanner le Dockerfile pour y détecter des failles de sécurité ou des non-conformités
- Créez un job nommé
lint_trivyrattaché à l'étapelint - Utilisez l'image
aquasec/trivy:0.76.0avec l'entrypoint vide[""](l'image définittrivycomme entrypoint) - Dans la section
script, lancez la commandetrivy config Dockerfile(outrivy config .pour scanner tout le projet)
Épinglez la version de Trivy
En mars 2026, l'écosystème Trivy a subi une attaque supply chain : des images vérolées ont été publiées sous les tags 0.69.4, 0.69.5, 0.69.6 et latest (détails sur le blog Docker). N'utilisez jamais latest pour un outil de sécurité : épinglez une version vérifiée, idéalement par digest (aquasec/trivy:<version>@sha256:<digest>)
Option C : Docker build --check (Validation native)¶
Docker permet de vérifier la syntaxe et le respect des bonnes pratiques directement via la CLI sans construire l'image
- Créez un job nommé
lint_docker_checkrattaché à l'étapelint - Utilisez l'image
docker:29avec le servicedocker:29-dind - Définissez les variables
DOCKER_HOSTàtcp://docker:2375etDOCKER_TLS_CERTDIRà""(TLS désactivé, comme dans les slides) - Dans la section
script, lancez la commandedocker build --check .
Exercice : Choisissez et configurez l'une des méthodes ci-dessus, puis poussez vos modifications et vérifiez le résultat dans GitLab CI. Si des alertes sont remontées, corrigez votre Dockerfile en conséquence
Étape 6 : Cache distant BuildKit et stratégie de Tagging¶
Dans un contexte professionnel, il est crucial de réduire le temps d'exécution des pipelines et d'adopter un nommage clair et structuré de nos images Docker. Les runners étant éphémères, chaque job repart sans aucune couche en cache : on stocke donc le cache dans le registre
-
Ajoutez à votre commande
buildctll'export et l'import du cache dans le registre GitLab : -
Lancez le pipeline deux fois de suite sans modifier le Dockerfile : au second passage, les étapes apparaissent en
CACHEDdans les logs et le job est plus rapide. Au tout premier build, une erreur sur l'import du cache est normale et ne fait pas échouer le job : le cache n'existe pas encore -
Poussez deux tags à chaque build : l'image avec le SHA court du commit (
$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA) et une image avec le nom de la branche ($CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG). Avecbuildctl, les noms se séparent par une virgule dansname=, entre guillemets échappés : -
Optionnel : Ajoutez une règle de pipeline (
rules) pour que l'image soit tagguée avec la version de la release ($CI_REGISTRY_IMAGE:$CI_COMMIT_TAG) uniquement lorsqu'un tag Git (ex:v1.0.0) est créé
Le même cache avec Docker Buildx
--export-cache et --import-cache sont les options de buildctl. Avec docker buildx build, le même mécanisme s'écrit --cache-to type=registry,ref=...,mode=max et --cache-from type=registry,ref=...
Étape 7 : Publication sur un registre externe privé (Docker Hub)¶
Dans de nombreux projets industriels, les images ne sont pas stockées sur le registre GitLab intégré, mais sur un registre externe d'entreprise (Docker Hub, Harbor, AWS ECR, etc.). Nous allons configurer notre pipeline pour pousser sur Docker Hub
- Créez un compte gratuit sur Docker Hub si vous n'en avez pas déjà un
- Générez un jeton d'accès personnel (Personal Access Token - PAT) dans les paramètres de votre compte Docker Hub (Account settings > Personal access tokens)
- Dans GitLab, allez dans Settings > CI/CD > Variables et ajoutez deux variables masquées :
DOCKER_HUB_USER: Votre nom d'utilisateur Docker HubDOCKER_HUB_TOKEN: Le jeton d'accès généré (ne jamais utiliser votre mot de passe en clair dans la CI)
- Ajoutez une seconde entrée dans le fichier
~/.docker/config.jsonde votre job BuildKit pour Docker Hub (l'URL du registre par défaut esthttps://index.docker.io/v1/) : un même fichier peut contenir plusieurs registres dansauths, ce qui permet de garder le cache sur le registre GitLab - Modifiez le nom de l'image dans
--outputpour cibler votre dépôt Docker Hub :docker.io/<votre_utilisateur_dockerhub>/<nom_du_depot>:$CI_COMMIT_SHORT_SHA - Lancez le pipeline et vérifiez que l'image est bien présente sur votre compte Docker Hub
Étape 8 : Bonus - Comparer avec d'autres outils de build¶
Pour élargir votre culture outillage, configurez un job de build avec l'une des alternatives suivantes, puis comparez-la à BuildKit : temps de build, simplicité de configuration, droits nécessaires sur le runner
Option A : Utilisation de Buildah¶
- Créez un job
build_buildahdans votre.gitlab-ci.yml - Utilisez l'image
quay.io/buildah/stable:v1.43 - Définissez la variable
STORAGE_DRIVERàvfs(Buildah ne peut pas empiler son overlayfs sur celui du conteneur) - Dans la section
script, connectez-vous au registre GitLab avececho "$CI_REGISTRY_PASSWORD" | buildah login -u "$CI_REGISTRY_USER" --password-stdin $CI_REGISTRY - Lancez la construction de l'image avec
buildah build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .(buildah buden est l'ancien alias) - Poussez l'image avec
buildah push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
Option B : Utilisation de Kaniko via son fork maintenu¶
Kaniko, archivé par Google en juin 2025, est repris par la communauté dans le fork osscontainertools/kaniko, qui maintient les dépendances à jour, corrige les bugs et publie des images publiques
- Créez un job
build_kanikodans votre.gitlab-ci.yml - Utilisez l'image
ghcr.io/osscontainertools/kaniko:v1.29.0-debugavec l'entrypoint vide[""](la variantedebugcontient un shell, indispensable pour GitLab CI ; la même image est publiée sur Docker Hub sousmartizih/kaniko) - Créez le fichier d'authentification
/kaniko/.docker/config.json, avec le même contenu que pour BuildKit - Lancez la construction et le push avec
/kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA-kaniko - Activez le cache avec
--cache=true --cache-repo=$CI_REGISTRY_IMAGE/kaniko-cacheet comparez les temps de build avec ceux de BuildKit
Et le fork de Chainguard ?
Chainguard maintient aussi un fork (chainguard-dev/kaniko), mais ne publie aucune image de conteneur publique : ses images sont réservées à ses clients, sinon il faut les construire soi-même depuis les sources
Option C : Utilisation de Cloud Native Buildpacks (Zéro Dockerfile)¶
Les Buildpacks permettent de construire une image sans écrire ni maintenir de Dockerfile, en détectant automatiquement la pile technologique (Node.js)
- Créez un job
build_buildpackdans votre.gitlab-ci.yml - Utilisez l'image
buildpacksio/pack:0.40.9-baseavec l'entrypoint vide[""](la variante par défaut est distroless, sans shell) et déclarez le servicedocker:29-dind(la CLIpacka besoin d'un démon Docker pour lancer le build) - Définissez les variables
DOCKER_HOSTàtcp://docker:2375etDOCKER_TLS_CERTDIRà"" - Configurez le fichier d'authentification
~/.docker/config.jsonavec vos identifiants de registre (l'image ne contient pas la CLIdocker,packlit directement ce fichier) - Lancez la construction et la publication automatique avec la commande :
pack build $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA --builder paketobuildpacks/builder-jammy-base --publish