Validar Docker Compose y archivos `.env` en línea

Validar Docker Compose y archivos `.env` en línea

Revisa la estructura de tus `compose.yml` y `.env` antes de `docker compose up` — validación local en el navegador, sin instalar herramientas.

16.07.2026
9 min de lectura
Compartir este artículo:
docker-compose
env
DevOps
Validación
yaml
Tutorial

¿Por qué validar Compose y `.env` antes del deploy?

Un `docker compose up` que falla por una clave `services` mal indentada o una línea `.env` sin `=` hace perder tiempo en una máquina nueva, en CI o durante un onboarding. Un control rápido de la estructura antes de lanzar la stack pilla los typos evidentes antes de que Docker se queje. En FastMinify puedes validar un archivo Docker Compose en línea y validar un archivo `.env` en línea — 100 % en el navegador, sin instalar Docker ni Node. El cluster completo está en el hub de herramientas DevOps, junto a Terraform, Dockerfile y HCL.

Errores de estructura Compose pillados antes de `docker compose up`
Líneas `.env` inválidas (sin `=`, clave ilegal) detectadas pronto
Claves duplicadas y comillas sin cerrar señaladas en el `.env`
Alerta cuando una clave parece un secreto (`SECRET`, `TOKEN`…)
El mismo hub que Dockerfile, Terraform y HCL

Errores frecuentes y flujo antes del deploy

Lo que la validación suele pillar

Algunos fallos vuelven una y otra vez. Corregirlos antes de `docker compose up` evita mensajes Docker crípticos.

Indentación YAML incoherente bajo `services` (error de parse)
`services` escrito como lista en lugar de mapping
Servicio sin `image` ni `build` — nada que arrancar
Línea `.env` sin `=` (a menudo un comentario sin `#`)
Clave `.env` duplicada: el último valor pisa al anterior
Secretos y buenas prácticas `.env`

El validador señala las claves que parecen secretos (`PASSWORD`, `API_KEY`, `SECRET`, `TOKEN`), pero es solo un recordatorio — no un scan de secretos. La disciplina real sigue siendo no commitear los `.env`.

Añadir `.env` al `.gitignore` y commitear un `.env.example` sin valores
Citar los valores que contienen espacios o caracteres especiales
Usar secretos Docker / el gestor de la plataforma en prod
Enlazar el Dockerfile del servicio vía la guía lint y format Dockerfile en línea
Formatear y validar el IaC asociado — ver Terraform y HCL en línea
Recorrer el hub DevOps FastMinify para todo el cluster

Compose vs `.env`: dos intenciones

Elegir el validador correcto

Compose y `.env` se complementan: uno describe la stack, el otro inyecta la config. En revisión, valida ambos antes de lanzar la stack.

Qué se comprueba

format:Compose: YAML + `services` + image/build
validate:`.env`: líneas KEY=VALUE, claves, comillas
minify:`docker compose config`: render real

Cuándo usarlo

format:Antes de `docker compose up`
validate:Antes de compartir o cargar un `.env`
minify:En CI o en un entorno de prueba
Orden recomendado

Una secuencia simple evita descubrir los errores en el momento del deploy.

Validar el `.env` (sintaxis de las variables)
Validar el `compose.yml` (estructura de los servicios)
Comprobar el Dockerfile referenciado por un `build:`
Lanzar `docker compose config` para el render final
Después `docker compose up` en un entorno de prueba

Cuándo basta la herramienta del navegador

Casos de uso frecuentes

No hace falta tener Docker instalado para comprobar tres errores en un `compose.yml` recibido por mensaje.

Comprobar un `compose.yml` pegado desde un ticket o un README
Validar un `.env` antes de compartirlo con un compañero
Preparar un ejemplo pedagógico o un gist público
Desbloquear un `docker compose up` que falla en una máquina nueva
Revisión exprés de una config Compose vendor / template

Límites: lo que el navegador no sustituye

`docker compose config` y el runtime real

En cuanto debas resolver la interpolación `${VAR}`, fusionar varios archivos Compose (`-f`) o comprobar que una imagen existe, la CLI Docker y el demonio siguen siendo obligatorios.

`docker compose config` para el render final con variables resueltas
Merge de varios archivos (`compose.yml` + `compose.override.yml`)
Comprobar la disponibilidad de las imágenes en el registro
Probar redes, volúmenes y dependencias entre servicios
Secretos: gestor de la plataforma / Docker secrets, nunca en línea
Archivos vecinos

Un servicio suele llegar con un Dockerfile, HCL Terraform y un `.env`. Validar Compose y `.env` + lintear el Dockerfile + formatear el HCL cubre el recorrido DevOps diario.

Validar el `.env` antes del `compose.yml`
Lintear el Dockerfile referenciado por un `build:`
Formatear / validar el HCL Terraform asociado
Mantener una convención de indentación común en el repositorio
Tratar la config como fuente Git, versionada y revisada

CLI y ecosistema

Herramientas de referencia en local

La CLI Docker y algunos linters siguen siendo el estándar. Las herramientas FastMinify son un complemento rápido para la exploración y los one-shots.

docker compose config

Renderiza el archivo final con variables resueltas y señala errores de spec.

