Passer au contenu principal

Conteneurs et Registres (GitLab)

Integration Docker et Kaniko en CI

Construire des images Docker dans un pipeline CI pose un probleme d'isolation : le daemon Docker necessite des privileges root sur le systeme hote. Deux approches coexistent en production : Docker-in-Docker (dind) et les builders sans daemon (Kaniko, Buildah).

Docker-in-Docker

L'approche dind lance un daemon Docker dans un service de job. Elle necessite un runner configure en mode privilegied :

build-dind:
  image: docker:27
  services:
    - docker:27-dind
  variables:
    DOCKER_TLS_CERTDIR: "/certs"
  script:
    - docker info
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA

Avantages : familier, supporte toutes les options Docker build. Inconvenients : runners privilegied = risque de securite, overhead du daemon interne, caches difficiles a persister entre jobs.

Kaniko en detail

Kaniko parse le Dockerfile et execute chaque instruction directement dans le systeme de fichiers du conteneur, sans daemon. Il s'execute en root dans le conteneur mais sans capacites privilegiees sur l'hote.

build-kaniko:
  image:
    name: gcr.io/kaniko-project/executor:v1.23.2-debug
    entrypoint: [""]
  script:
    - mkdir -p /kaniko/.docker
    - echo "{"auths":{"$CI_REGISTRY":{"auth":"$(printf "%s:%s" "$CI_REGISTRY_USER" "$CI_REGISTRY_PASSWORD" | base64 | tr -d '
')"}}}" > /kaniko/.docker/config.json
    - /kaniko/executor
      --context $CI_PROJECT_DIR
      --dockerfile $CI_PROJECT_DIR/Dockerfile
      --destination $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
      --cache=true
      --cache-repo $CI_REGISTRY_IMAGE/cache

Cache des layers Docker

Le cache des layers Docker est le principal levier d'optimisation du build. Kaniko supporte le cache via --cache et --cache-repo, qui stocke les layers intermediaires dans le Container Registry GitLab. Docker buildx avec le driver docker-container supporte aussi le cache via --cache-to et --cache-from.

Multi-architecture

Pour builder des images multi-arch (amd64 + arm64), Docker buildx avec QEMU est l'approche standard sur des runners x86 :

build-multiarch:
  image: docker:27
  services:
    - docker:27-dind
  script:
    - docker run --privileged --rm tonistiigi/binfmt --install all
    - docker buildx create --use --name multiarch
    - docker buildx build
      --platform linux/amd64,linux/arm64
      --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
      --push .

Pour des builds arm64 natifs en production, des runners ARM physiques ou des VM arm64 sont plus efficaces que l'emulation QEMU.

Sources