Docker Compose und `.env`-Dateien online validieren

Docker Compose und `.env`-Dateien online validieren

Prüfen Sie die Struktur von `compose.yml` und `.env` vor `docker compose up` — lokal im Browser validieren, ohne CLI-Tools.

16.07.2026
9 Min. Lektüre
Teilen Sie diesen Artikel:
docker-composeenvDevOpsValidierungYAMLAnleitung

Compose und `.env` vor dem Deployment validieren

Ein `docker compose up`, das an einem falsch eingerückten `services`-Schlüssel oder an einer `.env`-Zeile ohne `=` scheitert, kostet Zeit, sei es auf einer neuen Maschine, in der CI oder beim Einarbeiten. Eine schnelle Struktur-Prüfung vor dem Start des Stacks fängt offensichtliche Tippfehler ab, bevor Docker sich beschwert. Auf FastMinify können Sie eine Docker-Compose-Datei online validieren und eine `.env`-Datei online validieren, vollständig im Browser, ohne Docker- oder Node-Installation. Die ganze Werkzeugfamilie liegt im Hub DevOps-Werkzeuge, neben Terraform, Dockerfile und HCL.

Compose-Strukturfehler vor `docker compose up` erkennen
Ungültige `.env`-Zeilen (fehlendes `=`, illegaler Schlüssel) früh finden
Doppelte Schlüssel und offene Anführungszeichen in der `.env` melden
Hinweis, wenn ein Schlüssel wie ein Secret aussieht (`SECRET`, `TOKEN`…)
Gleicher Hub wie Dockerfile, Terraform und HCL

Häufige Fehler und Ablauf vor dem Deployment

Was die Validierung oft findet

Einige Fehler tauchen ständig auf. Sie vor `docker compose up` zu korrigieren, vermeidet kryptische Docker-Meldungen.

Inkonsistente YAML-Einrückung unter `services` (Einlesefehler)
`services` als Liste statt als Mapping geschrieben
Ein Service ohne `image` und `build` hat nichts, was gestartet werden könnte
`.env`-Zeile ohne `=` (oft ein Kommentar ohne `#`)
Doppelter `.env`-Schlüssel: der letzte Wert überschreibt den vorherigen
Secrets und bewährte Verfahren für `.env`

Der Validator markiert Schlüssel, die wie Secrets aussehen (`PASSWORD`, `API_KEY`, `SECRET`, `TOKEN`), das ist aber nur eine Erinnerung und keine Suche nach Secrets. Die eigentliche Disziplin bleibt, `.env`-Dateien nicht in Git einzuchecken.

Nehmen Sie `.env` in die `.gitignore` auf und checken Sie eine `.env.example` ohne Werte ein
Werte mit Leerzeichen oder Sonderzeichen in Anführungszeichen setzen
In Produktion Docker-Secrets / den Secret-Manager der Plattform nutzen
Verknüpfen Sie das Dockerfile des Services über den Leitfaden Dockerfile online linten und formatieren
Formatieren und validieren Sie die zugehörige IaC, wie in Terraform und HCL online beschrieben
Nutzen Sie den FastMinify-DevOps-Hub für die ganze Werkzeugfamilie

Compose und `.env` verfolgen zwei verschiedene Ziele

Den richtigen Validator wählen

Compose und `.env` ergänzen sich: Das eine beschreibt den Stack, das andere liefert die Konfiguration. Bei der Prüfung validieren Sie beide, bevor Sie den Stack starten.

Was geprüft wird

format:Compose: YAML + `services` + image/build
validate:`.env`: KEY=VALUE-Zeilen, Schlüssel, Anführungszeichen
minify:`docker compose config`: die tatsächliche Ausgabe

Wann nutzen

format:Vor `docker compose up`
validate:Vor dem Teilen oder Laden einer `.env`
minify:In der CI oder auf einer Testumgebung
Empfohlene Reihenfolge

Eine einfache Reihenfolge vermeidet, Fehler erst beim Deployment zu entdecken.

Die `.env` validieren (Variablen-Syntax)
Die `compose.yml` validieren (Service-Struktur)
Das von einem `build:` referenzierte Dockerfile prüfen
`docker compose config` für die endgültige Ausgabe ausführen
Dann `docker compose up` auf einer Testumgebung

Wann das Browser-Werkzeug genügt

Häufige Szenarien

Sie brauchen kein installiertes Docker, um drei Fehler in einer per Nachricht erhaltenen `compose.yml` zu prüfen.

Eine aus einem Ticket oder README eingefügte `compose.yml` prüfen
Eine `.env` validieren, bevor Sie sie mit einem Kollegen teilen
Ein Lehrbeispiel oder einen öffentlichen Gist vorbereiten
Ein `docker compose up` wieder zum Laufen bringen, das auf einer neuen Maschine scheitert
Eine Compose-Konfiguration eines Anbieters oder aus einer Vorlage kurz prüfen

Grenzen des Browsers und was er nicht ersetzt

`docker compose config` und die tatsächliche Ausführung

Docker-CLI und -Daemon bleiben Pflicht, sobald Sie die `${VAR}`-Interpolation auflösen, mehrere Compose-Dateien (`-f`) zusammenführen oder prüfen müssen, ob ein Image existiert.

`docker compose config` für die endgültige Ausgabe mit aufgelösten Variablen
Zusammenführen von Dateien (`compose.yml` + `compose.override.yml`)
Verfügbarkeit von Images in der Registry prüfen
Netzwerke, Volumes und Service-Abhängigkeiten testen
Secrets gehören in den Manager der Plattform oder in Docker-Secrets und nie ins Netz
Benachbarte Dateien

Ein Service kommt oft mit Dockerfile, Terraform-HCL und `.env`. Compose und `.env` zu validieren, das Dockerfile zu linten und das HCL zu formatieren, deckt den täglichen DevOps-Weg ab.

Die `.env` vor der `compose.yml` validieren
Das von einem `build:` referenzierte Dockerfile linten
Zugehöriges Terraform-HCL formatieren / validieren
Eine gemeinsame Konvention für die Einrückung im Repository halten
Behandeln Sie die Konfiguration als Git-Quelle: versioniert und geprüft

CLI und Ökosystem

Lokale Referenzwerkzeuge

Die Docker-CLI und einige Linter bleiben der Standard. Die FastMinify-Werkzeuge ergänzen die Erkundung und einmalige Prüfungen.

docker compose config

Erzeugt die endgültige Datei mit aufgelösten Variablen und meldet Fehler gegen die Spezifikation.

Vorteile:
Löst `${VAR}`-Interpolation aus der `.env` auf
Führt `-f`-Dateien und Overrides zusammen
Offizielle Referenz für die Compose-Spezifikation
Nachteile:
Benötigt installiertes Docker
Weniger praktisch für einen Ausschnitt außerhalb des Repositorys

dotenv-linter

Schneller `.env`-Linter (Rust) mit Regeln für Schlüssel und Werte.

Vorteile:
Erkennt Duplikate, unsortierte Schlüssel, verdächtige Werte
Passt zu Pre-Commit-Hooks und zur CI
Behebt einige Probleme automatisch
Nachteile:
Braucht lokale Installation
Validiert die Compose-Datei nicht

yamllint

Generischer YAML-Linter, nützlich für Einrückung und Stil.

Vorteile:
Konfigurierbare Einrückungs- und Stilregeln
Nützlich über Compose hinaus (CI, K8s…)
Editor- und Pre-Commit-Integration
Nachteile:
Kennt die Compose-Semantik nicht
Eine Konfiguration, die pro Team gepflegt werden muss

Anatomie einer `compose.yml` und einer `.env`

Struktur einer Compose-Datei

Eine moderne Compose-Datei ist ein einzelnes YAML-Dokument mit einem erforderlichen Top-Level-Schlüssel `services`. Jeder Service sollte ein `image` oder einen `build`-Block deklarieren. Weitere erwartete Top-Level-Schlüssel sind `networks`, `volumes`, `secrets`, `configs`, `name` und das historische `version`. Der Schlüssel `version` ist in der aktuellen Compose-Spec optional, wird aber weiterhin toleriert.

Wurzel: ein einzelnes YAML-Dokument (keine mehrfachen `---`-Trenner)
`services` erforderlich und ein Mapping (keine Liste)
Jeder Service: `image:` oder `build:`, um startbar zu sein
Bekannte Top-Level-Schlüssel: services, networks, volumes, secrets, configs, name, version
YAML-Einrückung ist entscheidend: konsistent zwei Leerzeichen, nie Tabs
Struktur einer `.env`-Datei

Eine `.env` ist eine Liste von `KEY=VALUE`-Paaren, eines pro Zeile. Leerzeilen und Kommentare (`#`) werden ignoriert, ein `export `-Präfix wird toleriert. Schlüsselnamen folgen der Shell-Konvention (Buchstaben, Ziffern, Unterstrich, nicht mit einer Ziffer beginnend). Ein Wert mit Leerzeichen sollte in Anführungszeichen stehen, um Überraschungen zu vermeiden.

Ein `KEY=VALUE`-Paar pro Zeile, und eine Zeile ohne `=` ist ungültig
Kommentare (`#`) und Leerzeilen werden ignoriert
Gültiger Schlüssel: `^[A-Za-z_][A-Za-z0-9_]*$` (kein Leerzeichen/Bindestrich)
Anführungszeichen `"` oder `'` müssen geschlossen sein, und Werte mit Leerzeichen gehören in Anführungszeichen
`export FOO=bar` wird akzeptiert, Compose liest aber nur `FOO=bar`
Was die Browser-Validierung nicht ersetzt

Beide Validatoren führen strukturelle Prüfungen aus, keine vollständige Validierung der Compose-Spezifikation und keine Suche nach Secrets. Sie lösen keine Variablen-Interpolation (`${VAR}`) auf, prüfen nicht, ob ein Image in einer Registry existiert, und führen kein `docker compose up` aus. Wie es zur Laufzeit wirklich aussieht, zeigen weiterhin `docker compose config` und der Docker-Daemon.

Keine vollständige Compose-Schema-Validierung (Typ jedes Feldes)
Keine Auflösung von `${VARIABLE}` zwischen `.env` und `compose.yml`
Keine fortgeschrittene Suche nach Secrets, nur ein Muster für Schlüsselnamen
Keine Registry-Verbindung und kein `docker build`
Niemals echte Secrets in ein öffentliches Textfeld einfügen

Zwei Validierungen, Compose und `.env`

Docker Compose validieren (YAML-Struktur)

Der Validator liest das YAML ein und prüft, dass es ein einzelnes Dokument, eine Mapping-Wurzel und einen `services`-Schlüssel gibt. Er meldet Services ohne `image` oder `build` und unbekannte Schlüssel auf oberster Ebene. Probieren Sie den Online-Docker-Compose-Validator.

YAML-Fehler auf der betroffenen Zeile lokalisiert
Fehler, wenn `services` fehlt oder kein Mapping ist
Warnung, wenn ein Service weder `image` noch `build` hat
Ein Hinweis zu Schlüsseln auf oberster Ebene außerhalb der bekannten Menge
Eine strukturelle Prüfung, nicht die vollständige Compose-Spezifikation
Eine `.env`-Datei validieren (KEY=VALUE-Analyse)

Der `.env`-Validator liest jede Zeile. Er meldet Zeilen ohne `=` oder mit illegalem Schlüssel und erkennt offene Anführungszeichen, doppelte Schlüssel und Werte mit Leerzeichen ohne Anführungszeichen. Nutzen Sie den Online-`.env`-Validator, bevor Sie eine Beispieldatei teilen.

Zeile ohne `=` → Fehler, `KEY=VALUE` erwartet
Ungültiger Schlüssel (Leerzeichen, Bindestrich, führende Ziffer) → Fehler
Offenes Anführungszeichen → Fehler
Doppelter Schlüssel → Warnung mit der Ursprungszeile
Leerzeichen in einem Wert ohne Anführungszeichen → Warnung
Dockerfile und Terraform desselben Projekts

Ein Service steht selten allein. Weiter geht es mit dem Online-Dockerfile-Linter und dem Online-Terraform-/HCL-Formatierer, um die gesamte Infrastrukturkonfiguration abzudecken.

Dockerfile desselben Services linten und formatieren
Zugehöriges Terraform-HCL formatieren und validieren
Derselbe DevOps-Hub für einen Arbeitsweg
Nützlich vor einem ersten lokalen `docker compose up`
Halten Sie Secrets aus dem Repository und aus Online-Werkzeugen fern

Zusammenfassung

Wer die Struktur seiner `compose.yml` und `.env` vor `docker compose up` validiert, vermeidet Fehlschläge beim Deployment durch Tippfehler. Nutzen Sie den Browser als ersten Strukturfilter und danach `docker compose config` und den Docker-Daemon, um zu sehen, was zur Laufzeit wirklich passiert. Weiter geht es mit Dockerfile und Terraform-HCL im selben DevOps-Hub.

Validieren Sie jetzt Ihr Compose oder Ihre `.env`

Validieren Sie die `.env` vor der `compose.yml`
Korrigieren Sie YAML-Einrückung und Services ohne image/build früh
Nehmen Sie `.env` in die `.gitignore` auf und checken Sie eine `.env.example` ein
Nutzen Sie `docker compose config` für die endgültige Ausgabe mit Variablen
Fügen Sie niemals echte Secrets in ein Online-Werkzeug ein
Teilen Sie diesen Artikel
Teilen Sie diesen Artikel: