{"id":29601,"date":"2026-03-25T13:34:00","date_gmt":"2026-03-25T12:34:00","guid":{"rendered":"https:\/\/contabo.com\/blog\/umgebungsvariablen-in-linux-setzen-und-auflisten\/"},"modified":"2026-04-01T09:40:41","modified_gmt":"2026-04-01T07:40:41","slug":"umgebungsvariablen-in-linux-setzen-und-auflisten","status":"publish","type":"post","link":"https:\/\/contabo.com\/blog\/de\/umgebungsvariablen-in-linux-setzen-und-auflisten\/","title":{"rendered":"Einrichten und Auflisten von Umgebungsvariablen in Linux"},"content":{"rendered":"\n
\"Einrichten<\/figure>\n\n\n\n

Jeder Linux-Prozess erbt einen Satz Umgebungsvariablen von seinem Elternprozess. Diese Schl\u00fcssel-Wert-Paare steuern das Verhalten von Shells, legen fest, wo Programme nach ausf\u00fchrbaren Dateien suchen, und bestimmen, welche Konfiguration eine laufende Anwendung verwendet. Stimmt etwas nicht, geht dein Deployment um 2 Uhr nachts kaputt. Stimmt alles, hast du eine saubere, portable Systemkonfiguration, die mit deinem Benutzerprofil oder deinem gesamten Server mitreist.<\/p>\n\n\n\n

Ob du einen neuen VPS einrichtest, eine defekte CI-Pipeline debuggst oder eine Python-App deployst, die ihre Datenbank nicht findet: Umgebungsvariablen stehen immer im Mittelpunkt. Sie geh\u00f6ren zu den grundlegenden Linux-Konzepten, die du jeden Tag nutzen wirst, sobald du sie einmal verstanden hast.<\/p>\n\n\n\n

Dieser Leitfaden f\u00fchrt dich durch die Befehle, die du tats\u00e4chlich im Alltag brauchst: Auflisten, Ausgeben, Setzen, Persistieren und L\u00f6schen von Linux-Umgebungsvariablen. Au\u00dferdem behandeln wir Best Practices und h\u00e4ufige Stolperfallen, die selbst erfahrene Sysadmins ins Straucheln bringen.<\/p>\n\n\n\n

Was sind Umgebungsvariablen in Linux?<\/h2>\n\n\n\n

Umgebungsvariablen sind dynamische Schl\u00fcssel-Wert-Paare, die das Verhalten von Shells und Prozessen auf einem Linux-System beeinflussen. F\u00fchre printenv<\/strong> <\/code>in einem Terminal aus, und du siehst Dutzende davon: PATH teilt der Shell mit, wo sie ausf\u00fchrbare Dateien findet, HOME zeigt auf dein Benutzerverzeichnis, SHELL gibt an, welche Shell du verwendest, und LANG legt deine Locale fest.<\/p>\n\n\n\n

Admins nutzen sie, um Konfigurationen anwendungs\u00fcbergreifend zu teilen, ohne Werte fest im Code zu verankern. Eine einzige PATH<\/strong> <\/code>Variable erm\u00f6glicht es zum Beispiel jedem Programm auf dem System, Binaries zu finden, ohne dass jedes seine eigene Suchliste pflegen muss. Stell dir Umgebungsvariablen wie ein gemeinsames schwarzes Brett vor, das jeder Prozess auf dem System lesen kann.<\/p>\n\n\n\n

Linux unterscheidet klar zwischen zwei Arten von Variablen. Umgebungsvariablen haben einen globalen Geltungsbereich. Sie sind f\u00fcr Kindprozesse, Subshells und jedes Programm sichtbar, das aus der jeweiligen Sitzung heraus gestartet wird. Shell-Variablen hingegen existieren nur in der aktuellen Sitzung. Starte eine Subshell mit bash<\/strong> <\/code>und sie sind weg.<\/p>\n\n\n\n

Dieser Unterschied ist wichtiger, als er zun\u00e4chst klingt. Genau das ist der Grund, warum dein Skript interaktiv einwandfrei l\u00e4uft, aber scheitert, wenn es von ‚cron‘, ’systemd‘ oder einem anderen Benutzer gestartet wird. Der aufrufende Prozess nimmt deine Shell-Variablen nicht mit, und das Skript findet einen leeren Wert, wo es einen Pfad erwartet hat.<\/p>\n\n\n\n

Linux-Umgebungsvariablen verwalten<\/h2>\n\n\n\n

Umgebungsvariablen auf einem Linux-System zu verwalten bedeutet, vier Operationen zu kennen: auflisten, einzelne Werte ausgeben, neue setzen und nicht mehr ben\u00f6tigte entfernen. Alles Folgende funktioniert auf jeder g\u00e4ngigen Linux-Distribution, von Ubuntu und Debian bis CentOS und Arch. Verbinde dich per SSH oder \u00f6ffne dein lokales Terminal, und schon kann es losgehen.<\/p>\n\n\n\n

Umgebungsvariablen in Linux auflisten<\/h3>\n\n\n\n

Am schnellsten listest du Umgebungsvariablen in Linux mit dem printenv<\/strong> <\/code>Befehl auf:<\/p>\n\n\n\n

printenv<\/code><\/pre>\n\n\n\n
Das gibt jede Variable samt Wert auf Standardausgabe (stdout) aus. Die Ausgabe wird schnell lang. Leite sie deshalb durch less<\/strong> <\/code>damit du durchbl\u00e4ttern kannst:<\/p>\n\n\n\n
printenv | less<\/code><\/pre>\n\n\n\n
Der env <\/code><\/strong>Befehl<\/strong> funktioniert nahezu identisch wie printenv<\/code><\/strong>. Der Unterschied: Der set <\/code><\/strong>Befehl<\/strong> in Linux gibt sowohl Umgebungs- als auch Shell-Variablen aus und liefert dir damit das Gesamtbild. Wenn du nur Shell-Variablen sehen willst, filtere mit grep<\/code><\/strong>:<\/p>\n\n\n\n
set | grep -i my_var<\/code><\/pre>\n\n\n\n
Einige Variablen begegnen dir st\u00e4ndig auf allen Linux-Distributionen:<\/p>\n\n\n\n
    \n
  • PATH<\/strong> <\/code>– Verzeichnisse, in denen die Shell nach ausf\u00fchrbaren Dateien sucht<\/li>\n\n\n\n
  • HOME<\/strong> <\/code>– das Home-Verzeichnis des aktuellen Benutzers<\/li>\n\n\n\n
  • USER<\/strong> <\/code>– der Name des angemeldeten Benutzerkontos<\/li>\n\n\n\n
  • SHELL<\/strong> <\/code>– Pfad zur Shell des aktuellen Benutzers<\/li>\n\n\n\n
  • PWD<\/strong> <\/code>– das aktuelle Arbeitsverzeichnis<\/li>\n\n\n\n
  • EDITOR<\/strong> <\/code>– der Standard-Texteditor des Systems<\/li>\n<\/ul>\n\n\n\n
    Diese sind in praktisch jeder Linux-Distribution voreingestellt. Du kannst eigene Variablen f\u00fcr beliebige Zwecke definieren: individuelle Anwendungskonfigurationen, Deployment-Flags, Service-Endpunkte. Und genau hier wird es interessant.<\/p>\n\n\n\n
    Umgebungsvariablen in Linux ausgeben<\/h3>\n\n\n\n
    Um eine einzelne Umgebungsvariable in Linux auszugeben, verwendest du den echo<\/strong> <\/code>Befehl mit einem Dollarzeichen als Pr\u00e4fix:<\/p>\n\n\n\n
    echo $PATH<\/code><\/pre>\n\n\n\n
    Der Linux echo <\/code><\/strong>Befehl<\/strong> liest den aktuellen Wert der Variable und gibt ihn im Terminal aus. Gro\u00df- und Kleinschreibung spielt eine Rolle, also $<\/code><\/strong>path<\/strong> <\/code>und $PATH<\/strong><\/code> sind zwei verschiedene Dinge.<\/p>\n\n\n\n
    Du kannst auch printenv<\/strong> <\/code>direkt mit dem Variablennamen verwenden:<\/p>\n\n\n\n
    printenv HOME<\/code><\/pre>\n\n\n\n
    Du willst pr\u00fcfen, ob eine Variable \u00fcberhaupt existiert? Leite printenv<\/strong> <\/code>durch grep<\/code><\/strong>:<\/p>\n\n\n\n
    printenv | grep USER<\/code><\/pre>\n\n\n\n
    Um mehrere Variablen auf einmal abzufragen:<\/p>\n\n\n\n
    printenv HOME PATH SHELL<\/code><\/pre>\n\n\n\n
    Jeder Wert wird in einer eigenen Zeile ausgegeben. Schnell und unkompliziert. Das ist praktisch, wenn du ein Setup-Skript schreibst und vor dem Fortfahren sicherstellen musst, dass mehrere Werte gesetzt sind.<\/p>\n\n\n\n
    Umgebungsvariable in Linux mit ‚export‘ setzen<\/h3>\n\n\n\n
    Der export <\/code><\/strong>Befehl<\/strong> in Linux erstellt eine tempor\u00e4re globale Umgebungsvariable. Hier die grundlegende Syntax:<\/p>\n\n\n\n
    export MY_VAR=\"some_value\"<\/code><\/pre>\n\n\n\n
    Die Variable ist jetzt f\u00fcr die aktuelle Shell und jeden daraus gestarteten Kindprozess sichtbar. Gib sie zur Kontrolle aus:<\/p>\n\n\n\n
    echo $MY_VAR<\/code><\/pre>\n\n\n\n
    Du kannst mehrere Werte durch Doppelpunkte getrennt zuweisen. Genau so funktioniert PATH<\/strong><\/code>:<\/p>\n\n\n\n
    export PATH=\"$PATH:\/opt\/myapp\/bin\"<\/code><\/pre>\n\n\n\n
    Aber Achtung: Das ist nur tempor\u00e4r. Starte dein System neu, \u00f6ffne eine neue Terminal-Sitzung, und die Variable ist weg. Der Linux export <\/code><\/strong>Befehl<\/strong> wirkt sich nur auf die laufende Sitzung und deren Kindprozesse aus. Dar\u00fcber stolpern Einsteiger st\u00e4ndig. Sie setzen eine Variable, es funktioniert, sie starten neu, und die Variable ist verschwunden.<\/p>\n\n\n\n
    F\u00fcr eine lokale Shell-Variable (eine, die nicht an Kindprozesse weitergegeben wird) l\u00e4sst du das Schl\u00fcsselwort ‚export‘ einfach weg:<\/p>\n\n\n\n
    my_local_var=\"test\"<\/code><\/pre>\n\n\n\n
    Die Konvention: Kleinschreibung f\u00fcr lokal, Grossschreibung f\u00fcr global. Halte dich daran. Dein zuk\u00fcnftiges Ich wird die Klarheit zu sch\u00e4tzen wissen, wenn du um Mitternacht Fehler suchst.<\/p>\n\n\n\n
    Persistente Umgebungsvariablen erstellen<\/h3>\n\n\n\n
    Tempor\u00e4re Variablen verschwinden beim Neustart. F\u00fcr permanente Umgebungsvariablen in Linux musst du sie in Konfigurationsdateien eintragen. Welche Datei die richtige ist, h\u00e4ngt davon ab, wer die Variable sehen soll.<\/p>\n\n\n\n
    Benutzerspezifische Umgebungsvariablen<\/h4>\n\n\n\n
    Bearbeite die bashrc <\/code><\/strong>Datei<\/strong>, um Variablen festzulegen, die f\u00fcr einen einzelnen Benutzer dauerhaft gelten. \u00d6ffne sie mit einem beliebigen Texteditor:<\/p>\n\n\n\n
    nano ~\/.bashrc<\/code><\/pre>\n\n\n\n
    F\u00fcge deine ‚export‘-Anweisung am Ende hinzu:<\/p>\n\n\n\n
    export API_URL=\"https:\/\/api.example.com\"<\/code><\/pre>\n\n\n\n
    Speichern und beenden. Die Variable wird in deiner aktuellen Sitzung erst wirksam, wenn du die Datei neu l\u00e4dst:<\/p>\n\n\n\n
    source ~\/.bashrc<\/code><\/pre>\n\n\n\n
    Der source bashrc<\/code><\/strong> Befehl liest die Datei erneut ein, ohne dass du dich ab- und wieder anmelden musst. Das ist der Befehl, den Leute am h\u00e4ufigsten vergessen, wenn sie eine neue Variable hinzuf\u00fcgen und sich dann wundern, warum sie nicht auftaucht.<\/p>\n\n\n\n
    Du kannst auch ~\/.profile<\/code><\/strong> verwenden, wenn du Variablen in Login-Shells verf\u00fcgbar machen willst. Der Unterschied: .bashrc<\/code><\/strong> wird bei jeder interaktiven Shell ausgef\u00fchrt, .profile<\/code><\/strong> wird nur einmal beim Login ausgef\u00fchrt. W\u00e4hle die Datei, die zu deinem Anwendungsfall passt. Wenn du dir nicht sicher bist, .bashrc<\/code><\/strong> ist f\u00fcr die meisten Szenarien die sichere Wahl.<\/p>\n\n\n\n
    Systemweite Umgebungsvariablen<\/h4>\n\n\n\n
    F\u00fcr Variablen, die jeder Benutzer auf dem System braucht, bearbeitest du \/etc\/environment<\/strong><\/code>:<\/p>\n\n\n\n
    sudo nano \/etc\/environment<\/code><\/pre>\n\n\n\n
    Trage einfache Schl\u00fcssel-Wert-Paare ohne das export<\/strong> <\/code>Schl\u00fcsselwort ein:<\/p>\n\n\n\n
    JAVA_HOME=\"\/usr\/lib\/jvm\/java-17\"<\/code><\/pre>\n\n\n\n
    Speichere die Datei und starte dann neu oder melde dich erneut an, damit die \u00c4nderungen wirksam werden.<\/p>\n\n\n\n
    Eine Alternative: Erstelle ein Shell-Skript in \/etc\/profile.d\/<\/code><\/strong>. Dieses Verzeichnis wird beim Login f\u00fcr alle Benutzer eingelesen:<\/p>\n\n\n\n
    sudo nano \/etc\/profile.d\/custom_env.sh<\/code><\/pre>\n\n\n\n
    In der Datei verwendest du export<\/strong> <\/code>wie gewohnt:<\/p>\n\n\n\n
    export LOG_LEVEL=\"info\"<\/code><\/pre>\n\n\n\n
    Gib der Datei einen aussagekr\u00e4ftigen Namen. Du wirst dir selbst danken, wenn das Verzeichnis 15 Skripte enth\u00e4lt und du genau das finden musst, das die Proxy-Konfiguration setzt. Starte neu, um die \u00c4nderungen zu \u00fcbernehmen, und pr\u00fcfe dann mit printenv<\/code><\/strong>. Der \/etc\/profile.d\/<\/code><\/strong> Ansatz ist \u00fcbersichtlicher, wenn du mehrere Gruppen von Variablen verwaltest, weil jeder Bereich seine eigene Datei bekommt.<\/p>\n\n\n\n
    Umgebungsvariablen in Linux l\u00f6schen<\/h3>\n\n\n\n
    Der unset<\/strong> <\/code>Befehl entfernt eine Umgebungsvariable aus der aktuellen Sitzung:<\/p>\n\n\n\n
    unset MY_VAR<\/code><\/pre>\n\n\n\n
    Weg. Aber nur f\u00fcr diese Sitzung. Wenn die Variable in ~\/.bashrc<\/code><\/strong> oder \/etc\/environment<\/code><\/strong> definiert ist, taucht sie nach einem Neustart wieder auf. Der unset<\/strong> <\/code>Befehl ist von Natur aus tempor\u00e4r.<\/p>\n\n\n\n
    Um eine Umgebungsvariable in Linux dauerhaft zu entfernen, \u00f6ffnest du die Konfigurationsdatei, in der sie definiert ist, und l\u00f6schst die Zeile (oder kommentierst sie aus). Auskommentieren ist sicherer und erspart dir sp\u00e4teren \u00c4rger:<\/p>\n\n\n\n
    # export API_URL=\"https:\/\/api.example.com\"<\/code><\/pre>\n\n\n\n
    Ein Hash-Zeichen am Anfang deaktiviert die Zeile, ohne sie zu l\u00f6schen. Wenn drei Wochen sp\u00e4ter die unvermeidliche Frage „Warum haben wir das entfernt?“ aufkommt, kannst du die Zeile in Sekunden wieder aktivieren, statt den Wert aus dem Ged\u00e4chtnis zu rekonstruieren.<\/p>\n\n\n\n
    Umgebungsvariablen in der Entwicklung nutzen<\/h2>\n\n\n\n
    Hier zeigen Umgebungsvariablen ihren wahren Wert. Wenn du Datenbank-Zugangsdaten, API-Schl\u00fcssel und Service-URLs als Umgebungsvariablen speicherst, bleiben sie aus deiner Codebasis heraus. Keine ‚Secrets‘ in der Versionskontrolle. Kein versehentliches Pushen eines Produktionsdatenbank-Passworts in ein \u00f6ffentliches GitHub-Repo. Falls du schon einmal ein Unternehmen in den Nachrichten wegen geleakter Zugangsdaten gesehen hast: Die Wahrscheinlichkeit ist gro\u00df, dass jemand genau diesen Schritt \u00fcbersprungen hat.<\/p>\n\n\n\n
    Das Muster funktioniert so: Du definierst f\u00fcr jede Stufe unterschiedliche Variablen:<\/p>\n\n\n\n
    export APP_ENV=\"staging\"<\/code><\/pre>\n\n\n\n
    export DB_HOST=\"staging-db.internal\"<\/code><\/pre>\n\n\n\n
    Beim Deployment in die Produktion tauschst du die Werte aus. Der Anwendungscode liest $APP_ENV<\/code><\/strong> und $DB_HOST<\/code><\/strong> und verh\u00e4lt sich entsprechend. Keine Code\u00e4nderungen zwischen den Umgebungen. Dasselbe Docker-Image, dasselbe Binary, dasselbe Skript l\u00e4uft \u00fcberall mit unterschiedlichem Verhalten, ausschlie\u00dflich gesteuert durch die vererbten Variablen.<\/p>\n\n\n\n
    Dieser Ansatz vereinfacht auch die Automatisierung. Ein Deployment-Skript kann Umgebungsvariablen setzen, bevor es eine Anwendung startet. So kommen alle Konfigurationswerte aus einer einzigen Quelle. Vergleiche das mit der Pflege separater Konfigurationsdateien pro Umgebung, wobei jede eine potenzielle Quelle f\u00fcr Abweichungen und Fehler ist. Drei Umgebungen mit je f\u00fcnf Konfigurationsdateien ergeben f\u00fcnfzehn Dateien, die synchron gehalten werden m\u00fcssen. Mit Umgebungsvariablen reduzierst du das auf einen einzigen Mechanismus.<\/p>\n\n\n\n
    Best Practices f\u00fcr Umgebungsvariablen<\/h2>\n\n\n\n
    Die Befehle zu kennen ist die halbe Miete. Der richtige Umgang damit macht den Unterschied zwischen einem sauberen System und einem, das auf r\u00e4tselhafte Weise ausf\u00e4llt.<\/p>\n\n\n\n
    Aussagekr\u00e4ftige Variablennamen verwenden<\/h3>\n\n\n\n
    VAR1<\/strong> sagt dir nichts. POSTGRES_CONNECTION_STRING<\/strong> sagt dir alles. Aussagekr\u00e4ftige Namen verhindern, dass du vor 40 exportierten Variablen sitzt und nicht herausfindest, welche das Log-Ausgabeverzeichnis steuert.<\/p>\n\n\n\n
    Halte dich an eine einheitliche Namenskonvention. Stelle zusammengeh\u00f6rigen Variablen den Anwendungs- oder Servicenamen voran: MYAPP_DB_HOST<\/strong>, MYAPP_DB_PORT<\/strong>, MYAPP_LOG_PATH<\/strong>. Wenn ein anderes Teammitglied deinen Server \u00fcbernimmt, wird es das System in Minuten statt in Stunden durchschauen. Vage Namen erzeugen Insiderwissen. Aussagekr\u00e4ftige Namen schaffen Dokumentation genau dort, wo sie tats\u00e4chlich gebraucht wird.<\/p>\n\n\n\n
    Variable Scopes korrekt handhaben<\/h3>\n\n\n\n
    Eine h\u00e4ufige Falle: Du erstellst eine Shell-Variable mit demselben Namen wie eine globale Umgebungsvariable. Die Shell wei\u00df dann nicht, welche du meinst, und pl\u00f6tzlich liest deine Anwendung den falschen Wert. Ich habe erlebt, wie das ein Produktions-Deployment lahmgelegt hat, weil jemand eine lokale PATH<\/strong> <\/code>\u00dcberschreibung vergessen hatte.<\/p>\n\n\n\n
    Verwende lokale (Shell-)Variablen f\u00fcr kurzlebige Aufgaben: einen Schleifenz\u00e4hler in einem Skript, einen tempor\u00e4ren Dateipfad, einen einmaligen Testwert. Verwende globale Umgebungsvariablen f\u00fcr alles, was prozess\u00fcbergreifend geteilt wird: Datenbank-URLs, Log-Level, Feature-Flags.<\/p>\n\n\n\n
    Halte dich an die Konvention. Kleinbuchstaben f\u00fcr lokale Shell-Variablen, Gro\u00dfbuchstaben f\u00fcr globale. PATH<\/strong> <\/code>ist systemweit. path_to_tmp<\/code><\/strong> ist nur f\u00fcr die Sitzung g\u00fcltig. Diese visuelle Unterscheidung sorgt f\u00fcr Klarheit.<\/p>\n\n\n\n
    Umgebungsvariablen regelm\u00e4\u00dfig \u00fcberpr\u00fcfen<\/h3>\n\n\n\n
    Variablen sammeln sich an. Alte API-Schl\u00fcssel bleiben liegen. Veraltete Service-URLs werden nicht aufger\u00e4umt. Jemand hat vor sechs Monaten ein Debug-Flag gesetzt und vergessen. Jetzt schreibt dein Produktionsserver ausf\u00fchrliche Logs auf eine Festplatte, die zu 94 % voll ist. Das passiert h\u00e4ufiger, als irgendjemand zugeben m\u00f6chte.<\/p>\n\n\n\n
    Speichere deine aktuellen Variablen regelm\u00e4\u00dfig in einer Datei:<\/p>\n\n\n\n
    set > env_audit_$(date +%Y%m%d).txt<\/code><\/pre>\n\n\n\n
    Vergleiche sie mit fr\u00fcheren Exporten. Entferne, was nicht mehr gebraucht wird. Rotiere Zugangsdaten, die in der Exportliste auftauchen. Stelle sicher, dass nichts Sensibles in eine systemweite Datei gelangt ist, die jeder Benutzer lesen kann. Das ist keine glamour\u00f6se Arbeit, aber genau die Art von Hygiene, die Sicherheitsvorf\u00e4lle und r\u00e4tselhafte Produktionsausf\u00e4lle verhindert. Betrachte es wie einen \u00d6lwechsel: langweilig, notwendig und katastrophal, wenn es vernachl\u00e4ssigt wird.<\/p>\n\n\n\n
    FAQ zu Linux-Umgebungsvariablen<\/h2>\n\n\n\n
    Wie kann ich Umgebungsvariablen in Linux anzeigen?<\/strong> 
    F\u00fchre printenv<\/strong> oder env<\/strong> aus, um alle Umgebungsvariablen aufzulisten. Mit echo $VARIABLE_NAME<\/strong> <\/code>pr\u00fcfst du eine bestimmte Variable. Der set<\/strong> <\/code>Befehl zeigt sowohl Shell- als auch Umgebungsvariablen zusammen an. Leite die Ausgabe eines dieser Befehle durch grep<\/strong><\/code>, um gezielt zu filtern. F\u00fcr eine scrollbare Ansicht aller Variablen probiere printenv | less<\/code><\/strong>.<\/p> <\/div> 
    Welche Arten von Umgebungsvariablen gibt es?<\/strong> 
    Linux kennt zwei Hauptkategorien. Lokale (Shell-)Variablen existieren nur in der aktuellen Sitzung und verschwinden, sobald du das Terminal schliesst oder eine Subshell startest. Globale Umgebungsvariablen bleiben \u00fcber Kindprozesse hinweg erhalten und gibt es in zwei Varianten: benutzerspezifisch (gespeichert in ~\/.bashrc<\/code><\/strong> oder ~\/.profile<\/code><\/strong>) und systemweit (gespeichert in \/etc\/environment<\/code><\/strong> oder als Skripte in \/etc\/profile.d\/<\/code><\/strong>).<\/p> <\/div> 
    Lokale vs. globale Umgebungsvariablen<\/strong> 
    Lokale Variablen sind auf die aktuelle Shell beschr\u00e4nkt. Starte eine Subshell, und sie sind weg. Globale Variablen werden an jeden Kindproze\u00df, jede Subshell und jedes Programm vererbt, das aus der Sitzung heraus gestartet wird. Wenn dein Skript einen Wert braucht und als Kindprozess l\u00e4uft, muss es eine globale (exportierte) Variable sein. Verwende Kleinbuchstaben f\u00fcr lokale und Gro\u00dfbuchstaben f\u00fcr globale Variablen, um sie eindeutig zu unterscheiden.<\/p> <\/div> 
    Wo werden Umgebungsvariablen in Linux gespeichert?<\/strong> 
    Benutzerspezifische persistente Variablen stehen typischerweise in ~\/.bashrc<\/code><\/strong> oder ~\/.profile<\/code><\/strong> im Home-Verzeichnis des Benutzers. Systemweite Variablen geh\u00f6ren in \/etc\/environment<\/code><\/strong> oder als einzelne Shell-Skripte in \/etc\/profile.d\/<\/code><\/strong>. Tempor\u00e4re Variablen existieren nur im Speicher der aktuellen Sitzung und werden in keiner Datei gespeichert. Sie verschwinden beim Logout oder Neustart.<\/p> <\/div> 
    Wie f\u00fcge ich eine Umgebungsvariable in Linux hinzu?<\/strong> 
    F\u00fcr eine tempor\u00e4re Variable verwendest du export VAR=\"value\"<\/code><\/strong> im Terminal. Trage dieselbe ‚export‘-Zeile in ~\/.bashrc<\/code><\/strong> ein und f\u00fchre source ~\/.bashrc<\/code><\/strong> aus, um sie sofort zu laden. So wird daraus eine permanente, benutzerspezifische Variable. F\u00fcr eine systemweite Variable tr\u00e4gst du das Schl\u00fcssel-Wert-Paar in \/etc\/environment<\/code><\/strong> (ohne das ‚export‘-Schl\u00fcsselwort) ein und startest neu oder meldest dich erneut an.<\/p> <\/div> <\/div>\n","protected":false},"excerpt":{"rendered":"
    Jeder Linux-Prozess erbt einen Satz Umgebungsvariablen von seinem Elternprozess. Diese Schl\u00fcssel-Wert-Paare steuern das Verhalten von Shells, legen fest, wo Programme nach ausf\u00fchrbaren Dateien suchen, und bestimmen, welche Konfiguration eine laufende Anwendung verwendet. Stimmt etwas nicht, geht dein Deployment um 2 Uhr nachts kaputt. Stimmt alles, hast du eine saubere, portable Systemkonfiguration, die mit deinem Benutzerprofil […]<\/p>\n","protected":false},"author":44,"featured_media":28638,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"_uag_custom_page_level_css":"","site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1399],"tags":[1443],"ppma_author":[3402],"class_list":["post-29601","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tutorials","tag-linux-de"],"uagb_featured_image_src":{"full":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE.webp",1200,630,false],"thumbnail":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE-150x150.webp",150,150,true],"medium":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE-600x315.webp",600,315,true],"medium_large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE-768x403.webp",768,403,true],"large":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE.webp",1200,630,false],"1536x1536":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE.webp",1200,630,false],"2048x2048":["https:\/\/contabo.com\/blog\/wp-content\/uploads\/2026\/02\/blog-head_guide-set-and-list-linux-environment-variables_DE.webp",1200,630,false]},"uagb_author_info":{"display_name":"Milan Ivanovic","author_link":"https:\/\/contabo.com\/blog\/de\/author\/milan\/"},"uagb_comment_info":0,"uagb_excerpt":"Jeder Linux-Prozess erbt einen Satz Umgebungsvariablen von seinem Elternprozess. Diese Schl\u00fcssel-Wert-Paare steuern das Verhalten von Shells, legen fest, wo Programme nach ausf\u00fchrbaren Dateien suchen, und bestimmen, welche Konfiguration eine laufende Anwendung verwendet. Stimmt etwas nicht, geht dein Deployment um 2 Uhr nachts kaputt. Stimmt alles, hast du eine saubere, portable Systemkonfiguration, die mit deinem Benutzerprofil…","authors":[{"term_id":3402,"user_id":0,"is_guest":1,"slug":"contabro","display_name":"ContaBro","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","0":null,"1":"","2":"","3":"","4":"","5":"","6":"","7":"","8":""}],"_links":{"self":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29601","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/users\/44"}],"replies":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/comments?post=29601"}],"version-history":[{"count":8,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29601\/revisions"}],"predecessor-version":[{"id":29646,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/posts\/29601\/revisions\/29646"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media\/28638"}],"wp:attachment":[{"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/media?parent=29601"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/categories?post=29601"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/tags?post=29601"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/contabo.com\/blog\/de\/wp-json\/wp\/v2\/ppma_author?post=29601"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}