Ventajas:
Resuelve la interpolación `${VAR}` desde el `.env`
Fusiona los archivos `-f` y los overrides
Referencia oficial de la spec Compose
Inconvenientes:
Requiere Docker instalado
Menos práctico para un snippet fuera del repo

dotenv-linter

Linter `.env` rápido (Rust) con reglas sobre claves y valores.

Ventajas:
Detecta duplicados, claves sin ordenar, valores sospechosos
Integrable en pre-commit y en CI
Corrige automáticamente algunos problemas
Inconvenientes:
Hay que instalarlo en local
No valida el archivo Compose

yamllint

Linter YAML genérico útil para indentación y estilo.

Ventajas:
Reglas de indentación y estilo configurables
Útil más allá de Compose (CI, K8s…)
Integración en editor y pre-commit
Inconvenientes:
No conoce la semántica Compose
Configuración a mantener por equipo

Anatomía de un `compose.yml` y de un `.env`

Estructura de un archivo Compose

Un archivo Compose moderno es un único documento YAML con una clave raíz `services` obligatoria. Cada servicio debería declarar una `image` o un bloque `build`. Las demás claves raíz esperadas son `networks`, `volumes`, `secrets`, `configs`, `name` y la histórica `version`. La clave `version` es ahora opcional en la spec Compose actual, pero sigue tolerada.

Raíz = un solo documento YAML (sin separadores `---` múltiples)
`services` obligatorio y en forma de mapping (no una lista)
Cada servicio: `image:` o `build:` para poder arrancarlo
Claves raíz conocidas: services, networks, volumes, secrets, configs, name, version
La indentación YAML lo es todo: dos espacios coherentes, nunca tabulaciones
Estructura de un archivo `.env`

Un `.env` es una lista de pares `KEY=VALUE`, uno por línea. Las líneas vacías y los comentarios (`#`) se ignoran, y el prefijo `export ` se tolera. Los nombres de clave siguen la convención shell (letras, cifras, underscore, sin empezar por un dígito). Un valor con espacios debe ir entre comillas para evitar sorpresas.

Un par `KEY=VALUE` por línea, sin `=` = línea inválida
Comentarios `#` y líneas vacías ignorados
Clave válida: `^[A-Za-z_][A-Za-z0-9_]*$` (sin espacio ni guion)
Comillas `"` o `'` a cerrar; valor con espacios a citar
`export FOO=bar` aceptado, pero Compose solo lee `FOO=bar`
Lo que la validación del navegador no sustituye

Estos dos validadores hacen controles estructurales, no una validación completa de la spec Compose ni un scan de secretos. No resuelven la interpolación de variables (`${VAR}`), no comprueban que una imagen exista en un registro y no lanzan `docker compose up`. Para la verdad runtime, `docker compose config` y el demonio Docker siguen siendo la referencia.

Sin validación del esquema Compose completo (tipos de cada campo)
Sin resolución de `${VARIABLE}` entre `.env` y `compose.yml`
Sin scan avanzado de secretos — solo un patrón de nombre de clave
Sin conexión a un registro ni `docker build`
Nunca pegues secretos reales en un textarea público

Dos validaciones: Compose y `.env`

Validar Docker Compose (estructura YAML)

El validador parsea el YAML, comprueba que hay un solo documento, una raíz de tipo mapping y una clave `services`. Señala los servicios sin `image` ni `build` y las claves raíz desconocidas. Prueba el validador Docker Compose en línea.

Error YAML localizado en la línea incorrecta
Error si falta `services` o no es un mapping
Advertencia si un servicio no tiene `image` ni `build`
Info sobre las claves raíz fuera de la lista conocida
Control estructural — no la spec Compose completa
Validar un archivo `.env` (parser KEY=VALUE)

El validador `.env` lee cada línea, reporta las que no tienen `=` o tienen una clave ilegal, detecta comillas sin cerrar, claves duplicadas y valores sin citar que contienen espacios. Usa el validador `.env` en línea antes de compartir un archivo de ejemplo.

Línea sin `=` → error `KEY=VALUE` esperado
Clave inválida (espacio, guion, dígito inicial) → error
Comilla sin cerrar → error
Clave duplicada → advertencia con la línea de origen
Espacios en un valor no citado → advertencia
Dockerfile y Terraform del mismo proyecto

Un servicio rara vez llega solo. Encadena con el linter Dockerfile en línea y el formateador Terraform / HCL en línea para cubrir toda la config de infra.

Lintear y formatear el Dockerfile del mismo servicio
Formatear y validar el HCL Terraform asociado
El mismo hub DevOps para un recorrido único
Útil antes de un primer `docker compose up` local
Mantén los secretos fuera del repositorio y fuera de las herramientas en línea

Conclusión

Validar la estructura de tus `compose.yml` y `.env` antes de `docker compose up` evita fallos de deploy por typos. Usa el navegador como primer filtro estructural, y después `docker compose config` y el demonio Docker para la verdad runtime. Encadena con el Dockerfile y el HCL Terraform en el mismo hub DevOps.

Validar el `.env` antes del `compose.yml`
Corregir pronto la indentación YAML y los servicios sin image/build
Añadir `.env` al `.gitignore` y commitear un `.env.example`
Usar `docker compose config` para el render final con variables
Nunca pegar secretos reales en una herramienta en línea
Compartir este artículo
Compartir este artículo: