E-NO
DevOps 12 min de lecture

Automatisation de la sécurité Docker dans les pipelines CI/CD : guide pratique de mise en œuvre

calendar_today Publié : 2026-11-16
update Dernière mise à jour : 2026-11-16
analytics Efficacité SEO : 97%
Illustration du guide technique pour « Automatisation de la sécurité Docker dans les pipelines CI/CD : guide pratique de mise en œuvre ».

Introduction

Les équipes logicielles modernes s'appuient sur les conteneurs pour empaqueter et livrer leurs applications, mais la commodité des conteneurs introduit des considérations de sécurité faciles à négliger. Les images Docker regroupent souvent des bibliothèques système, des environnements d'exécution de langage et des dépendances applicatives ; une seule vulnérabilité non corrigée ou une configuration trop permissive peut exposer un service entier. L'intégration de contrôles de sécurité directement dans l'automatisation CI/CD permet de détecter ces problèmes avant qu'ils n'atteignent la production et transforme les revues de sécurité ponctuelles en une boucle de rétroaction rapide et reproductible.

Ce guide présente une configuration pratique d'automatisation de la sécurité Docker dans un pipeline CI/CD à l'aide d'outils gratuits et largement disponibles. Vous verrez comment inventorier l'environnement, appliquer des choix de configuration sûrs, vérifier que les contrôles fonctionnent comme prévu, gérer les échecs sans bloquer le pipeline et exploiter le processus au quotidien. Les exemples sont volontairement restreints et axés sur le local, afin que vous puissiez les adapter à votre outillage existant sans investissement initial important.

Inventaire des versions et de l'environnement

Avant d'ajouter l'automatisation de la sécurité, documentez les versions et la topologie avec lesquelles vous allez travailler. Cet inventaire évite les écarts de versions entre le développement local et les exécuteurs CI et facilite le dépannage. Pour ce guide, l'environnement de référence est le suivant :

  • Docker Engine 24.0.5 ou plus récent, avec Buildx disponible (exécutez docker version et docker buildx version pour confirmer).
  • Une plateforme CI qui prend en charge les tâches conteneurisées, comme GitHub Actions, GitLab CI ou un exécuteur auto-hébergé avec Docker installé. Les exemples utilisent la syntaxe GitHub Actions, mais les concepts s'appliquent à tout exécuteur capable d'exécuter des commandes Docker.
  • Un dépôt d'application contenant un Dockerfile, le code applicatif et une définition de workflow CI.
  • Des outils d'analyse de sécurité en ligne de commande courants installés dans la tâche CI : Trivy (version 0.45 ou ultérieure), Hadolint (2.12.0 ou ultérieure) et Dockle (0.4.14 ou ultérieure). Ce sont des binaires uniques, faciles à épingler dans le pipeline.

Une topologie typique est une tâche unique de construction et d'analyse qui construit l'image, exécute les analyses de sécurité, puis pousse l'image vers un registre uniquement si tout est réussi. Garder l'analyse dans une seule étape réduit les pièces mobiles. Si votre organisation exige une séparation des tâches, vous pouvez avoir une étape de promotion ultérieure, mais pour le premier pilote, une seule étape suffit.

Prérequis pour l'exécuteur CI :

  • Le démon Docker doit être disponible pour la tâche. Sur GitHub Actions, l'utilisation des exécuteurs ubuntu-latest fournit Docker prêt à l'emploi.
  • Accès réseau pour extraire les images des analyseurs ou télécharger leurs binaires. Si votre environnement CI est hors ligne, préinstallez les analyseurs sur une image d'exécuteur personnalisée.
  • Identifiants stockés en tant que secrets pour le registre de conteneurs. Ne codez jamais en dur les identifiants de registre dans le fichier de workflow.

Vérifiez ces prérequis avec une tâche minimale :

name: environment-check
on: [push]
jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - name: Check Docker
        run: docker version --format '{{.Server.Version}}'
      - name: Check Buildx
        run: docker buildx version

La sortie attendue pour la première étape est une seule ligne de version du serveur, telle que 24.0.5. La deuxième étape affiche la version de Buildx, par exemple github.com/docker/buildx v0.11.2. Si l'une ou l'autre commande échoue, corrigez l'exécuteur avant de continuer.

