.env zu JSON Konverter

Was ist eine .env-Datei?

// Parse a .env file to a JSON object in Node.js using dotenv
import { parse } from 'dotenv';

const envText = `# Database
DATABASE_URL=postgres://user:pass@localhost:5432/mydb
DEBUG=true`;

// dotenv.parse returns a plain object of string values
const parsed = parse(envText);

// Every value is a string, just like process.env
const json = JSON.stringify(parsed, null, 2);

console.log(json);
// {
//   "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
//   "DEBUG": "true"
// }

Hauptfunktionen

Beispiele

# Database
DATABASE_URL=postgres://user:pass@localhost:5432/mydb
DATABASE_POOL_SIZE=10

# Auth
JWT_SECRET="super secret value"
SESSION_TIMEOUT=3600

# Feature flags
ENABLE_SIGNUP=true
VITE_API_BASE=https://api.example.com

{
  "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
  "DATABASE_POOL_SIZE": "10",
  "JWT_SECRET": "super secret value",
  "SESSION_TIMEOUT": "3600",
  "ENABLE_SIGNUP": "true",
  "VITE_API_BASE": "https://api.example.com"
}

POSTGRES_DB=mydb
POSTGRES_USER=admin
POSTGRES_PASSWORD=s3cr3t!
PGDATA=/var/lib/postgresql/data
TZ=UTC
NGINX_HOST=example.com
NGINX_PORT=80

{
  "POSTGRES_DB": "mydb",
  "POSTGRES_USER": "admin",
  "POSTGRES_PASSWORD": "s3cr3t!",
  "PGDATA": "/var/lib/postgresql/data",
  "TZ": "UTC",
  "NGINX_HOST": "example.com",
  "NGINX_PORT": "80"
}

export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_REGION=us-east-1
export DEPLOY_ENV=production

{
  "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
  "AWS_SECRET_ACCESS_KEY": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
  "AWS_REGION": "us-east-1",
  "DEPLOY_ENV": "production"
}

APP_NAME=My App                 # unquoted value, inline comment stripped
GREETING="Hello,\nWorld"        # double quotes: \n becomes a real newline
LITERAL='no \n escapes here'    # single quotes: kept literally
PRIVATE_KEY="-----BEGIN KEY-----
line two
line three
-----END KEY-----"
EMPTY=

{
  "APP_NAME": "My App",
  "GREETING": "Hello,\nWorld",
  "LITERAL": "no \\n escapes here",
  "PRIVATE_KEY": "-----BEGIN KEY-----\nline two\nline three\n-----END KEY-----",
  "EMPTY": ""
}

Anwendung

1. 1

   Füge deine .env-Datei ein

   Gib deine .env-Inhalte in das Eingabefeld oben ein oder füge sie ein. Du kannst auch auf 'Beispiel laden' klicken, um eine Node/Vite-.env, eine Docker-Compose-env-Datei oder eine CI-Secrets-Vorlage auszuprobieren.

2. 2

   Live-JSON-Ausgabe ansehen

   JSON erscheint sofort im Ausgabe-Panel. Schalte 'Typen ableiten' um, wenn du Zahlen und Booleans statt Strings möchtest, und wähle 2 oder 4 Leerzeichen Einrückung.

3. 3

   Kopieren oder Herunterladen

   Klicke auf Kopieren, um das JSON in die Zwischenablage zu übernehmen, oder auf Herunterladen, um es als .json-Datei zu speichern — bereit für einen Konfigurations-Loader, einen Secrets-Manager oder jedes Tool, das JSON liest.

Häufige .env-Fallstricke

DATABASE_URL
DEBUG true

DATABASE_URL=
DEBUG=true

API_KEY = abc123

API_KEY=abc123

COLOR=#ff0000

COLOR="#ff0000"

GREETING='Hello\nWorld'

GREETING="Hello\nWorld"

KEY="-----BEGIN-----
line two

KEY="-----BEGIN-----
line two
-----END-----"

PORT=3000
PORT=8080

PORT=8080

Häufige Anwendungsfälle

Konfiguration in JSON-basierte Tools einspeisen

Konvertiere eine .env-Datei zu JSON, um Umgebungskonfiguration in Tools, Skripte und SDKs zu laden, die JSON statt Umgebungsvariablen lesen — Konfigurationsvalidatoren, Schema-Prüfer und Code-Generatoren.

Secrets in einen Manager importieren

Viele Secrets-Manager (AWS Secrets Manager, Vault, Doppler) akzeptieren JSON für den Bulk-Import. Konvertiere zuerst eine .env-Datei in ein JSON-Objekt und übertrage dann den gesamten Satz in einem Vorgang statt Variable für Variable.

Eine lange .env auf einen Blick prüfen

Verwandle eine ausufernde .env-Datei in strukturiertes, eingerücktes JSON, damit du Schlüssel überfliegen, Duplikate über die Warnung erkennen und die Konfiguration in einem lesbaren Format überprüfen kannst, bevor du Änderungen committest.

Typisierte Konfigurationsobjekte erzeugen

Aktiviere Typen ableiten, um Zahlen, Booleans und null im JSON zu erhalten, und speise es dann in eine typisierte Konfigurationsschicht oder einen JSON-zu-TypeScript-Schritt ein, um ein Interface für deine Umgebungsvariablen abzuleiten.

Gegen ein JSON-Schema validieren

Konvertiere .env zu JSON und lasse es durch einen JSON-Schema-Validator laufen, um erforderliche Schlüssel, Wertformate und erlaubte Enums in CI zu erzwingen — und fange fehlkonfigurierte Umgebungen vor dem Deploy ab.

Docker-Compose-env_file-Konfiguration migrieren

Wandle die env_file, die dein Compose-Stack liest, in JSON um, zur Verwendung in einem anderen Orchestrierungstool, einem Konfigurationsserver oder der Dokumentation — ohne echte Zugangsdaten an einen externen Dienst preiszugeben.

Technische Details

Zeilenweises, dotenv-kompatibles Parsing

Die Eingabe wird Zeile für Zeile geparst. Leerzeilen und Kommentarzeilen (erstes Zeichen ohne Leerraum #) werden übersprungen, ein optionales export-Präfix wird entfernt, und jede verbleibende Zeile wird am ersten = in Schlüssel und Wert geteilt. Bei Schlüsseln wird umgebender Leerraum entfernt. Werte folgen den dotenv-Regeln: Doppelte Anführungszeichen verarbeiten die Escapes \n \t \r \\ \" und erlauben mehrzeilige Bereiche, einfache Anführungszeichen sind wörtlich, und nicht in Anführungszeichen stehende Werte entfernen nachgestellten Leerraum und Inline-Kommentare.

Optionale Typableitung

Standardmäßig werden alle Werte als JSON-Strings ausgegeben, was dem Laufzeitverhalten von dotenv entspricht, bei dem process.env-Werte immer Strings sind. Mit aktiviertem Typen ableiten werden nicht in Anführungszeichen stehende Werte befördert: Numerische Strings werden zu JSON-Zahlen, true/false zu Booleans, und leere oder null-Werte zu JSON null. In Anführungszeichen stehende Werte werden nie abgeleitet — die Anführungszeichen markieren sie als explizite Strings. Doppelte Schlüssel werden nach dem Prinzip Letzter gewinnt mit einer Warnung aufgelöst.

Browserbasiert — kein Upload, kein Server

Die gesamte Verarbeitung geschieht vollständig in der JavaScript-Engine deines Browsers; zu keinem Zeitpunkt werden .env-Daten über das Netzwerk übertragen. Es gibt keine externen Abhängigkeiten, weil der Parser hauseigen geschrieben ist — die Node-dotenv-Bibliothek ist auf das Dateisystem angewiesen und nicht browsersicher. Eingaben größer als 200KB wechseln vom Live-Modus in den manuellen Modus (ein expliziter Konvertieren-Klick), damit der Browser reaktionsfähig bleibt.

Bewährte Praktiken

Behalte die Standard-String-Ausgabe, um dotenv zu entsprechen

dotenv lädt jeden Wert als String, sodass die Standard-String-Ausgabe genau das widerspiegelt, was deine Anwendung zur Laufzeit sieht. Aktiviere Typen ableiten nur, wenn der nachgelagerte Konsument wirklich typisiertes JSON erwartet — sonst riskierst du eine Diskrepanz, bei der sich '0' oder 'false' in JSON anders verhält als in deiner laufenden App.

Werte mit # oder Leerraum in Anführungszeichen setzen

Bei nicht in Anführungszeichen stehenden Werten beginnt ein Leerzeichen gefolgt von # einen Inline-Kommentar, und nachgestellter Leerraum wird entfernt. Wenn ein Wert legitim ein # (Hex-Farben, Fragment-URLs) oder bedeutsame Leerzeichen enthält, setze ihn in doppelte Anführungszeichen, damit er wörtlich im JSON erhalten bleibt.

Doppelte Schlüssel an der Quelle auflösen

Das Tool behält den letzten Wert und warnt dich, wenn ein Schlüssel doppelt vorkommt, aber ein Duplikat in einer .env-Datei ist fast immer ein Fehler. Entferne die überflüssige Zeile, damit es keine Mehrdeutigkeit darüber gibt, welches Geheimnis aktiv ist.

Niemals Produktions-Secrets in serverseitige Konverter einfügen

Da eine .env-Datei faktisch eine Liste von Zugangsdaten ist, konvertiere sie nur in einem Tool, das vollständig im Browser läuft. Dieser Konverter tut das — überprüfe null Netzwerkanfragen in den DevTools — daher ist er sicher für echte Geheimnisse, anders als serverseitige oder API-gestützte Konverter.

Validiere das JSON, bevor du es nachgelagert verwendest

Lasse das JSON nach dem Konvertieren durch den JSON-Formatierer laufen, um die Struktur zu bestätigen, bevor du es in einen Schema-Validator, einen Secrets-Manager-Import oder einen Konfigurations-Loader einspeist, damit eine strukturelle Überraschung früh auffällt.

Häufig gestellte Fragen