Illustration du trio Docker, SonarQube et Hadolint montrant Hadolint qui analyse un Dockerfile et publie les résultats dans Sonarqube

Analysez la qualité de vos Dockerfiles avec SonarQube

SonarQube est une plateforme open-source de contrôle de la qualité du code qui permet d’analyser et de mesurer la qualité de divers langages de programmation. Il aide à détecter les bogues, les vulnérabilités et les mauvaises pratiques de codage. Dans le cadre de l’industrialisation des projets informatiques, cet outil s’avère très utile pour maintenir un code source propre et sécurisé, notamment en intégrant l’analyse de code dans les pipelines CI/CD.
Si SonarQube supporte déjà de nombreux langages de programmation par défaut, il reste incapable d’analyser les fichiers Dockerfiles. Alors, comment peut-on analyser un Dockerfile et centraliser les résultats dans SonarQube ?

Analyser statiquement un Dockerfile avec Hadolint

Hadolint est un outil de linting open-source qui détecte les erreurs et les mauvaises pratiques spécifiques aux Dockerfiles. Largement adopté par la communauté informatique, Hadolint est si pertinent que le CNES a développé un plugin SonarQube pour analyser et centraliser les résultats de ses analyses.

Hadolint peut être installé localement pour analyser les Dockerfiles avant de les committer, ou être intégré à un éditeur de texte comme VS Code via une extension. De plus, l’image Docker officielle de Hadolint permet de réaliser des analyses directement dans votre pipeline CI/CD préféré, permettant ainsi son automatisation.

Configurer son projet pour utiliser le sonar-hadolint-plugin

Par défaut, ce plugin est configuré pour analyser un unique fichier Dockerfile et extraire le résultat de l’analyse depuis l’unique fichier hadolint-report.xml, tout deux présents à la racine du projet lors de l’analyse du projet avec sonar-scanner.

Si votre dépôt contient plusieurs Dockerfiles, comme c’est souvent le cas pour les projets mono-repo, vous devrez réaliser plusieurs analyses Hadolint et référencer l’ensemble des fichiers Dockerfile et hadolint-report.xml dans votre sonar-project.properties.

Dans ce cas, la configuration suivante pourrait probablement convenir :

# /sonar-project.properties
# ...

# Docker
sonar.lang.patterns.dockerfile=**/Dockerfile
sonar.hadolint.reports.path=**/hadolint-report.xml

Dans un pipeline Jenkins, vous pourriez ajouter le stage et instructions suivantes pour analyser vos Dockerfiles :

// ...
    stage ("Pre analyse") {
      agent {
        docker {
          image 'hadolint/hadolint:latest-debian'
        }
      }
      steps {
        unstash 'sources' <1>

        sh """
        find -type f -name Dockerfile | while read -r path; do
          hadolint --no-fail --format checkstyle "\$path" > "\$(dirname "\$path")/hadolint-report.xml"
        done
        """ <2>

        stash includes: '**/hadolint-report.xml', name: 'hadolint' , useDefaultExcludes: false
      }
    }
    stage ("Analyse Sonarqube") {
      agent {
        docker {
          image 'sonarsource/sonar-scanner-cli'
        }
      }
      steps {
        unstash 'sources'
        unstash 'hadolint'

        // ...
      }
    }
// ...
1

Ce stash contient le code source récupéré depuis le dépôt distant hébergeant le code source de l’application.

2

Cette instruction sh permet d’automatiser la génération des rapports Hadolint au format XML.

La combinaison de ce code et de la configuration permet au sonar-scanner d’extraire le résultat de l’analyse grâce au sonar-hadolint-plugin.

Utiliser un format de rapport générique

Rapport générique Hadolint compatible avec SonarQube

SonarQube permet d’élargir la détection de problèmes en fournissant un ou des fichiers de rapport génériques au format JSON (voir la documentation officielle pour plus de détails).

Hadolint a été amélioré pour pouvoir produire un fichier au format JSON qui respecte ce format générique. Lorsque le plugin ne peut pas être installé (version serveur incompatible, politique de sécurité, etc.), ce format de sortie est une excellente alternative pour continuer à centraliser les résultats de l’analyse dans SonarQube.

Configuration du pipeline CI/CD

Reprenons l’exemple précédent et adaptons le pour utiliser les fichiers de rapport génériques. Commençons par le fichier de configuration du sonar-scanner :

 # /sonar-project.properties
 # ...
-
-# Docker
-sonar.lang.patterns.dockerfile=**/Dockerfile
-sonar.hadolint.reports.path=**/hadolint-report.xml

Poursuivons avec la modification du pipeline :

 // ...
     stage ("Pre analyse") {
 // ...
         sh """
         find -type f -name Dockerfile | while read -r path; do
-          hadolint --no-fail --format checkstyle "\$path" > "\$(dirname "\$path")/hadolint-report.xml"
+          hadolint --no-fail --format sonarqube "\$path" > "\$(dirname "\$path")/hadolint-report.json"
         done
         """

-        stash includes: '**/hadolint-report.xml', name: 'hadolint' , useDefaultExcludes: false
+        stash includes: '**/hadolint-report.json', name: 'hadolint' , useDefaultExcludes: false
       }
     }
     stage ("Analyse Sonarqube") {
 // ...
         sh """
+        reports=\$(find -type f -name hadolint-report.json | tr '\\n' ',' | sed -r 's/,\$//') <1>
+
         sonar-scanner -Dsonar.host.url=${SONAR_URL} \
-          -Dsonar.login='${SONAR_USERNAME}' -Dsonar.password='${SONAR_PASSWORD}'
+          -Dsonar.login='${SONAR_USERNAME}' -Dsonar.password='${SONAR_PASSWORD}' \
+           -Dsonar.externalIssuesReportPaths="\${reports}" <2>
         """
       }
     }
 // ...
1

Cette commande permet de créer une liste de rapport séparée par des , comme ./relative/path1,./relative/path2.

2

Nous passons la liste des rapports en paramètre de la ligne de commande sonar-scanner. Il est alternativement possible de le renseigner dans le fichier sonar-project.properties si vous préférez. Cependant, pour un mono-repo cette option est calculée dynamiquement.

Notre exemple est maintenant adapté est opérationnel ! Si vous essayez sur votre propre projet, les issues détectées devraient porter l’étiquette HADOLINT.

Conclusion

En interfaçant Hadolint avec SonarQube, vous pouvez améliorer significativement la qualité et la sécurité de vos Dockerfiles. Cette combinaison permet de détecter et de corriger les erreurs et les mauvaises pratiques spécifiques aux Dockerfiles, tout en centralisant les résultats dans une plateforme unique. Pour cela, deux solutions s’offrent à vous :

  • Utiliser le sonar-hadolint-plugin.
  • Générer un rapport générique au format JSON.

Ces outils sont entièrement compatibles avec vos pipelines CI/CD, garantissant ainsi une détection précoce des problèmes. Cette approche améliore la maintenabilité de vos projets en respectant les standards de qualité du code.

N’hésitez pas à explorer davantage les capacités de SonarQube et Hadolint. Ces solutions peuvent réellement vous aider à améliorer la qualité de vos prestations.

Laisser un commentaire