Question rapide 1 sur 2

Quel outil est recommandé dans l’article pour l’analyse statique (linting) de Dockerfile ?

L’article indique : « Analyse statique (linting) du Dockerfile avec Hadolint pour détecter les mauvaises configurations courantes comme l’utilisation de tags latest ou l’exécution en tant que root. »

Chemin de configuration sûr

Commencez par un contrôle de sécurité étroit et mesurable, facile à inspecter localement. Tenter d'activer tous les analyseurs et toutes les politiques en même temps produit souvent des faux positifs et ralentit le pipeline. Commencez par trois contrôles qui couvrent différentes couches :

  • Linting du Dockerfile avec Hadolint pour détecter les mauvaises configurations courantes comme l'utilisation de l'étiquette latest ou l'exécution en tant que root.
  • Analyse des vulnérabilités de l'image avec Trivy pour identifier les CVE connues dans l'image construite.
  • Vérifications des benchmarks CIS avec Dockle pour valider la conformité de l'image aux meilleures pratiques.

Ces outils s'exécutent localement sur la machine du développeur, vous pouvez donc reproduire exactement les résultats CI. Configurez chaque analyseur avec un fichier de politique clair plutôt que de vous fier aux valeurs par défaut, et conservez la politique dans le dépôt afin que les modifications soient examinées.

Organisation du dépôt

Ajoutez un répertoire security/ au dépôt d'application :

security/
  hadolint.yaml
  trivy.yaml
  dockle.config

Un exemple de configuration Hadolint qui ignore une règle de style courante et échoue sur une instruction spécifique :

# security/hadolint.yaml
ignored:
  - DL3008 # Épingler les versions dans apt install ; nous utilisons une image de base avec des paquets épinglés
failure-threshold: warning

La configuration de Trivy peut définir un seuil de gravité afin que seules les vulnérabilités critiques et élevées fassent échouer la construction :

# security/trivy.yaml
severity:
  - CRITICAL
  - HIGH

Dockle utilise un drapeau --config avec un simple fichier JSON pour désactiver les vérifications non pertinentes :

{
  "ignore": [
    "CIS-DI-0001"
  ]
}

Définition du workflow CI

Un workflow GitHub Actions qui construit l'image localement pour l'analyse avec docker/build-push-action, exécute les trois analyseurs et ne pousse que si tous réussissent en utilisant à nouveau docker/build-push-action avec push: true. Le workflow est conçu pour échouer rapidement : si une analyse échoue, l'étape de poussée est ignorée.

name: docker-security
on:
  push:
    branches: [main]
  pull_request:

jobs:
  build-and-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Lint Dockerfile
        run: |
          docker run --rm -i hadolint/hadolint:2.12.0-alpine \
            hadolint --config /security/hadolint.yaml - < Dockerfile

      - name: Build image for scanning
        uses: docker/build-push-action@v5
        with:
          context: .
          load: true
          push: false
          tags: myapp:${{ github.sha }}

      - name: Scan image with Trivy
        run: |
          docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
            aquasec/trivy:0.45.0 image --config /security/trivy.yaml \
            myapp:${{ github.sha }}

      - name: Check CIS benchmarks with Dockle
        run: |
          docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
            goodwithtech/dockle:0.4.14 --config /security/dockle.config \
            myapp:${{ github.sha }}

      - name: Login to registry
        if: success()
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.REGISTRY_USERNAME }}
          password: ${{ secrets.REGISTRY_PASSWORD }}

      - name: Push image
        if: success()
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: myapp:${{ github.sha }}

Notez comment le workflow monte la socket Docker pour Trivy et Dockle. Cela est nécessaire pour qu'ils puissent inspecter l'image locale. Dans un environnement renforcé, envisagez d'utiliser un analyseur qui extrait l'image du registre après la poussée pour éviter l'accès à la socket, mais pour un premier pilote, le montage de la socket est acceptable et maintient une boucle de rétroaction rapide.

Reproduction locale

Chaque étape CI peut être exécutée localement pour valider les modifications avant de les pousser. Par exemple, l'étape Hadolint :

docker run --rm -i hadolint/hadolint:2.12.0-alpine \
  hadolint --config security/hadolint.yaml - < Dockerfile

