Dockerfile : linter et formater votre Dockerfile en ligne (Hadolint)

Dockerfile : linter et formater votre Dockerfile en ligne (Hadolint)

Détectez les anti-patterns Docker (root user, cache layers, tags `latest`) et formatez vos Dockerfiles avant la CI.

14.07.2026
10 min de lecture
Partager cet article:
docker
dockerfile
hadolint
DevOps
lint
containers
Tutoriel

Pourquoi lint et formater un Dockerfile avant la CI ?

Un Dockerfile compile vos images couche par couche. Une instruction `USER root` oubliée, un tag `latest` ou des `RUN` en cascade gonflent l'image, ralentissent le cache BuildKit et font échouer Hadolint en pipeline — souvent trop tard. Formater et linter avant d'ouvrir la PR réduit le bruit CI et aligne l'équipe sur les mêmes conventions. Sur FastMinify, vous pouvez linter un Dockerfile en ligne (règles DL style Hadolint) et formater un Dockerfile en ligne — 100 % dans le navigateur. Le cluster complet est sur le hub d'outils DevOps, à côté de Terraform, Compose et `.env`.

Anti-patterns Docker détectés avant le job Hadolint de la CI
Diffs de PR plus propres grâce à une casse et un espacement normalisés
Workflow rapide pour coller un Dockerfile reçu hors monorepo
Complément utile à Hadolint / dockerfile-utils en local
Même hub que HCL, Compose et validation `.env`

Règles DL fréquentes et workflow avant PR

Anti-patterns que le lint attrape souvent

Quelques codes reviennent dans presque toutes les équipes. Les corriger tôt évite un wall of warnings Hadolint en CI.

DL3007 — pinne un tag ou un digest, évite `FROM …:latest`
DL3002 — dernier USER non-root (sauf cas justeifié documenté)
DL3020 — préfère COPY à ADD pour des fichiers locaux
DL3059 — fusionne les RUN consécutifs pour limiter les couches
DL3008 / DL3013 — pinne les versions apt / pip quand c'est pertinent
Équipe et CI

Verrouillez Hadolint (version d'image ou binaire) et faites échouer la pipeline sur les niveaux d'équipe. Le navigateur reste un filtre rapide hors monorepo.

Exécuter Hadolint sur chaque PR qui touche un Dockerfile
Documenter les ignore exceptionnels (`.hadolint.yaml`) dans la PR
Formater avant de lint pour des messages plus clairs
Relier l'IaC Terraform / HCL du même repo via le guide Terraform et HCL en ligne
Automatiser les assets front dans la même pipeline — voir minification en CI/CD
Parcourir le hub DevOps FastMinify pour Compose et `.env`

Lint vs format vs build

Choisir la bonne action

Format, lint et `docker build` se complètent. En revue, formatez, lintez, puis laissez la CI construire.

Objectif

format:Lisibilité et diffs stables
validate:Bonnes pratiques DL (Hadolint-style)
minify:Image réelle + cache BuildKit

Quand l'utiliser

format:Après édition manuelle / conflit
validate:Avant chaque PR Dockerfile
minify:En CI ou sur un workspace de test
Ordre recommandé

Un enchaînement simple évite de corriger le style après le lint en boucle.

Écrire ou coller le Dockerfile
Formater pour stabiliser casse et espacement
Linter (navigateur puis Hadolint CLI si possible)
Valider Compose / `.env` associés si besoin
Lancer `docker build` (ou buildx) sur un environnement de test

Quand l'outil navigateur suffit

Cas d'usage fréquents

Pas besoin de cloner le monorepo pour corriger trois instructions reçues sur Slack.

Reformater un Dockerfile collé depuis un ticket
Vérifier les DL avant d'ouvrir une PR depuis un laptop sans Hadolint
Préparer un exemple pédagogique ou un gist public
Comparer rapidement deux versions après un conflit de merge
Revue express d'un Dockerfile vendor / template

Limites : ce que le navigateur ne remplace pas

Hadolint CLI et le build réel

Dès que vous devez appliquer la config d'équipe (ignores, severity), scanner le shell dans RUN, ou construire multi-stage avec secrets BuildKit, le CLI et la CI restent obligatoires.

Hadolint avec `.hadolint.yaml` et politiques d'ignore
ShellCheck / analyse poussée des scripts dans RUN
`docker build` / buildx avec cache et secrets montés
Scan CVE d'image (Trivy, Grype…) hors scope du lint DL
Credentials registry : uniquement via CI secrets, jamais collés en ligne
Fichiers voisins

Un service arrive souvent avec Compose, `.env` et du HCL. Format/lint Dockerfile + validate Compose/env + format Terraform couvrent le parcours DevOps quotidien.

Valider Compose avant `compose up`
Valider `.env` pour les erreurs de syntaxe
Formater / valider le HCL Terraform associé
Garder une convention d'indentation commune dans le dépôt
Traiter le Dockerfile formaté comme source Git, pas le bruit de build logs

CLI et écosystème

Outils de référence en local

Hadolint et dockerfile-utils restent le standard en entreprise. Les outils FastMinify sont un complément pour l'exploration et les one-shots.

Hadolint

Linter Dockerfile de référence avec règles DL et intégration CI.

Avantages :
Écosystème mature et IDs DL documentés
Config `.hadolint.yaml` pour les politiques d'équipe
Image Docker / binaire / action GitHub
Inconvénients :
À installer ou à embarquer en CI
Moins pratique pour un snippet hors repo

dockerfile-utils / formatters

Normalisation de style (casse, espacement) côté éditeur ou CLI.

Avantages :
Diffs stables en revue
Complète le lint sans changer le build
Intégrable en pre-commit
Inconvénients :
Ne remplace pas les règles DL
Variants d'outils selon l'éditeur

BuildKit / buildx

Moteur de build moderne : cache, multi-platform, secrets.

Avantages :
Builds plus rapides et reproductibles
Secrets sans les graver dans une couche
Standard Docker actuel
Inconvénients :
Hors scope d'un linter texte
Demande un daemon / CI configuré

Anatomie d'un Dockerfile : instructions et couches

Instructions courantes

Un Dockerfile est une séquence d'instructions (`FROM`, `RUN`, `COPY`, `WORKDIR`, `USER`, `CMD`…). Chaque instruction qui mute le système de fichiers crée une couche. L'ordre compte pour le cache : les changements fréquents (code app) doivent arriver après les couches stables (dépendances OS). Pour le YAML voisin (`compose.yml`), validez la structure avant `docker compose up`.

FROM pinne une base (image:tag ou digest) — évitez `latest` en prod
RUN combine souvent apt/apk + nettoyage dans une même couche
COPY plutôt que ADD pour des fichiers locaux simples
USER non-root en fin de fichier pour limiter la surface d'attaque
CMD / ENTRYPOINT en forme JSON exec (`["node", "app.js"]`)
Ce que le lint navigateur ne remplace pas

Le linter FastMinify applique un <strong>sous-ensemble documenté</strong> de règles DL Hadolint (identifiants wiki). Il ne lance pas ShellCheck dans chaque `RUN`, ne construit pas l'image, et ne vérifie pas le registre distant. En CI, Hadolint CLI (ou l'action GitHub) reste la référence d'équipe.

