Dockerfile: lint y formateo en línea (Hadolint)

Dockerfile: lint y formateo en línea (Hadolint)

Detecta anti-patrones Docker (usuario root, capas de cache, tags `latest`) y formatea tus Dockerfiles antes de la CI.

14.07.2026
10 min de lectura
Compartir este artículo:
docker
dockerfile
hadolint
DevOps
lint
containers
Tutorial

¿Por qué lintear y formatear un Dockerfile antes de la CI?

Un Dockerfile construye tus imágenes capa a capa. Una instrucción `USER root` olvidada, un tag `latest` o `RUN` en cascada inflan la imagen, ralentizan la caché BuildKit y hacen fallar Hadolint en el pipeline — a menudo demasiado tarde. Formatear y lintear antes de abrir la PR reduce el ruido de CI y alinea al equipo en las mismas convenciones. En FastMinify puedes lintear un Dockerfile en línea (reglas DL estilo Hadolint) y formatear un Dockerfile en línea — 100 % en el navegador. El cluster completo está en el hub de herramientas DevOps, junto a Terraform, Compose y `.env`.

Anti-patterns Docker detectados antes del job Hadolint de la CI
Diffs de PR más limpios gracias a mayúsculas y espaciado normalizados
Flujo rápido para pegar un Dockerfile recibido fuera del monorepo
Complemento útil de Hadolint / dockerfile-utils en local
El mismo hub que HCL, Compose y validación `.env`

Reglas DL frecuentes y flujo antes de la PR

Anti-patterns que el lint suele pillar

Algunos códigos vuelven en casi todos los equipos. Corregirlos pronto evita un muro de warnings Hadolint en CI.

DL3007 — fija un tag o un digest, evita `FROM …:latest`
DL3002 — último USER no root (salvo caso justificado documentado)
DL3020 — prefiere COPY a ADD para archivos locales
DL3059 — fusiona los RUN consecutivos para limitar las capas
DL3008 / DL3013 — fija las versiones apt / pip cuando tiene sentido
Equipo y CI

Fija Hadolint (versión de imagen o binario) y haz fallar el pipeline en los niveles del equipo. El navegador sigue siendo un filtro rápido fuera del monorepo.

Ejecutar Hadolint en cada PR que toque un Dockerfile
Documentar los ignore excepcionales (`.hadolint.yaml`) en la PR
Formatear antes de lintear para mensajes más claros
Enlazar el IaC Terraform / HCL del mismo repo vía la guía Terraform y HCL en línea
Automatizar los assets front en el mismo pipeline — ver minificación en CI/CD
Recorrer el hub DevOps FastMinify para Compose y `.env`

Lint vs format vs build

Elegir la acción correcta

Format, lint y `docker build` se complementan. En revisión, formatea, lintea y deja que la CI construya.

Objetivo

format:Legibilidad y diffs estables
validate:Buenas prácticas DL (estilo Hadolint)
minify:Imagen real + caché BuildKit

Cuándo usarlo

format:Tras edición manual / conflicto
validate:Antes de cada PR Dockerfile
minify:En CI o en un workspace de prueba
Orden recomendado

Una secuencia simple evita corregir el estilo después del lint en bucle.

Escribir o pegar el Dockerfile
Formatear para estabilizar mayúsculas y espaciado
Lintear (navegador y después Hadolint CLI si es posible)
Validar Compose / `.env` asociados si hace falta
Lanzar `docker build` (o buildx) en un entorno de prueba

Cuándo basta la herramienta del navegador

Casos de uso frecuentes

No hace falta clonar el monorepo para corregir tres instrucciones recibidas en Slack.

Reformatear un Dockerfile pegado desde un ticket
Comprobar las DL antes de abrir una PR desde un portátil sin Hadolint
Preparar un ejemplo pedagógico o un gist público
Comparar rápido dos versiones después de un conflicto de merge
Revisión exprés de un Dockerfile vendor / template

Límites: lo que el navegador no sustituye

Hadolint CLI y el build real

En cuanto debas aplicar la config del equipo (ignores, severity), escanear el shell en RUN o construir multi-stage con secretos BuildKit, el CLI y la CI siguen siendo obligatorios.

Hadolint con `.hadolint.yaml` y políticas de ignore
ShellCheck / análisis avanzado de scripts en RUN
`docker build` / buildx con caché y secretos montados
Scan CVE de imagen (Trivy, Grype…) fuera del alcance del lint DL
Credenciales de registro: solo vía secretos de CI, nunca pegadas en línea
Archivos vecinos

Un servicio suele llegar con Compose, `.env` y HCL. Format/lint Dockerfile + validate Compose/env + format Terraform cubren el recorrido DevOps diario.

Validar Compose antes de `compose up`
Validar `.env` para errores de sintaxis
Formatear / validar el HCL Terraform asociado
Mantener una convención de indentación común en el repositorio
Tratar el Dockerfile formateado como fuente Git, no el ruido de logs de build