Si le Dockerfile a un problème comme FROM ubuntu: latest, Hadolint affiche un avertissement ou une erreur selon la gravité. Corrigez le problème et réexécutez jusqu'à ce que ce soit propre.

Vérification et diagnostics

Une fois le pipeline en place, vérifiez que chaque contrôle se comporte comme prévu. Commencez par une image volontairement vulnérable pour confirmer que les analyseurs détectent les problèmes, puis passez à l'application réelle et confirmez un résultat propre.

Test avec une image connue comme mauvaise

Créez un Dockerfile.bad temporaire dans un répertoire de travail :

FROM ubuntu: latest
RUN apt-get update && apt-get install -y curl
USER root

Exécutez chaque analyseur manuellement :

# Hadolint
docker run --rm -i hadolint/hadolint:2.12.0-alpine hadolint - < Dockerfile.bad
# Attendu : plusieurs avertissements, p. ex. DL3007 (étiquette latest), DL3015 (apt install sans -y --no-install-recommends), DL3002 (USER root)

# Construire l'image mauvaise pour Trivy et Dockle
docker build -t bad-image -f Dockerfile.bad .

# Trivy (avec seuil de gravité élevé par défaut)
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:0.45.0 image bad-image
# Attendu : liste de vulnérabilités avec gravité HIGH ou CRITICAL, code de sortie 1

# Dockle
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock goodwithtech/dockle:0.4.14 bad-image
# Attendu : messages FAIL pour des vérifications comme CIS-DI-0005 (éviter l'étiquette latest), CIS-DI-0006 (ajouter HEALTHCHECK), etc., code de sortie 1

Vérifier le résultat propre de l'application réelle

Une fois le Dockerfile de l'application réelle corrigé pour passer les politiques configurées, exécutez les mêmes analyseurs et attendez un code de sortie 0. Par exemple, un Dockerfile bien formé pourrait être :

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
USER node
EXPOSE 3000
CMD ["node", "server.js"]

Exécutez l'analyse Trivy et observez la sortie :

myapp: latest (alpine 3.18.4)
Total: 0 (UNKNOWN: 0, LOW: 0, MEDIUM: 0, HIGH: 0, CRITICAL: 0)

Un résultat de zéro vulnérabilité signifie que l'analyseur a fonctionné avec succès, pas que l'image est parfaitement sécurisée, mais cela confirme que l'outillage est correctement câblé.

Journaux du pipeline et codes de sortie

Dans vos journaux CI, chaque analyse doit se terminer par une réussite ou un échec clair. GitHub Actions affiche une croix rouge en cas d'échec et des annotations telles que Process completed with exit code 1.. Si une analyse est ignorée en raison d'un échec précédent, l'étape de poussée sera ignorée et le pipeline s'arrête. C'est le comportement d'échec rapide souhaité.

Modes de défaillance et récupération

L'automatisation de la sécurité peut échouer pour des raisons sans rapport avec des vulnérabilités réelles. Connaître ces modes de défaillance à l'avance réduit les temps d'arrêt et la frustration.

Modes de défaillance courants

DéfaillanceCause typiqueAction immédiate
Le conteneur d'analyse ne démarre pasProblème réseau pour extraire l'image de l'analyseur ou version d'analyseur invalideRelancer la tâche ; si persistant, épingler une image d'analyseur connue comme bonne et la pré-extraire sur l'exécuteur
Le démon Docker n'est pas disponibleL'exécuteur n'a pas Docker en cours d'exécutionUtiliser une image d'exécuteur avec Docker, ou démarrer le service Docker dans la tâche
L'analyse trouve des vulnérabilitésNouvelle CVE publiée ou dépendance ajoutéeMettre à jour l'image de base ou la dépendance, relancer l'analyse
Mauvaise configuration de la politiqueL'analyseur ignore une vérification ou exige un fichier de configuration manquantValider la syntaxe du fichier de configuration localement, corriger le chemin dans CI
Faux positifL'analyseur signale un paquet non exploitable dans le contexteAjouter une règle d'ignorance avec justification dans le fichier de politique

Étapes de restauration et de récupération

Si une modification du contrôle de sécurité casse le pipeline et bloque les fusions, vous pouvez désactiver temporairement le contrôle défaillant pendant que vous corrigez le problème sous-jacent. Par exemple, pour que Trivy n'échoue que sur les vulnérabilités critiques pendant un incident, modifiez security/trivy.yaml :

severity:
  - CRITICAL

Validez cette modification et le pipeline passera pour les résultats de gravité élevée. Revenez sur la modification une fois l'incident résolu.

Si une mise à jour de version d'analyseur provoque des échecs inattendus, épinglez l'analyseur à la dernière version connue comme fonctionnelle. Dans le workflow, changez aquasec/trivy:0.45.0 par aquasec/trivy:0.44.1 et réessayez.

En cas de défaillance complète du pipeline due à des problèmes d'infrastructure, vous pouvez toujours construire et analyser localement avec les mêmes commandes et pousser manuellement si urgent, mais cela devrait être une exception rare.

Vérification de la récupération

Après tout changement de politique d'analyseur ou d'outillage, vérifiez avec une image connue comme mauvaise que l'analyseur détecte toujours les problèmes pertinents, puis vérifiez que l'application réelle passe. Cette vérification en deux étapes empêche qu'un analyseur soit silencieusement désactivé.

Question rapide 2 sur 2

Selon le passage 1, quelle est une façon d’ajouter une couche de sécurité supplémentaire aux conteneurs Docker ?

Le passage 1 indique : « Vous pouvez ajouter une couche de sécurité supplémentaire en activant AppArmor, SELinux, GRSEC ou un autre système de durcissement approprié. »

Pièges courants et comment les éviter

De nombreuses équipes rencontrent les mêmes obstacles lorsqu'elles automatisent pour la première fois les contrôles de sécurité Docker. En être conscient fait gagner du temps et évite la frustration.

Piège 1 : Exécuter des analyseurs sans versions épinglées

Pourquoi cela arrive : Les équipes utilisent souvent l'étiquette latest pour les images d'analyseurs car c'est pratique. Mais le comportement et les drapeaux des analyseurs peuvent changer entre les versions, provoquant des échecs de pipeline imprévisibles.

Comment l'éviter : Épinglez toujours l'image de l'analyseur à un digest de version spécifique, pas seulement à une étiquette. Par exemple, utilisez aquasec/trivy:0.45.0@sha256:... pour garantir un comportement immuable. Réévaluez le digest mensuellement ou lorsqu'une nouvelle version de l'analyseur est nécessaire.

Piège 2 : Fichiers de politique trop permissifs

Pourquoi cela arrive : Pour réduire les faux positifs, les équipes désactivent parfois trop de vérifications ou abaissent trop les seuils de gravité, ce qui peut masquer des problèmes réels.

Comment l'éviter : Commencez par les valeurs par défaut recommandées de la documentation de l'analyseur. N'ajoutez des règles d'ignorance qu'avec une justification claire dans le commentaire du fichier de politique. Examinez toutes les règles d'ignorance lors de l'audit mensuel et supprimez celles qui ne sont plus nécessaires.

Piège 3 : Ne pas vérifier que les analyseurs détectent réellement les problèmes

Pourquoi cela arrive : Les équipes supposent que si le pipeline passe, les analyseurs fonctionnent. Mais un analyseur mal configuré peut ignorer silencieusement des vérifications.

Comment l'éviter : Périodiquement (au moins mensuellement), exécutez une image connue comme mauvaise dans le pipeline pour confirmer que les analyseurs échouent comme prévu. Cela peut être automatisé avec une tâche CI planifiée qui construit une image volontairement vulnérable et vérifie l'échec.

Piège 4 : Montage de la socket Docker dans CI

Pourquoi cela arrive : Monter la socket Docker dans les conteneurs d'analyseurs est pratique mais donne à l'analyseur un contrôle total sur le démon Docker, ce qui peut être un risque de sécurité dans les environnements CI partagés.

Comment l'éviter : Utilisez un exécuteur CI dédié pour l'analyse de sécurité, ou passez à des analyseurs qui peuvent extraire des images d'un registre après la poussée. Si vous devez utiliser la socket, limitez les capacités du conteneur d'analyseur et exécutez-le avec un utilisateur non root lorsque c'est possible.

Piège 5 : Ignorer les avertissements des analyseurs sur les mises à jour de l'image de base