Pas d'analyse ShellCheck complète des scripts shell dans RUN
Pas de `docker build` ni de scan CVE d'image
Pas de validation du schéma Compose dans cet outil (autre page)
Utile pour un premier filtre DL + format ; la CI reste la source de vérité
Ne jamais coller de secrets / tokens dans un textarea public

Lint et format : deux intentions distinctes

Linter (règles DL style Hadolint)

Le linter remonte des issues avec code DL (ex. DL3007 pour `latest`, DL3002 pour utilisateur root final) et liens vers le wiki Hadolint. Idéal pour coller un Dockerfile et corriger avant la PR. Essayez le linter Dockerfile en ligne.

IDs DL alignés sur Hadolint pour des messages actionnables
Niveaux warning / info selon la règle
Liens wiki Hadolint pour approfondir chaque code
Parfait pour un extrait ou un Dockerfile mono-stage
Ne remplace pas Hadolint CLI + politiques d'équipe en CI
Formater (normalisation dockerfile-utils)

Le formateur normalise la casse des instructions et l'espacement pour des diffs stables — sans changer la sémantique du build. Utilisez le formateur Dockerfile en ligne avant de committer un fichier retouché à la main.

Instructions en majuscules cohérentes
Espacement et alignement normalisés
Idéal après un merge conflict sur le Dockerfile
Complément du lint : format d'abord, puis lint
À coupler en repo avec un formatage local ou un gate CI
Compose et `.env` du même projet

Le Dockerfile ne vit rarement seul. Validez aussi Docker Compose en ligne et les fichiers `.env` avant un deploy local.

Structure Compose (services, image) — pas la spec complète
Syntaxe `.env` sans scan secrets avancé
Même hub DevOps pour un parcours unique
Utile avant `docker compose up` sur une machine neuve
Garder les secrets hors du dépôt et hors des outils en ligne

Conclusion

Linter et formater un Dockerfile avant la CI évite des allers-retours inutiles sur les règles DL et le style. Utilisez le navigateur pour les snippets et le premier filtre Hadolint-style, puis Hadolint CLI et `docker build` pour la vérité pipeline. Enchaînez avec Compose, `.env` et Terraform sur le même hub DevOps.

Lintez ou formatez votre Dockerfile maintenant

Formater avant de lint pour des diffs et messages clairs
Corriger DL3007 / DL3002 / DL3020 tôt dans la revue
Épingler Hadolint et échouer la CI sur la politique d'équipe
Valider Compose et `.env` du même service
Ne jamais coller de secrets dans un outil en ligne
Partager cet article
Partager cet article: