Kraft.gg - Formations

Appearance

Buildkit ​

Introduction ​

Docker BuildKit a été introduit dans Docker pour améliorer le processus de build des images. Il permet une plus grande flexibilité, des performances accrues, et propose de nouvelles fonctionnalités pour optimiser le développement et la livraison des conteneurs.

Pourquoi utiliser BuildKit ? ​

  • Optimisation des performances : BuildKit permet de paralléliser certaines étapes du processus de build, réduisant ainsi le temps de construction.
  • Réutilisation des caches : Les couches de cache sont mieux gérées, réduisant ainsi le nombre de reconstructions inutiles.
  • Contrôle avancé des builds : BuildKit permet de mieux gérer les contextes de build, les secrets et les fichiers de configuration.

Activer BuildKit ​

Pour utiliser Docker avec BuildKit, il faut d'abord activer cette fonctionnalité. Cela peut être fait de deux manières :

Activation temporaire via la ligne de commande ​

bash
DOCKER_BUILDKIT=1 docker build .

Activation permanente via la configuration Docker ​

Modifier le fichier daemon.json pour activer BuildKit par défaut :

json
{
  "features": {
    "buildkit": true
  }
}

Ensuite, redémarrer Docker pour appliquer les changements :

bash
sudo systemctl restart docker

Fonctionnalités clés de BuildKit ​

BuildKit offre plusieurs nouvelles fonctionnalités qui améliorent et enrichissent l’expérience de construction des images Docker.

Meilleure gestion du cache ​

BuildKit gère plus efficacement les caches de build, notamment avec la commande --cache-from et --cache-to, ce qui permet de spécifier et réutiliser les caches des builds précédents.

Exemple d’utilisation du cache dans un pipeline CI/CD :

bash
docker build --cache-from=type=local,src=/path/to/cache --cache-to=type=local,dest=/path/to/cache .

Build parallèle ​

BuildKit peut paralléliser plusieurs étapes du Dockerfile, réduisant ainsi le temps de build.

Par exemple, les instructions indépendantes comme l’installation de paquets et la copie de fichiers peuvent être exécutées en parallèle.

Montage de secrets et de fichiers spécifiques au moment du build ​

Avec BuildKit, vous pouvez monter des secrets (comme des clés API) ou des fichiers spécifiques (comme des fichiers de configuration) uniquement pour la durée du build. Ces secrets ne sont pas inclus dans l’image finale, ce qui renforce la sécurité.

Exemple d’utilisation des secrets :

bash
docker build --secret id=mysecret,src=/path/to/secret .

Dans le Dockerfile, vous pouvez ensuite accéder à ce secret via :

Dockerfile
RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret

Support des contextes multiples ​

BuildKit permet de spécifier plusieurs contextes de build (par exemple, différentes sources de fichiers) et de les utiliser dans le Dockerfile.

Exemple d’utilisation des contextes multiples :

bash
docker build --file Dockerfile --build-context mycontext=/path/to/context .

Amélioration des Dockerfile avec BuildKit ​

Avec BuildKit, certaines fonctionnalités des Dockerfiles deviennent plus puissantes. Voici quelques exemples de ces améliorations :

RUN avec --mount ​

Avec BuildKit, vous pouvez utiliser l'option --mount dans les instructions RUN pour monter temporairement des volumes, des caches ou des secrets pendant le build.

Exemple de montage temporaire pour le cache des paquets :

Dockerfile
RUN --mount=type=cache,target=/var/cache/apt \
    apt-get update && apt-get install -y build-essential

Ciblage des étapes de build avec des noms explicites ​

BuildKit permet de nommer les étapes de construction dans les Dockerfiles et de les cibler facilement.

Exemple de Dockerfile avec étapes nommées :

Dockerfile
FROM golang:1.16 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

FROM alpine:latest
COPY --from=builder /app/myapp /usr/local/bin/myapp
CMD ["myapp"]

Avec BuildKit, vous pouvez également cibler spécifiquement une étape intermédiaire pour la construire :


bash
docker build --target builder -t myapp:builder .

Gestion des logs et diagnostics ​

BuildKit introduit un nouveau système de logs qui permet de mieux comprendre ce qui se passe lors de la construction des images. Pour visualiser les étapes en détail et les informations de parallélisation, vous pouvez utiliser le mode verbose :

bash
DOCKER_BUILDKIT=1 docker build --progress=plain .

Exemples pratiques d’utilisation de BuildKit ​

Optimisation de builds multi-étapes ​

Avec BuildKit, les builds multi-étapes deviennent encore plus puissants grâce à la parallélisation et à la gestion avancée des caches. Par exemple :

Dockerfile

# Étape de compilation

FROM node:14 AS builder
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
RUN npm run build

# Étape de production

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

Ce Dockerfile utilise la puissance de BuildKit pour réutiliser les étapes de compilation dans des environnements de production sans inclure des fichiers inutiles dans l’image finale.

Gestion des secrets dans un CI/CD ​

Dans un pipeline CI/CD sécurisé, vous pouvez gérer les secrets avec BuildKit de manière à ce qu’ils ne soient pas inclus dans les artefacts finaux. Par exemple, pour accéder à une API lors du build tout en cachant les clés API :

bash
docker build --secret id=myapikey,src=/path/to/apikey .

Dans le Dockerfile :

Dockerfile
RUN --mount=type=secret,id=myapikey curl -H "Authorization: Bearer $(cat /run/secrets/myapikey)" <https://api.example.com/data>