Aller au contenu

Kaniko : Révolutionner vos builds Docker en toute sécurité

Bannière d'article

Dans l'univers du DevOps, la création d'images Docker est une tâche courante et cruciale. Cependant, construire ces images dans des environnements non-privilégiés, tels que des pipelines CI/CD, peut poser des défis de sécurité. Cet article explore comment Kaniko, un outil développé par Google, permet de construire des images Docker de manière sécurisée sans nécessiter de privilèges élevés. Nous couvrirons la théorie derrière Kaniko, une démonstration pratique de son utilisation, et un benchmark comparatif avec d'autres solutions.

Théorie : Pourquoi Utiliser Kaniko ?

Problématiques des builds Docker traditionnels

Les builds Docker traditionnels requièrent souvent des privilèges élevés pour fonctionner, car le démon Docker doit s'exécuter en tant que root. Cette exigence peut poser des risques de sécurité, surtout dans des environnements partagés ou des pipelines CI/CD. Les builds non-privilégiés réduisent ces risques en limitant les permissions nécessaires.

L'un des cas d'utilisation les plus cruciaux pour un builder non-privilégié est la construction d'images de conteneurs dans les pipelines CI/CD. Dans un environnement de développement moderne, l'intégration continue et le déploiement continu (CI/CD) sont essentiels pour livrer rapidement et de manière fiable des applications aux utilisateurs finaux. Les pipelines CI/CD automatisent la construction, le test et le déploiement du code, nécessitant souvent la création d'images Docker à chaque changement de code. Utiliser un builder non-privilégié comme Kaniko dans ces pipelines permet de renforcer la sécurité en éliminant le besoin de privilèges élevés. Cela réduit les risques de sécurité tout en garantissant que les images sont construites de manière efficace et conforme aux meilleures pratiques, assurant ainsi une livraison continue et sécurisée des applications.

Qu'est-ce que Kaniko ?

Kaniko est un outil open-source développé par Google, conçu pour construire des images Docker à partir d'un Dockerfile, mais sans nécessiter de démon Docker et sans privilèges élevés (--privileged). Il s'exécute dans un conteneur, analysant et exécutant les instructions du Dockerfile pour produire une image.

Fonctionnement de Kaniko

Kaniko exécute chaque instruction Dockerfile dans un conteneur éphémère, en utilisant l'API Container Runtime Interface (CRI) pour interagir avec le conteneur hôte. Cela permet de construire des images de manière fiable et sécurisée dans des environnements variés.

Kaniko fonctionne en trois étapes principales :

  1. Extraction des sources : Kaniko télécharge les sources de l'application et les fichiers nécessaires.
  2. Analyse du Dockerfile : Kaniko lit le Dockerfile et interprète chaque instruction (FROM, RUN, COPY, etc.).
  3. Construction de l'image : Kaniko exécute les instructions du Dockerfile dans un environnement non-privilégié pour construire l'image finale.

Pratique : Construire une image Docker avec Kaniko

Prérequis

  • De quoi exécuter un conteneur (docker, kubernetes, podman, etc.)

Étape 1 : Créer un Dockerfile

Créez un fichier Dockerfile pour votre application. Par exemple : 

FROM ubuntu:22.04
RUN apt-get update -y \
 && apt-get install -y git \
 && rm -rf /var/lib/apt/lists/*

Cette image est simplement un ubuntu avec la commande git.

Étape 2 : Lancer le conteneur Kaniko

Afin d'exécuter Kaniko dans un environnement intéractif ou dans une pipeline de CI/CD, il est nécessaire d'utiliser une version debug pour avoir accès à un terminal et de surcharger l'entrypoint.

docker run --rm -it --entrypoint=sh gcr.io/kaniko-project/executor:debug

Étape 3 : Lancer le build Kaniko

Appliquez la commande suivante dans le conteneur :

/kaniko/executor --context . --dockerfile Dockerfile --no-push --reproducible --tar-path kanikogit.tar

Cette commande produit un tar qui contient l'image OCI. Pour la pousser directement dans une registry autorisée, préférez la commande :

/kaniko/executor --context . --dockerfile Dockerfile --no-push --reproducible --destination monregistry.fr/kanikogit:latest

Benchmark : Comparaison des solutions de build non-privilégiées

Critères de Comparaison

  • Sécurité : Capacité à exécuter des builds dans des environnements non-privilégiés.
  • Performance : Temps de build et utilisation des ressources.
  • Simplicité : Facilité de configuration et d'utilisation.

Solutions Comparées

  1. Kaniko
  2. Buildah
  3. Podman

Sécurité

  • Kaniko : Exécute les builds sans nécessiter de démon Docker, donc pas de privilèges root nécessaires.
  • Buildah : Conçu pour fonctionner sans démon Docker et peut s'exécuter de manière rootless.
  • Podman : Alternative à Docker qui ne nécessite pas de démon et supporte les builds rootless.

Performance

  • Kaniko : Performances élevées pour des builds simples, mais peut être plus lent pour des builds complexes en raison de l'absence de cache partagé.
  • Buildah : Performances comparables à Docker, mais peut nécessiter une configuration supplémentaire pour des builds complexes.
  • Podman : Performances similaires à Docker, avec un support pour les builds rootless.

Simplicité

  • Kaniko : Facile à intégrer dans les pipelines CI/CD Kubernetes, mais nécessite une configuration initiale du job.
  • Buildah : Plus flexible mais peut être plus complexe à configurer pour des utilisateurs habitués à Docker.
  • Podman : Similaire à Docker en termes d'utilisation, donc facile à adopter pour les utilisateurs de Docker.

Résultats du Benchmark

Solution Sécurité Sans daemon Sans --privileged Taille de l'image
Kaniko Excellent ✅ ✅ 153MB
Buildah Excellent ✅ ✅ 153MB
Podman Bonne ✅ 🚫 153MB
Docker Faible 🚫 🚫 153MB

Conclusion

Kaniko se distingue comme une solution sécurisée et pratique pour construire des images Docker dans des environnements non-privilégiés, particulièrement adaptée aux pipelines CI/CD basés sur Kubernetes. Bien que d'autres solutions comme Buildah et Podman offrent également des fonctionnalités similaires, Kaniko brille par sa simplicité d'intégration et sa sécurité inhérente.

Pour les équipes cherchant à améliorer la sécurité de leurs pipelines CI/CD sans sacrifier la facilité d'utilisation, Kaniko représente un excellent choix. Essayez-le dans vos prochains projets et profitez de la tranquillité d'esprit qu'il apporte à vos builds Docker.

N'hésitez pas à me solliciter pour plus d'informations ou pour approfondir un point particulier !

Pour aller plus loin

Note : J'ai volontairement simplifié certains aspects techniques pour une meilleure compréhension. N'hésitez pas à me demander des précisions si besoin.