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 :
{
"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 :
# 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 :
RUN --mount=type=ssh git clone [email protected]: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 :
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 :
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 :
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 :
{
"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 :
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=nonelà où c'est approprié. - Exécuter en tant que non-root dans l'étape finale.
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 secretpar--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=nonepour 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 historypour vérifier les couches inhabituelles. - [ ] Exécutez
docker runpour vérifier que l'utilisateur est non root. - [ ] Utilisez
diveou 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.