## Introduction

Docker BuildKit est le moteur de construction moderne pour les images Docker, offrant des builds plus rapides, une mise en cache avancée et plus de flexibilité. Cependant, sa puissance introduit également de nouvelles considérations de sécurité. Un BuildKit mal configuré peut exposer des secrets de build, permettre un accès non autorisé ou fuiter des données par inadvertance. Ce guide fournit une approche pratique, étape par étape, pour renforcer BuildKit dans votre environnement, en garantissant que vos builds d'images soient sécurisés sans sacrifier les performances.

Un processus de durcissement clair réduit les reprises et la confusion. En commençant par un pilote étroit et mesurable, vous pouvez inspecter et ajuster les paramètres de sécurité localement avant de les déployer largement. Cet article vous guide à travers les vérifications de version, le contrôle d'accès, la gestion des secrets, le renforcement des permissions, la limitation de l'exposition réseau et la vérification. Chaque étape inclut des commandes concrètes et les sorties attendues pour que vous puissiez suivre et confirmer votre configuration.

## Inventaire des versions et de l'environnement

Avant d'apporter des modifications, vous devez avoir une vision claire de votre configuration Docker et BuildKit actuelle. Cet inventaire établit la base et permet d'identifier les fonctionnalités de sécurité disponibles. BuildKit est inclus avec Docker Engine 18.09 et versions ultérieures, et est le builder par défaut depuis Docker 23.0. Les versions plus anciennes peuvent ne pas prendre en charge toutes les options de durcissement.

Tout d'abord, vérifiez vos versions Docker et BuildKit :

```
docker version
```

Sortie attendue (exemple d'une version récente) :

```
Client: Docker Engine - Community
 Version:           24.0.5
 API version:       1.43
 Go version:        go1.20.4
 Git commit:        ced0996
 Built:             Tue Jul 25 02:52:41 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          24.0.5
  API version:      1.43 (minimum version 1.12)
  Go version:       go1.20.4
  Git commit:       a61e2b4
  Built:            Tue Jul 25 02:52:41 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.21
  GitCommit:        3dce8eb055cbb6878b9c4c58f6ac5a6d5b69a2c8
 runc:
  Version:          1.1.7
  GitCommit:        v1.1.7-0-g860f061
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0
```

Pour déterminer si BuildKit est activé, exécutez :

```
docker buildx version
```

Si BuildKit est disponible, vous verrez une sortie similaire à :

```
github.com/docker/buildx v0.11.2 9872040
```

Si `docker buildx` n'est pas trouvé, vous devrez peut-être installer le plugin buildx ou activer BuildKit en définissant la variable d'environnement `DOCKER_BUILDKIT=1` pour chaque commande de build ou dans votre profil shell.

Vous pouvez également inspecter la configuration actuelle du builder :

```
docker buildx ls
```

Exemple de sortie :

```
NAME/NODE DRIVER/ENDPOINT STATUS BUILDKIT PLATFORMS
default * docker
  default default running 20.10.24 linux/amd64, linux/arm64, linux/arm/v7, linux/arm/v6
```

Notez la version de BuildKit affichée. Certaines fonctionnalités de sécurité peuvent nécessiter une version minimale de BuildKit. Par exemple, les options `--secret` et `--ssh` sont disponibles depuis longtemps, mais des fonctionnalités plus récentes comme `--mount=type=cache` avec `sharing=private` nécessitent BuildKit 0.10 ou plus.

Une autre vérification importante consiste à savoir si vous utilisez la configuration par défaut du démon Docker ou une configuration personnalisée. Le fichier de configuration du démon se trouve généralement dans `/etc/docker/daemon.json`. Vous pouvez afficher son contenu (nécessite root ou sudo) :

```
sudo cat /etc/docker/daemon.json
```

Si le fichier n'existe pas, Docker utilise les paramètres par défaut. Les paramètres importants du démon pour la sécurité BuildKit incluent `"buildkit": true` (optionnel, car BuildKit est par défaut), `"features": { "buildkit": true }` (obsolète), ou `"builder": { "gc": { "enabled": true, "defaultKeepStorage": "10GB" } }` (ramasse-miettes).

Notez également l'utilisateur et le groupe actuels, car ils affectent les permissions d'accès au socket Docker, qui est le point d'entrée principal pour les opérations de build.

Enfin, vérifiez si vous avez des builders distants configurés, car ceux-ci peuvent avoir des considérations de sécurité distinctes :

```
docker buildx inspect default
```

Cela affiche des détails comme le driver, les plateformes et la version de BuildKit pour le builder.

Maintenant que vous avez un inventaire complet, vous pouvez passer à la mise en œuvre du durcissement de la sécurité de manière contrôlée.

## Chemin de configuration sûr

Le durcissement de BuildKit implique plusieurs domaines : contrôle d'accès, gestion des secrets, permissions de build, exposition réseau et isolation des conteneurs de build. Comme les changements peuvent affecter la fonctionnalité de build, il est important de les appliquer progressivement et de tester chaque étape. Un pilote étroit et mesurable est la meilleure première étape, car il permet de vérifier chaque changement localement avant un déploiement plus large.

### 1. Restreindre l'accès au démon Docker et à BuildKit

Les opérations BuildKit sont déclenchées via le démon Docker. Le contrôle de sécurité principal est de savoir qui peut accéder au socket Docker (`/var/run/docker.sock`). Par défaut, ce socket appartient à root et au groupe `docker`. Assurez-vous que seuls les utilisateurs de confiance sont dans le groupe `docker`. Ajouter un utilisateur au groupe `docker` lui donne un contrôle total sur le démon, ce qui équivaut à un accès root sur l'hôte, car il peut monter n'importe quel répertoire ou exécuter des conteneurs privilégiés. Par conséquent, restreignez l'appartenance au groupe.

Pour lister les utilisateurs du groupe `docker` :

```
grep docker /etc/group
```

Si vous devez ajouter un utilisateur, utilisez :

```
sudo usermod -aG docker username
```

Mais soyez conscient des implications de sécurité. Pour une isolation plus forte, envisagez d'utiliser Docker sans root ou un BuildKit distant avec authentification, mais cela dépasse le cadre de ce guide.

De plus, vous pouvez configurer le démon Docker pour exiger TLS pour les connexions distantes. Si vous devez exposer l'API Docker sur le réseau, activez l'authentification TLS. La configuration du démon inclurait :

```json
{
  "tls": true,
  "tlscert": "/etc/docker/certs/server-cert.pem",
  "tlskey": "/etc/docker/certs/server-key.pem",
  "tlsverify": true,
  "tlscacert": "/etc/docker/certs/ca.pem"
}
```

Ensuite, redémarrez Docker. Sans TLS, toute personne pouvant atteindre le port peut contrôler Docker. Même avec TLS, assurez-vous que les certificats sont correctement sécurisés.

### 2. Utiliser les secrets BuildKit pour les données sensibles

N'intégrez jamais de secrets comme des mots de passe, des clés API ou des jetons directement dans une commande `RUN` d'un Dockerfile. BuildKit fournit `--secret` pour monter des fichiers secrets ou des variables d'environnement pendant les étapes de build sans les conserver dans les couches de l'image. C'est une amélioration majeure par rapport aux anciennes méthodes comme `COPY` de secrets puis leur suppression, qui les laissent dans l'historique de l'image.

Exemple de Dockerfile utilisant un secret :

```dockerfile
# syntax=docker/dockerfile:1
FROM alpine:latest
RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret
```

Construisez avec :

```
echo "supersecret" > secret.txt
docker build --secret id=mysecret,src=secret.txt -t myapp .
```

Le secret n'est disponible que pendant cette instruction `RUN` et n'est pas stocké dans l'image finale ou les couches intermédiaires (sauf si vous le copiez intentionnellement dans une couche). Vous pouvez également utiliser `--secret id=mysecret,env=MY_SECRET` pour passer une variable d'environnement.

Si vous avez besoin de la redirection de l'agent SSH pour les dépôts privés, utilisez `--ssh` :

```dockerfile
RUN --mount=type=ssh git clone git@github.com:example/repo.git
```

Construisez avec :

```
docker build --ssh default -t myapp .
```

Cela évite de copier les clés privées SSH dans l'image.

### 3. Renforcer les permissions des conteneurs de build

BuildKit exécute chaque instruction `RUN` dans un conteneur avec certains privilèges. Par défaut, les conteneurs de build s'exécutent en tant que root. Vous pouvez changer l'utilisateur dans les étapes de build en utilisant la directive `USER` dans le Dockerfile. Pour les étapes qui nécessitent root (par exemple, installer des paquets), vous pouvez revenir à un utilisateur non root pour les étapes restantes :

```dockerfile
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y curl
USER appuser
RUN curl ...
```

Cela réduit le risque si une étape de build est compromise. De plus, vous pouvez utiliser le drapeau `--security=sandbox` dans `RUN` pour exécuter dans un profil seccomp/AppArmor plus restrictif (nécessite BuildKit 0.10+). Par exemple :

```dockerfile
RUN --security=sandbox apt-get update
```

Par défaut, `RUN` utilise `sandbox`, mais vous pouvez aussi utiliser `insecure` pour désactiver le bac à sable (non recommandé sauf si nécessaire). Gardez la valeur par défaut.

### 4. Contrôler l'accès réseau pendant les builds

BuildKit vous permet de contrôler l'accès réseau par étape de build. Par défaut, les étapes de build ont accès au réseau. Si votre build n'a pas besoin de réseau pour certaines étapes (par exemple, simplement copier des fichiers), vous pouvez utiliser `--network=none` :

```dockerfile
RUN --network=none go build -o app .
```

Cela empêche toute connexion réseau à partir de cette étape, réduisant la surface d'attaque. Pour les étapes qui ont besoin de réseau, vous pouvez restreindre à un réseau personnalisé spécifique en utilisant `--network=bridge` ou un réseau défini par l'utilisateur. Par exemple, dans un build multi-étapes, vous pourriez isoler l'étape de téléchargement.

Au niveau du builder, vous pouvez désactiver l'accès réseau pour tous les builds si vous utilisez un builder distant, mais cela est moins pratique. Au lieu de cela, utilisez le contrôle par étape.

### 5. Configurer le ramasse-miettes et le cache de BuildKit

BuildKit met en cache les couches pour accélérer les builds, mais ce cache peut contenir des données sensibles si des secrets ou du code privé ont été copiés dans une couche. Configurez le ramasse-miettes (GC) pour purger périodiquement le cache. Le démon Docker a une politique de GC par défaut, mais vous pouvez l'ajuster dans `/etc/docker/daemon.json` :

```json
{
  "builder": {
    "gc": {
      "enabled": true,
      "defaultKeepStorage": "20GB",
      "policy": [
        { "keepStorage": "10GB", "filter": ["unused-for=24h"] },
        { "keepStorage": "5GB", "filter": ["unused-for=168h"] }
      ]
    }
  }
}
```

Cet exemple conserve jusqu'à 10 Go de cache utilisé au cours des dernières 24 heures et 5 Go de cache utilisé au cours de la dernière semaine, et supprime tout ce qui n'a pas été utilisé depuis plus longtemps. Ajustez selon vos besoins. Après modification, redémarrez Docker.

### 6. Activer la confiance de contenu (facultatif)

La confiance de contenu garantit que les images de base que vous extrayez sont signées par un éditeur de confiance. Activez-la avec :

```
export DOCKER_CONTENT_TRUST=1
```

Ensuite, lorsque vous extrayez une image, Docker vérifie la signature. Pour les builds, vous voudrez peut-être épingler les images de base par empreinte dans votre Dockerfile :

```dockerfile
FROM alpine@sha256:123456...
```

Cela empêche l'utilisation accidentelle d'une version différente.

### Exemple : Construire une application simple de manière sécurisée

Prenons un exemple concret. Supposons que vous ayez une application Node.js qui nécessite un paquet npm d'un registre privé. Avec BuildKit, vous pouvez :

- Utiliser un build multi-étapes.
- Monter un secret pour le jeton npm.
- Utiliser `--network=none` là où c'est approprié.
- Exécuter en tant que non-root dans l'étape finale.

Dockerfile :

```dockerfile
# syntax=docker/dockerfile:1
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN --mount=type=secret,id=npm_token \
    NPM_TOKEN=$(cat /run/secrets/npm_token) npm install
COPY . .
RUN --network=none npm run build

FROM node:18-alpine
WORKDIR /app
USER node
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]
```

Construisez avec :

```
echo "your_npm_token" > npm_token.txt
docker build --secret id=npm_token,src=npm_token.txt -t myapp:latest .
```

Cela garantit que le jeton n'est pas stocké dans l'image. Le `--network=none` sur l'étape de build empêche tout accès réseau non intentionnel. L'étape finale s'exécute en tant qu'utilisateur `node`.

## Vérification et diagnostics

Après avoir appliqué les mesures de durcissement, vous devez vérifier qu'elles sont efficaces. Voici des vérifications pour chaque domaine.

### 1. Confirmer que les secrets ne sont pas dans les couches de l'image

Après avoir construit avec `--secret`, exécutez un conteneur à partir de l'image et assurez-vous que le secret n'est pas présent. Pour l'exemple ci-dessus :

```
docker run -it --rm myapp:latest sh -c 'ls -la /run/secrets/ 2>/dev/null; echo $NPM_TOKEN'
```

Attendu : pas de répertoire `/run/secrets` et `$NPM_TOKEN` vide. Vérifiez également l'historique de l'image pour vous assurer qu'aucune couche ne contient la chaîne du secret :

```
docker history myapp:latest
```

Recherchez toute couche qui aurait pu inclure le secret. Pour une vérification plus approfondie, utilisez `docker save` et inspectez l'archive tar, ou utilisez des outils comme `dive` pour analyser les couches. Exemple :

```
dive myapp:latest
```

Dans `dive`, vous pouvez parcourir les changements de fichiers de chaque couche et rechercher le secret.

### 2. Vérifier le cache BuildKit pour les secrets

Si vous soupçonnez que des secrets ont pu être mis en cache dans des builds précédents, exécutez :

```
docker builder prune --all --force
```

Cela supprime tout le cache de build. Pour vérifier l'utilisation actuelle du cache :

```
docker system df
```

Cela montre l'espace utilisé par le cache de build sous `Build Cache`.

### 3. Vérifier les restrictions réseau

Pour vous assurer que `--network=none` a fonctionné, vous pouvez ajouter temporairement une étape qui échoue si le réseau est disponible. Par exemple, dans votre Dockerfile, ajoutez un `RUN` de test (pas pour la production) qui essaie de pinger une IP externe et échoue si cela réussit. Mieux : après avoir construit avec `--network=none`, inspectez les journaux de build. BuildKit enregistre-t-il l'utilisation du réseau ? Pas directement. Au lieu de cela, vous pouvez utiliser un test à effet de bord : créez une étape `RUN` avec `--network=none` qui tente de télécharger un fichier et devrait échouer si l'étape s'exécute réellement. Mais comme `--network=none` est un drapeau de temps de build, l'étape échouera si elle essaie le réseau. Donc, si votre build a réussi avec `--network=none` sur une étape qui nécessitait auparavant le réseau, alors la restriction a fonctionné. Vous pouvez également exécuter `docker build --progress=plain` pour voir la sortie complète, y compris les erreurs réseau si elles se produisent.

### 4. Vérifier les permissions de l'utilisateur du conteneur

Exécutez un conteneur à partir de l'image finale et vérifiez l'utilisateur :

```
docker run -it --rm myapp:latest id
```

Sortie attendue pour ce qui précède : `uid=1000(node) gid=1000(node) groups=1000(node)`. Si elle montre `root`, alors la directive `USER` ne s'est pas appliquée à l'étape finale.

### 5. Vérifier le TLS du démon Docker (si configuré)

Si vous avez activé TLS sur le démon Docker, testez l'accès distant sans certificats pour vous assurer qu'il est refusé :

```
docker -H tcp://your-server:2376 info
```

Devrait renvoyer une erreur de certificat. Avec des certificats clients appropriés, cela devrait réussir.

### 6. Vérifier la version et les fonctionnalités de BuildKit

Exécutez :

```
docker buildx ls
```

Assurez-vous que la version de BuildKit est celle attendue. Pour le support de fonctionnalités spécifiques, référez-vous aux notes de version de BuildKit.

## Pièges courants et comment les éviter

Même avec une configuration soignée, des erreurs courantes peuvent compromettre la sécurité de BuildKit. Voici quelques pièges et comment les éviter ou s'en remettre.

### Piège 1 : Cuire accidentellement des secrets dans les couches de l'image

**Pourquoi cela arrive :** Les développeurs utilisent `COPY` ou `ADD` pour inclure un fichier `.env` ou une clé privée, puis le suppriment dans une couche ultérieure, en supposant qu'il a disparu. Cependant, le secret reste dans la couche intermédiaire et peut être extrait avec `docker history` ou en extrayant l'image.

**Comment l'éviter :** Utilisez toujours les secrets BuildKit (`--secret` ou `--mount=type=secret`) pour toute donnée sensible nécessaire pendant le build. Si un secret doit être un fichier dans l'image finale, envisagez d'utiliser des secrets d'exécution via un orchestrateur ou des variables d'environnement à la place.

**Récupération :** Si un secret est découvert dans une image, faites pivoter le justificatif immédiatement, reconstruisez l'image sans le secret et purgez le cache de build avec `docker builder prune --all --force` pour supprimer toutes les couches en cache le contenant.

### Piège 2 : Accès trop large au socket Docker

**Pourquoi cela arrive :** Pour simplifier le développement, les équipes ajoutent de nombreux utilisateurs au groupe `docker`, leur accordant un accès équivalent à root. Cela élargit la surface d'attaque si les comptes de ces utilisateurs sont compromis.

**Comment l'éviter :** N'ajoutez que les utilisateurs qui ont absolument besoin de construire des images, et envisagez d'utiliser Docker sans root ou un BuildKit distant avec authentification pour une isolation plus forte. Auditez régulièrement l'appartenance au groupe avec `grep docker /etc/group`.

**Récupération :** Supprimez les utilisateurs inutiles du groupe `docker` avec `sudo gpasswd -d username docker`, et mettez en place un processus de révision pour les nouvelles additions au groupe.

### Piège 3 : Isolation réseau manquante pour les étapes de build sensibles

**Pourquoi cela arrive :** Les développeurs supposent que les builds sont isolés et ne réalisent pas que les conteneurs de build ont accès au réseau par défaut. Une image de base compromise ou une dépendance pourrait exfiltrer des données.

**Comment l'éviter :** Appliquez `--network=none` à toute étape qui ne nécessite pas d'accès réseau, comme la compilation ou les étapes de copie de fichiers. Pour les étapes qui ont besoin du réseau, limitez à un réseau privé si possible.

**Récupération :** Passez en revue les Dockerfiles et ajoutez `--network=none` là où c'est approprié. Si une étape échoue parce qu'elle a besoin du réseau, évaluez si l'exigence réseau peut être supprimée ou si un réseau plus restreint peut être utilisé.

### Piège 4 : Exécuter les conteneurs de build en tant que root

**Pourquoi cela arrive :** Les instructions `RUN` par défaut des Dockerfiles s'exécutent en tant que root, et les développeurs oublient souvent de passer à un utilisateur non root. Si une étape de build est compromise, l'attaquant obtient des privilèges root dans l'environnement de build.

**Comment l'éviter :** Utilisez la directive `USER` pour passer à un utilisateur non root pour toutes les étapes qui ne nécessitent pas root, surtout dans l'étape finale. Pour les étapes qui doivent s'exécuter en tant que root, envisagez d'utiliser `--security=sandbox` pour restreindre les capacités.

**Récupération :** Refactorez le Dockerfile pour créer un utilisateur dédié et y passer après les étapes root prérequises. Testez l'image construite pour vous assurer que l'application s'exécute avec l'utilisateur non root.

### Piège 5 : Ignorer la sécurité du cache de build

**Pourquoi cela arrive :** Le cache de build est considéré comme éphémère et non comme un risque de sécurité. Cependant, les couches en cache peuvent contenir des secrets ou des dépendances vulnérables qui persistent plus longtemps que prévu.

**Comment l'éviter :** Configurez le ramasse-miettes de BuildKit avec des politiques de rétention appropriées, et purgez périodiquement le cache manuellement avec `docker builder prune`. Évitez également d'utiliser des montages de cache pour des données sensibles sauf si nécessaire, et utilisez `sharing=private` pour les montages de cache qui peuvent contenir des secrets.

**Récupération :** Si le cache est suspecté de contenir des secrets, purgez-le immédiatement et reconstruisez. Ajustez les politiques de GC pour empêcher la rétention à long terme du cache inutilisé.

## Modes de défaillance et récupération

Malgré un durcissement soigné, des problèmes peuvent survenir. Voici les modes de défaillance courants et comment s'en remettre.

### 1. Le build échoue à cause de `--network=none`

Si une étape nécessite le réseau mais que vous avez défini `--network=none`, le build échouera avec une erreur réseau, comme :

```
error: failed to solve: process "/bin/sh -c apt-get update" did not complete successfully: exit code: 100
```

Récupération : Supprimez `--network=none` de cette étape, ou ajustez l'étape pour utiliser un réseau si absolument nécessaire. Puis reconstruisez.

### 2. Le montage du secret ne fonctionne pas

Si le secret n'est pas trouvé, le build échoue avec quelque chose comme :

```
error: failed to solve: secret mysecret not found
```

Vérifiez que vous avez passé `--secret` correctement et que le fichier source existe. Vérifiez également la syntaxe du montage dans le Dockerfile. Le montage doit être sur la même ligne que la commande `RUN`.

### 3. Fuite de secret due à la mise en cache

Si un secret a été utilisé dans une étape de build qui a également copié des fichiers ou produit une sortie, il pourrait être mis en cache. Par exemple, si vous utilisez `RUN --mount=type=secret ... && curl -H ... > output.txt`, le fichier de sortie peut contenir le secret. Pour récupérer, purgez le cache et reconstruisez sans le secret dans la sortie :

```
docker builder prune --all --force
```

Ensuite, corrigez le Dockerfile pour éviter d'écrire des secrets dans des fichiers, ou assurez-vous que ces fichiers ne sont pas inclus dans l'image finale.

### 4. Une mauvaise configuration TLS provoque une défaillance du démon Docker

Si les paramètres TLS sont incorrects, le démon Docker peut ne pas démarrer. Vérifiez les journaux :

```
journalctl -u docker.service
```

Recherchez les erreurs de certificat. Récupération : Corrigez les chemins ou le contenu des certificats dans `/etc/docker/daemon.json`, ou revenez à aucun TLS si nécessaire, puis redémarrez Docker.

### 5. Problèmes de permission utilisateur dans le conteneur

Si vous définissez `USER` sur un utilisateur non root mais que des étapes ultérieures nécessitent root, le build échoue avec permission refusée. Récupération : Revenez temporairement à root avec `USER root` avant l'étape qui en a besoin, puis revenez en arrière.

### 6. Ramasse-miettes de BuildKit trop agressif

Si vous définissez une politique de GC trop basse, vous risquez de perdre fréquemment du cache, ralentissant les builds. Surveillez le taux de succès du cache avec `docker build --progress=plain` pour voir l'utilisation du cache. Ajustez les valeurs de `keepStorage` à la hausse si nécessaire.

Dans tous les cas, conservez des sauvegardes de votre Dockerfile et de vos scripts de build, et utilisez le contrôle de version pour pouvoir revenir facilement en arrière.

## Liste de contrôle opérationnelle

Utilisez cette liste de contrôle pour les revues de sécurité de routine et avant de déployer des changements. Attribuez un propriétaire responsable unique pour chaque élément majeur et définissez une fréquence de révision.

| Élément de la liste de contrôle | Propriétaire (exemple) | Fréquence de révision |
|--------------------------------|------------------------|----------------------|
| Les versions de Docker et BuildKit sont à jour | Ingénieur DevOps | Mensuelle |
| Seuls les utilisateurs autorisés sont dans le groupe docker | Administrateur système | Trimestrielle |
| Les Dockerfiles utilisent des secrets, pas COPY pour les données sensibles | Champion sécurité | À chaque build |
| Images de base épinglées par empreinte | Ingénieur DevOps | À chaque build |
| Utilisateur non root dans l'étape finale | Développeur d'application | À chaque build |
| Isolation réseau appliquée là où c'est possible | Développeur d'application | À chaque build |
| La politique de purge du cache de build est efficace | Ingénieur DevOps | Mensuelle |
| Les certificats TLS pour le démon Docker distant sont valides | Administrateur système | Trimestrielle |

### Liste de contrôle pré-build

- [ ] Assurez-vous que les versions de Docker et BuildKit sont à jour.
- [ ] Confirmez que seuls les utilisateurs autorisés sont dans le groupe `docker`.
- [ ] Définissez `DOCKER_BUILDKIT=1` (ou fiez-vous à la valeur par défaut) pour garantir l'utilisation de BuildKit.
- [ ] Passez en revue le Dockerfile pour les secrets ; remplacez `COPY secret` par `--secret`.
- [ ] Épinglez les images de base par empreinte lorsque c'est possible.
- [ ] Identifiez les étapes qui nécessitent le réseau ; prévoyez d'utiliser `--network=none` pour les autres.
- [ ] Prévoyez un utilisateur non root pour l'étape d'exécution.

### Liste de contrôle de vérification post-build

- [ ] Exécutez `docker history` pour vérifier les couches inhabituelles.
- [ ] Exécutez `docker run` pour vérifier que l'utilisateur est non root.
- [ ] Utilisez `dive` ou similaire pour inspecter les secrets.
- [ ] Confirmez que la taille du cache de build est acceptable.

### Opérations régulières

- [ ] Purgez périodiquement le cache de build (`docker builder prune`).
- [ ] Surveillez les journaux du démon Docker pour les tentatives d'accès non autorisées.
- [ ] Passez en revue et mettez à jour les processus de gestion des secrets.
- [ ] Gardez BuildKit et Docker à jour avec les correctifs de sécurité.

### Réponse aux incidents

- [ ] Si un secret est suspecté dans une image, reconstruisez immédiatement sans le secret et purgez le cache.
- [ ] Faites pivoter les justificatifs exposés.
- [ ] Enquêtez sur la façon dont le secret a fuité et mettez à jour les processus.

## Conclusion

Le durcissement de Docker BuildKit est essentiel pour des builds d'images sécurisés. En suivant les étapes de ce guide, vous pouvez contrôler l'accès à l'environnement de build, gérer les secrets en toute sécurité, restreindre les permissions de build et l'accès réseau, et vérifier vos configurations. Commencez par un petit pilote mesurable : prenez un Dockerfile, appliquez ces techniques de durcissement et testez soigneusement. Une fois confiant, étendez à d'autres projets.

Rappelez-vous que la sécurité est un processus continu. Passez régulièrement en revue vos configurations de build, restez à jour avec les versions de Docker et BuildKit, et intégrez de nouvelles fonctionnalités de sécurité dès qu'elles sont disponibles. Un processus de durcissement clair réduit les reprises et aide votre équipe à produire des conteneurs fiables et sécurisés.