Pourquoi cela arrive : Les équipes épinglent souvent les images de base à une étiquette spécifique et oublient de les mettre à jour, laissant des vulnérabilités connues non corrigées pendant des mois.

Comment l'éviter : Configurez une tâche CI planifiée (par exemple hebdomadaire) qui construit l'image avec la dernière étiquette de l'image de base et exécute les analyseurs. Si des vulnérabilités sont trouvées, créez un ticket pour mettre à jour l'image de base. Alternativement, utilisez des outils de mise à jour automatique des dépendances comme Renovate ou Dependabot pour garder les images de base à jour.

Liste de contrôle opérationnelle

Utilisez cette liste de contrôle pour la configuration initiale et la révision périodique.

Configuration initiale

  • [ ] Documenter les versions de Docker, de l'exécuteur et des analyseurs dans le README du dépôt ou la documentation.
  • [ ] Ajouter les fichiers de politique de sécurité (hadolint.yaml, trivy.yaml, dockle.config) au dépôt.
  • [ ] Créer le workflow CI avec les étapes de construction, d'analyse et de poussée.
  • [ ] Tester le workflow avec une image volontairement vulnérable pour confirmer les échecs.
  • [ ] Corriger le Dockerfile de l'application pour passer toutes les vérifications.
  • [ ] Vérifier que le pipeline réussit sur une pull request et la branche principale.

Révision hebdomadaire (Propriétaire : champion de la sécurité - par exemple, Alex Chen, ingénieur DevOps)

  • [ ] Examiner la sortie des analyseurs pour les nouvelles vulnérabilités ; trier les résultats élevés et critiques. - Propriétaire : Alex Chen, ingénieur DevOps - Fréquence : chaque lundi matin
  • [ ] Vérifier l'historique des exécutions du pipeline pour les échecs intermittents. - Propriétaire : Alex Chen, ingénieur DevOps - Fréquence : chaque lundi matin
  • [ ] Mettre à jour les versions des analyseurs vers la dernière version stable (tester localement d'abord). - Propriétaire : Alex Chen, ingénieur DevOps - Fréquence : chaque lundi matin, mais seulement si les tests locaux passent
  • [ ] Examiner les exceptions de politique ; supprimer celles qui ne sont plus nécessaires. - Propriétaire : Alex Chen, ingénieur DevOps - Fréquence : chaque lundi matin

Audit mensuel (Propriétaire : responsable de la sécurité de la plateforme - par exemple, Maria Rodriguez, responsable de l'ingénierie de la sécurité)

  • [ ] Réexécuter toute la suite de sécurité sur une image historique aléatoire du registre pour s'assurer que les analyseurs détectent toujours les problèmes connus. - Propriétaire : Maria Rodriguez, responsable de l'ingénierie de la sécurité - Fréquence : premier lundi de chaque mois
  • [ ] Faire tourner les identifiants du registre. - Propriétaire : Maria Rodriguez, responsable de l'ingénierie de la sécurité - Fréquence : premier lundi de chaque mois
  • [ ] Valider que le workflow CI n'a pas été modifié sans révision. - Propriétaire : Maria Rodriguez, responsable de l'ingénierie de la sécurité - Fréquence : premier lundi de chaque mois

Conclusion

Automatiser les contrôles de sécurité Docker dans les pipelines CI/CD est une première étape gérable vers une chaîne d'approvisionnement plus sûre. En inventoriant l'environnement, en commençant par un ensemble restreint d'analyseurs, en vérifiant la détection avec une image mauvaise et en se préparant aux défaillances courantes, vous pouvez intégrer la sécurité dans chaque construction sans ralentir le développement. Les exemples de ce guide utilisent des outils gratuits et une reproductibilité locale, vous pouvez donc mettre en œuvre le processus en un après-midi et l'étendre plus tard avec des politiques supplémentaires, la signature ou le contrôle d'admission. N'oubliez pas de garder la boucle de rétroaction rapide et les politiques claires ; un pipeline de sécurité auquel les développeurs font confiance et qu'ils comprennent est celui qui sera utilisé.

Recherches connexes

Score de qualité de l’article

Utilité pour le lecteur 97%
  • check_circle Guide prêt à lire
  • check_circle Exemples pratiques inclus
  • check_circle URL d’article optimisée pour le SEO