CLI y ecosistema

Herramientas de referencia en local

Hadolint y dockerfile-utils siguen siendo el estándar en empresa. Las herramientas FastMinify son un complemento para la exploración y los one-shots.

Hadolint

Linter Dockerfile de referencia con reglas DL e integración CI.

Ventajas:
Ecosistema maduro e IDs DL documentados
Config `.hadolint.yaml` para las políticas de equipo
Imagen Docker / binario / action GitHub
Inconvenientes:
Hay que instalarlo o embarcarlo en CI
Menos práctico para un snippet fuera del repo

dockerfile-utils / formatters

Normalización de estilo (mayúsculas, espaciado) en el editor o CLI.

Ventajas:
Diffs estables en revisión
Completa el lint sin cambiar el build
Integrable en pre-commit
Inconvenientes:
No sustituye las reglas DL
Variantes de herramientas según el editor

BuildKit / buildx

Motor de build moderno: caché, multi-platform, secretos.

Ventajas:
Builds más rápidos y reproducibles
Secretos sin grabarlos en una capa
Estándar Docker actual
Inconvenientes:
Fuera del alcance de un linter de texto
Requiere un daemon / CI configurado

Anatomía de un Dockerfile: instrucciones y capas

Instrucciones habituales

Un Dockerfile es una secuencia de instrucciones (`FROM`, `RUN`, `COPY`, `WORKDIR`, `USER`, `CMD`…). Cada instrucción que muta el sistema de archivos crea una capa. El orden cuenta para la caché: los cambios frecuentes (código de la app) deben llegar después de las capas estables (dependencias OS). Para el YAML vecino (`compose.yml`), valida la estructura antes de `docker compose up`.

FROM fija una base (image:tag o digest) — evita `latest` en prod
RUN suele combinar apt/apk + limpieza en una misma capa
COPY mejor que ADD para archivos locales simples
USER no root al final del archivo para limitar la superficie de ataque
CMD / ENTRYPOINT en forma JSON exec (`["node", "app.js"]`)
Lo que el lint del navegador no sustituye

El linter FastMinify aplica un subconjunto documentado de reglas DL Hadolint (identificadores wiki). No lanza ShellCheck en cada `RUN`, no construye la imagen y no comprueba el registro remoto. En CI, Hadolint CLI (o la action de GitHub) sigue siendo la referencia del equipo.

Sin análisis ShellCheck completo de los scripts shell en RUN
Sin `docker build` ni scan CVE de imagen
Sin validación del esquema Compose en esta herramienta (otra página)
Útil como primer filtro DL + format; la CI sigue siendo la fuente de verdad
Nunca pegues secretos / tokens en un textarea público

Lint y format: dos intenciones distintas

Linter (reglas DL estilo Hadolint)

El linter reporta issues con código DL (p. ej. DL3007 para `latest`, DL3002 para usuario root final) y enlaces al wiki Hadolint. Ideal para pegar un Dockerfile y corregir antes de la PR. Prueba el linter Dockerfile en línea.

IDs DL alineados con Hadolint para mensajes accionables
Niveles warning / info según la regla
Enlaces al wiki Hadolint para profundizar en cada código
Perfecto para un extracto o un Dockerfile mono-stage
No sustituye Hadolint CLI + políticas de equipo en CI
Formatear (normalización dockerfile-utils)

El formateador normaliza las mayúsculas de las instrucciones y el espaciado para diffs estables — sin cambiar la semántica del build. Usa el formateador Dockerfile en línea antes de commitear un archivo retocado a mano.

Instrucciones en mayúsculas coherentes
Espaciado y alineación normalizados
Ideal después de un conflicto de merge en el Dockerfile
Complemento del lint: format primero, después lint
Acoplar en el repo con un formateo local o un gate de CI
Compose y `.env` del mismo proyecto

El Dockerfile rara vez vive solo. Valida también Docker Compose en línea y los archivos `.env` antes de un deploy local.

Estructura Compose (services, image) — no la spec completa
Sintaxis `.env` sin scan avanzado de secretos
El mismo hub DevOps para un recorrido único
Útil antes de `docker compose up` en una máquina nueva
Mantén los secretos fuera del repositorio y fuera de las herramientas en línea

Conclusión

Lintear y formatear un Dockerfile antes de la CI evita idas y vueltas innecesarias sobre las reglas DL y el estilo. Usa el navegador para snippets y el primer filtro estilo Hadolint, y después Hadolint CLI y `docker build` para la verdad del pipeline. Encadena con Compose, `.env` y Terraform en el mismo hub DevOps.

Formatear antes de lintear para diffs y mensajes claros
Corregir DL3007 / DL3002 / DL3020 pronto en la revisión
Fijar Hadolint y hacer fallar la CI según la política del equipo
Validar Compose y `.env` del mismo servicio
Nunca pegar secretos en una herramienta en línea
Compartir este artículo
Compartir este artículo: