# env — Umgebungsvariablen in der Shell verwalten > Umgebungsvariablen ansehen, setzen, exportieren und löschen – plus PATH-Verwaltung, .env-Dateien und portable Shebangs mit env. Source: https://www.jpkc.com/db/cheatsheets/shell-system/env/ Umgebungsvariablen steuern, wie Programme sich verhalten: vom Suchpfad `PATH` über die Sprache `LANG` bis zu API-Schlüsseln und Proxy-Einstellungen. `env` ist das Werkzeug, mit dem du diese Variablen anzeigst, gezielt für einen einzelnen Aufruf setzt oder eine Umgebung komplett zurücksetzt – und zusammen mit den Shell-Builtins `export` und `unset` verwaltest du den kompletten Lebenszyklus. Dieser Guide zeigt dir die Befehle, die du im Alltag wirklich brauchst, vom schnellen Nachschauen bis zur sauberen, reproduzierbaren Umgebung. ## Variablen anzeigen `env` — Listet alle Umgebungsvariablen auf. ```bash env ``` `env | sort` — Listet alle Umgebungsvariablen alphabetisch sortiert auf. ```bash env | sort ``` `printenv` — Gibt alle Umgebungsvariablen aus (wie env). ```bash printenv ``` `printenv ` — Gibt den Wert einer bestimmten Variable aus. ```bash printenv HOME ``` `echo $` — Gibt den Wert einer Variable per Shell-Expansion aus. ```bash echo $PATH ``` `env | grep ` — Sucht Variablen, die zu einem Muster passen. ```bash env | grep -i proxy ``` ## Setzen & Exportieren `export =` — Setzt und exportiert eine Variable (für Kindprozesse verfügbar). ```bash export EDITOR=vim ``` `=` — Setzt eine Shell-Variable (wird NICHT an Kindprozesse vererbt). ```bash MY_VAR=hello ``` `export ` — Exportiert eine bereits gesetzte Shell-Variable. ```bash MY_VAR=hello && export MY_VAR ``` `export -p` — Listet alle exportierten Variablen samt Werten auf. ```bash export -p ``` `declare -x =` — Deklariert und exportiert eine Variable (Bash). ```bash declare -x API_KEY=abc123 ``` ## Entfernen & Aufheben `unset ` — Entfernt eine Variable vollständig. ```bash unset TEMP_VAR ``` `export -n ` — Hebt den Export auf (bleibt nur noch Shell-Variable). ```bash export -n MY_VAR ``` `env -u ` — Führt ein Kommando ohne eine bestimmte Variable aus. ```bash env -u http_proxy curl https://example.com ``` ## Inline & temporär `= ` — Setzt eine Variable nur für ein einzelnes Kommando. ```bash NODE_ENV=production node app.js ``` `env = ` — Führt ein Kommando mit temporärer Variable aus (explizit). ```bash env LANG=C sort data.txt ``` `env -i ` — Führt ein Kommando mit komplett leerer Umgebung aus. ```bash env -i /bin/bash --norc ``` `env -i HOME=$HOME PATH=$PATH ` — Führt mit sauberer Umgebung aus, behält aber das Nötigste. ```bash env -i HOME=$HOME PATH=$PATH bash -c 'env' ``` ## PATH verwalten `echo $PATH` — Zeigt den aktuellen PATH (doppelpunktgetrennte Verzeichnisse). ```bash echo $PATH ``` `export PATH=":$PATH"` — Stellt ein Verzeichnis dem PATH voran (wird zuerst durchsucht). ```bash export PATH="$HOME/.local/bin:$PATH" ``` `export PATH="$PATH:"` — Hängt ein Verzeichnis an den PATH an (wird zuletzt durchsucht). ```bash export PATH="$PATH:/opt/myapp/bin" ``` `echo $PATH | tr ':' '\n'` — Zeigt die PATH-Einträge einzeln pro Zeile. ```bash echo $PATH | tr ':' '\n' ``` `which ` — Zeigt, über welchen PATH-Eintrag ein Kommando aufgelöst wird. ```bash which python3 ``` ## Gängige Muster `source .env` — Lädt Variablen aus einer .env-Datei in die aktuelle Shell. ```bash source .env ``` `export $(grep -v '^#' .env | xargs)` — Exportiert alle Nicht-Kommentar-Zeilen aus einer .env-Datei. ```bash export $(grep -v '^#' .env | xargs) ``` `${VAR:-default}` — Nutzt einen Standardwert, wenn die Variable nicht gesetzt oder leer ist. ```bash echo ${PORT:-8080} ``` `${VAR:?error message}` — Bricht mit Fehler ab, wenn die Variable nicht gesetzt oder leer ist. ```bash echo ${DATABASE_URL:?DATABASE_URL must be set} ``` `env -0 | sort -z | tr '\0' '\n'` — Listet Variablen sicher auf (verträgt Werte mit Zeilenumbrüchen). ```bash env -0 | sort -z | tr '\0' '\n' ``` ## Fazit `env` ist mehr als nur „alle Variablen anzeigen": Mit `env VAR=wert befehl` setzt du eine Variable sauber für genau einen Aufruf, ohne deine Shell-Umgebung zu verändern, und mit `env -i` startest du ein Programm in einer komplett leeren Umgebung – ideal für reproduzierbare Builds und zum Debuggen von Variablen-Problemen. Sehr verbreitet ist `env` außerdem im Shebang `#!/usr/bin/env python3`: Statt einen festen Interpreterpfad zu verdrahten, wird das Programm über den `PATH` gesucht – das macht Skripte portabel über verschiedene Systeme und virtuelle Umgebungen hinweg. Ein Sicherheitshinweis: Geheimnisse wie API-Schlüssel oder Passwörter sind als Umgebungsvariablen nicht wirklich privat – sie tauchen je nach System in `/proc//environ` auf und können von Kindprozessen geerbt werden. Für echte Geheimnisse sind dedizierte Secret-Manager oder Dateien mit restriktiven Rechten die bessere Wahl. Und Vorsicht beim verbreiteten `export $(grep -v '^#' .env | xargs)`: Es bricht bei Werten mit Leerzeichen oder Anführungszeichen – für komplexe `.env`-Dateien lieber `set -a; source .env; set +a` nutzen. ## Weiterführende Links - [Wikipedia: Umgebungsvariable](https://de.wikipedia.org/wiki/Umgebungsvariable) – Grundlagen zu Umgebungsvariablen und ihrer Vererbung an Kindprozesse - [ubuntuusers-Wiki: Umgebungsvariable](https://wiki.ubuntuusers.de/Umgebungsvariable/) – deutschsprachige Praxis-Doku zum Setzen und Nutzen von Variablen unter Linux ## Verwandte Kommandos - [bash](https://www.jpkc.com/db/cheatsheets/shell-system/bash/) – die Shell, in der Variablen gesetzt, exportiert und expandiert werden - [id](https://www.jpkc.com/db/cheatsheets/shell-system/id/) – zeigt Benutzer- und Gruppen-IDs, die das Verhalten der Umgebung mitprägen - [sudo](https://www.jpkc.com/db/cheatsheets/shell-system/sudo/) – Kommandos mit anderen Rechten ausführen, inklusive `-E` zum Erhalt der Umgebung