Wenn du schon einmal an der Entwicklung einer Anwendung gearbeitet hast, hast du sicher schon von dem Begriff „Umgebungsvariablen“ gehört Umgebungsvariablen werden verwendet, um Anwendungsgeheimnisse und Konfigurationsdaten zu speichern, die bei Bedarf von deiner laufenden Anwendung abgerufen werden.
Umgebungsvariablen verleihen deiner statischen Codebasis mehr Dynamik: Du kannst zwischen internen und externen Ressourcen umschalten, je nachdem, welchen Wert die Umgebungsvariable deiner Anwendung übergibt.
In diesem Artikel werden wir Umgebungsvariablen für dich aufschlüsseln. Du lernst einige gängige Methoden kennen, um Umgebungsvariablen zu erstellen und zu verwalten, und erfährst, wann du sie einsetzen solltest. Am Ende dieses Artikels wirst du in der Lage sein, Umgebungsvariablen in deinen Anwendungen effektiv und sicher zu nutzen.
Ohne Umschweife, lass uns beginnen!
Was ist eine Umgebungsvariable?
Wie oben bereits erklärt, sind Umgebungsvariablen Variablen, die deinem Programm/ deiner Anwendung während der Laufzeit dynamisch zur Verfügung stehen. Der Wert dieser Variablen kann aus einer Reihe von Quellen stammen – Textdateien, Sekretariatsmanager von Drittanbietern, aufrufende Skripte usw.
Wichtig dabei ist, dass der Wert dieser Umgebungsvariablen nicht fest in deinem Programm kodiert ist. Sie sind wirklich dynamisch und können je nach der Umgebung, in der dein Programm läuft, geändert werden.
Arten von Umgebungsvariablen
Es gibt drei wichtige Arten von Umgebungsvariablen in einem Windows-basierten Computersystem, und jede von ihnen hat ihre Anwendungsfälle. Lass uns eine nach der anderen besprechen.
1. Systemumgebungsvariablen
Systemumgebungsvariablen befinden sich im obersten Stammverzeichnis des Systems und sind für alle Prozesse, die in einem System unter allen Benutzerprofilen des Systems laufen, identisch. Normalerweise werden sie von deinem Betriebssystem/Systemadministrator festgelegt und du musst dich nur selten damit befassen.
Eine der häufigsten Verwendungen einer Systemumgebungsvariable ist das Einrichten einer PATH -Variable für ein globales Paket/eine globale Bibliothek, das/die von allen Benutzern im System verwendet werden soll.
2. Benutzer-Umgebungsvariablen
Benutzerumgebungsvariablen sind die Variablen, die in Windows-Systemen lokal für ein Benutzerprofil sind. In diesen Variablen werden benutzerspezifische Informationen gespeichert, z. B. der Pfad zu einer lokalen Installation von Bibliotheken, die nicht von allen Benutzern verwendet werden sollen, Werte für Programme, die nur für bestimmte Benutzer installiert werden, usw.
Du brauchst den Systemadministrator nicht, um Änderungen an diesen Variablen vorzunehmen; das kannst du als Benutzer selbst tun. Diese Variablen sind hilfreich, wenn du lokale Änderungen an deinem System vornimmst, ohne dass andere Benutzer davon betroffen sind.
3. Laufzeit-/Prozessumgebungsvariablen
Laufzeit-Umgebungsvariablen werden nur auf die Laufzeit oder den Prozess eingegrenzt, mit dem sie verbunden sind. Sie werden in der Regel von dem übergeordneten Prozess gesetzt, der den neuen Prozess erstellt, und werden von den System- und Benutzerumgebungsvariablen begleitet.
Du kannst Terminal-Skripte verwenden, um diese Variablen im laufenden Betrieb zu erstellen und zu speichern. Laufzeitvariablen sind in der Regel nicht dauerhaft, es sei denn, sie werden per Skript gesetzt, und du musst sie jedes Mal definieren, wenn du einen neuen Prozess startest.
Umgebungsvariablen in Unix-basierten Systemen
Im Gegensatz zu Windows-Systemen gibt es bei Unix-Systemen keine drei Schichten von Umgebungsvariablen. In solchen Systemen wird alles unter einem var Objekt gespeichert und kann von dem laufenden Programm aufgerufen/geändert werden.
Wenn du einige Umgebungsvariablen als Standard festlegen möchtest, die jedes Mal geladen werden, wenn ein Programm auf deinem System läuft, musst du sie in Dateien wie .~/bashrc oder ~.profile definieren, die beim Hochfahren des Systems geladen werden.
Umgebungsvariablen vs. Pseudo-Umgebungsvariablen
In Windows- und DOS-basierten Systemen gibt es eine eigene Reihe von dynamischen Umgebungsvariablen, die so genannten Pseudo-Umgebungsvariablen. Dabei handelt es sich nicht um statisch zugewiesene Paare von Schlüsseln und Werten, sondern um dynamische Referenzen, die bei Abfrage verschiedene Werte zurückgeben.
Während du einer Umgebungsvariablen manuell einen Wert zuweisen kannst, indem du den Befehl SET oder ein ähnliches Kommando verwendest, kannst du Pseudo-Umgebungsvariablen keine Werte zuweisen. Es gibt eine feste Liste solcher Variablen, und du kannst sie in deinem Code verwenden, um dir die Arbeit zu erleichtern. Einige beliebte Anwendungsfälle sind %CD% für das aktuelle Verzeichnis und %TIME% für die aktuelle Uhrzeit.
Warum solltest du Umgebungsvariablen verwenden?
Jetzt, wo du weißt, was eine Umgebungsvariable ist und welche verschiedenen Typen es gibt, ist es an der Zeit zu erfahren, warum du sie in deinen Anwendungen ausgiebig nutzen solltest.
Trennung der Bereiche
Einer der wichtigsten Gründe, warum du Umgebungsvariablen in deinen Anwendungen verwenden solltest, ist die Einhaltung eines beliebten und nützlichen Designprinzips – der Trennung von Belangen. Dieses Prinzip besagt, dass Computerprogramme in verschiedene Abschnitte unterteilt werden sollten, um sie effizient zu verwalten. Jeder Abschnitt sollte sich auf eines der Hauptanliegen des Programms stützen, und zwischen diesen Abschnitten sollte es nur eine minimale Kopplung geben.
Die Anwendungskonfiguration kann als eines dieser Anliegen betrachtet werden und muss daher vom Hauptprogramm getrennt werden. Eine der besten Möglichkeiten dafür ist, sie in einer externen Datei zu speichern und sie bei Bedarf einzubinden. Umgebungsvariablen helfen dir, kritische Daten zur Anwendungskonfiguration mithilfe von Umgebungsdateien oder externen Variablenspeichern zu isolieren. Auf diese Weise werden deinen Entwicklern nur die Informationen zur Verfügung gestellt, die sie benötigen.
Unabhängige Konfigurationssätze in verschiedenen Umgebungen aufrechterhalten
Du musst nicht nur die Anwendungskonfigurationen von deinem Quellcode isolieren, sondern auch in der Lage sein, problemlos zwischen den einzelnen Konfigurationsdaten zu wechseln. Wenn du deine App-Konfigurationswerte im Quellcode fest einträgst, kann es fast unmöglich sein, diese Werte je nach äußeren Bedingungen, wie z. B. der Einsatzumgebung, zu ersetzen.
Die Verwendung von Umgebungsvariablen hilft dir dabei, deine Konfigurationsdaten von deinem Code zu entkoppeln und die Art und Weise zu standardisieren, wie diese Informationen deiner Anwendung zur Verfügung gestellt werden, so dass du die bereitgestellten Informationen im Handumdrehen ändern oder austauschen kannst.
Geheimnisse sichern
Die Geheimnisse deiner App fallen unter die sensiblen Informationen. Wenn die falschen Leute sie in die Hände bekommen, können sie auf die interne Architektur deiner App und auf die Ressourcen Dritter zugreifen. Häufige Beispiele sind AWS-Schlüssel und Systemkontodaten. Der unbefugte Zugriff auf diese Schlüssel kann zum Verlust von Geld und Anwendungsdaten führen. Hacker können sogar so weit gehen, dass sie deine App am normalen Betrieb hindern.
Deshalb ist es wichtig, dass du diese Geheimnisse schützt. Wenn du sie in deiner Codebasis herumliegen lässt, kann das dazu führen, dass alle deine Entwickler/innen Zugang zu ihnen haben. Wenn du nicht die richtigen Methoden zur Codeverschleierung anwendest, können deine Anwendungen zurückentwickelt werden, um an die Schlüssel in deinem Code zu gelangen. Die Isolierung dieser Geheimnisse durch Umgebungsvariablen kann solche Szenarien verhindern.
Beispiele für die Verwendung von Umgebungsvariablen
Nachdem du nun eine klare Vorstellung davon hast, wie Umgebungsvariablen funktionieren und wie du sie effektiv einsetzen solltest, folgen nun einige häufige Szenarien, in denen du Umgebungsvariablen verwenden kannst:
- Umgebungstyp: Umgebungsvariablen werden oft verwendet, um den Namen der Umgebung zu speichern, in der die App gerade läuft. Die Logik der App kann diesen Wert nutzen, um auf die richtigen Ressourcen zuzugreifen oder bestimmte Funktionen oder Bereiche der App zu aktivieren/deaktivieren.
- Domainname: Der Domainname einer Anwendung kann je nach Umgebung variieren. Wenn du ihn isolierst, kannst du den Domainnamen deiner Anwendung leicht ändern, ohne ihn in der gesamten Codebasis suchen zu müssen.
- API-URLs: Jede Umgebung deiner Anwendung kann über APIs verfügen, die auch in anderen Umgebungen eingesetzt werden.
- Private Schlüssel: Schlüssel zu bezahlten Diensten und Ressourcen müssen vom Quellcode der App isoliert werden, damit sie nicht versehentlich in die falschen Hände geraten.
- Servicekontonummern usw.: Du kannst andere systemspezifische Informationen wie Servicekontonummern, Keytabs usw. je nach Umgebung der App für die Ressourcenverwaltung und -überwachung variieren.
Wie man Umgebungsvariablen speichert
Jetzt, wo du weißt, warum Umgebungsvariablen wichtig sind, ist es an der Zeit, sich anzusehen, wie du sie in deiner Anwendung speichern und darauf zugreifen kannst. Im Folgenden werden drei verschiedene, aber beliebte Methoden zur Verwaltung von Umgebungsvariablen in einer Anwendung beschrieben.
.env-Dateien verwenden
.env dateien sind zweifelsohne die einfachste und beliebteste Art, Umgebungsvariablen zu verwalten. Die Idee ist einfach: Du speicherst deine Umgebungsvariablen in einer Datei namens .env im Stammverzeichnis deines Projekts. Die Anwendung sucht nach den Variablen in dieser Datei und lädt sie zur Verwendung während der Laufzeit. So sieht eine typische .env Datei aus:
VAR_UNO=SOME_KEY_HERE
VAR_DOS=SOME_OTHER_KEY_HERE
.env dateien ermöglichen es dir auch, Gruppen von Umgebungsvariablen zu definieren und auf sie basierend auf der Laufzeitumgebung deiner Anwendung oder anderen Faktoren zuzugreifen. Anstatt die Datei einfach als .env zu speichern, kannst du auch mehrere Dateien erstellen und sie als .env.dev und .env.prod speichern. In diesen Dateien kannst du dieselben Variablensätze definieren, allerdings mit unterschiedlichen Werten, je nach Umgebung.
Beispiel Vorlage
Wenn du mit .env Dateien arbeitest, ist es nicht empfehlenswert, sie in dein Versionskontrollsystem aufzunehmen (mehr dazu später). Deshalb solltest du in deinem Projekt eine „.env.template“ definieren, damit die Entwickler der Vorlage folgen und eine .env Datei für sich selbst lokal erstellen können.
So würde eine .env.template Datei aussehen:
VAR_UNO= # Your value here
VAR_DOS= # Your value here
Sie muss keinen Konventionen folgen, so lange sie für dein Entwicklungsteam selbsterklärend ist. Um diesen Prozess zu vereinfachen, kannst du auch Pakete wie env-template verwenden.
Pro
Hier sind einige Gründe, warum du .env Dateien zur Verwaltung von Umgebungsvariablen in deiner App verwenden solltest.
Einfach zu verwenden
Diese Methode ist die einfachste in der Reihe der Techniken zur Verwaltung von Umgebungsvariablen. Alles, was du tun musst, ist, eine einfache Textdatei zu erstellen, die deine Geheimnisse enthält, und sie im Stammverzeichnis deines Projekts zu speichern.
Der Wechsel der Umgebung ist so einfach wie das Ändern der env-Datei selbst. Du kannst mehrere Dateien unter den Namen .env.dev, .env.prod, .env.uat usw. speichern und deinen Quellcode so konfigurieren, dass er je nach Umgebung auf diese Dateien zugreift.
Lokaler Zugriff
Du kannst .env Dateien ganz einfach in einer lokalen Entwicklungsumgebung einrichten. Im Gegensatz zu plattformspezifischen Variablenmanagern musst du deine Anwendung nicht bereitstellen, um die Funktionen der Umgebungsvariablen zu nutzen. Im Vergleich zu Secret Managern lassen sich .env Dateien einfacher lokal einrichten, und es besteht keine Netzwerkabhängigkeit für den Zugriff auf die Secrets deiner App.
Open-Source-Unterstützung
Es gibt zahlreiche Open-Source-Pakete, mit denen du App-Secrets aus env Dateien laden und verwalten kannst. Du bist weder auf kostenpflichtige Dienste angewiesen, noch sind deine Möglichkeiten bei der Verwaltung von App-Secrets begrenzt. Es gibt eine große Auswahl an Open-Source-Bibliotheken von Drittanbietern, die dir bei der Verwaltung deiner Umgebungsdateien helfen. Einige beliebte und nützliche Beispiele sind dotenv, env-template und cross-env.
Nachteile
Hier sind einige Nachteile von env-Dateien, die du kennen solltest, bevor du sie in deinen Projekten einsetzt.
Formatierung
.env dateien speichern die Geheimnisse deiner Anwendung in Form von Schlüssel-Wert-Paaren. Das übliche Format für die Speicherung von Umgebungsvariablen in einer .env Datei ist:
Key1=Value1
Du musst dich strikt an dieses Format halten, damit deine App deine App-Geheimnisse erfolgreich lesen kann. Wenn du irgendwo zwischen zehn oder hunderten von Zeilen mit Umgebungsvariablen einen kleinen Fehler machst, kann es sein, dass die gesamte Datei nicht geparst wird und dein Programm unzusammenhängende Fehler ausgibt. Die Tatsache, dass es einen Parsing-Fehler in deiner .env Datei gibt, wird vielleicht nicht einmal hervorgehoben. Aus diesem Grund musst du bei der Verwendung von .env Dateien vorsichtig sein.
Anfällig für unbeabsichtigte Geheimnisträger beim Teilen/Speichern
Da es sich bei .env Dateien um reine Textdateien handelt, sind sie anfällig für eine versehentliche Preisgabe, wenn sie auf einer gemeinsam genutzten Festplatte gespeichert oder über ein ungesichertes Netzwerk verschickt werden. Deshalb musst du besonders darauf achten, dass deine App-Geheimnisse nicht nach außen dringen, wenn du sie in .env Dateien gespeichert hast.
Plattformspezifische Variablenspeicherung verwenden
Eine weitere beliebte Option für die Speicherung von Umgebungsvariablen ist die Verwendung des Variablenspeichers deiner Bereitstellungsplattform. Die meisten Bereitstellungsplattformen wie Heroku, AWS, Netlify usw. bieten einen Bereich, in den Nutzer/innen Geheimnisse hochladen können, die später in die Laufzeit deiner Anwendung eingefügt werden. Du kannst in der Dokumentation deiner Bereitstellungsplattform nachsehen, ob sie diese Funktion unterstützt und wie du sie nutzen kannst.
Hier ist ein kurzer Blick auf den Umgebungsvariablen-Manager von Netlify:
Pro
Hier sind die Gründe, warum du plattformspezifische Lösungen zur Speicherung von Variablen in Betracht ziehen solltest.
Hochgradig sicher
Da diese Option vollständig von deiner Bereitstellungsplattform verwaltet wird, ist sie mit Sicherheit sicherer als die Speicherung deiner Geheimnisse in einer einfachen Textdatei. Du kannst kontrollieren, wer Zugriff auf den Variablenmanager hat, und du kannst sicher sein, dass die Geheimnisse nicht versehentlich in dein VCS übertragen werden.
Einfach zu aktualisieren
Die Aktualisierung der Umgebungsvariablen ist einfacher, wenn sie unabhängig gespeichert werden – du musst deinen Quellcode nicht bearbeiten und eine neue Version dafür erstellen. Du kannst einfach die Werte in der Plattform ändern und dein Projekt neu erstellen. Beim nächsten Start erhält es dann die neuen Werte.
Auch Formatierungsprobleme gehören der Vergangenheit an, da die meisten plattformspezifischen Deployment Manager die Schlüssel bei der Eingabe färben. In Fällen wie dem von Netlify gibst du die Geheimnisse in einer vorformatierten Form ein, so dass die Gefahr eines Formatierungsfehlers ausgeschlossen ist.
Ermöglicht Kollaboration
Da dein gesamtes Team auf die Verteilungsplattformen zugreifen kann, kannst du die Geheimnisse ganz einfach mit den richtigen Personen teilen, ohne dass du Textdateien über das Internet verschicken musst. Du kannst bestimmen, wer auf den Variablenmanager zugreifen darf (in den meisten Fällen) und ihn als zentrales Repository für deine App-Geheimnisse nutzen.
Nachteile
Obwohl plattformspezifische Variablenmanager genau die Lösung zu sein scheinen, die du brauchst, gibt es ein paar Dinge, die du beachten solltest, bevor du dich für sie entscheidest.
Plattformabhängig
Wie ihr Name schon sagt, sind sie sehr spezifisch für die Plattform, die du verwendest. In manchen Fällen bietet deine Bereitstellungsplattform einen solchen Dienst gar nicht an. Ein Wechsel deiner Einsatzplattform, um Zugang zu einem solchen Dienst zu erhalten, ist vielleicht nicht die beste Entscheidung.
Uneinheitlich
Da sie vollständig von der Bereitstellungsplattform angeboten und verwaltet werden, können solche Dienste sehr uneinheitlich sein. Die Übertragung von Variablen von einer Plattform auf eine andere kann problematisch sein. Du kannst nicht einmal davon ausgehen, dass jede Bereitstellungsplattform die Möglichkeit bietet, Umgebungsvariablen zu importieren/exportieren. Die meisten tun dies zwar, aber es liegt ganz in der Hand der Plattform. Wenn du eine lange Liste von Umgebungsvariablen hast, ist die Wahrscheinlichkeit groß, dass du in eine kleine Anbieterbindung gerätst.
Keine lokale Unterstützung
Während solche Dienste für den Zugriff auf Umgebungsvariablen in den Deployments deiner App gut geeignet sind, kannst du sie bei der lokalen Entwicklung deiner App nur selten nutzen. In den meisten Fällen musst du auf die Verwaltung lokaler .env Dateien zurückgreifen. Das erfüllt zwar den Zweck, verkompliziert aber die ganze Einrichtung unnötig.
Verwendung von Secret Managern
Die dritte Option, die sich noch in der Entwicklungsphase befindet, ist der Einsatz von speziellen Secret Managern. Secret Manager sind Dienste von Drittanbietern, die es dir ermöglichen, die Geheimnisse deiner App vollständig von deinem Quellcode bzw. deinem Deployment zu isolieren und sie bei Bedarf über sichere Netzwerkverbindungen abzurufen.
Pro
Hier sind einige der Vorteile, die Secret Manager gegenüber anderen Methoden der Geheimnisverwaltung bieten.
Hochgradig sicher
Da deine Geheimnisse in einem vollständig isolierten Dienst gespeichert werden, kannst du sicher sein, dass du sie nicht versehentlich preisgibst, wenn du sie mit deinen Kollegen oder über Versionskontrollübertragungen teilst. Die Plattform des Drittanbieters kümmert sich um die Sicherheit deiner Geheimnisse und hat in der Regel sehr strenge SLAs, wenn es um die Datensicherheit geht.
Selbst wenn du von deiner Anwendung aus auf die Geheimnisse zugreifst, bieten die meisten Geheimnisverwalter einen eigenen Client-Code an, der die Geheimnisse bei Bedarf sicher abrufen und den Zugriff darauf ermöglichen kann.
Einheitlich in verschiedenen Umgebungen
Da die Geheimnisse jetzt unabhängig von deiner Codebasis und deinen Einsatzumgebungen sind, kannst du sie in allen Umgebungen einheitlich nutzen. Du musst keine besonderen Vorkehrungen für das Onboarding neuer Entwickler/innen treffen oder besondere Schritte unternehmen, bevor du deine App in die Produktion überführst – die meisten dieser Aspekte werden vereinfacht oder von deinem Secrets Manager übernommen.
Nachteile
Obwohl Secrets Manager die bestmögliche Lösung für die Verwaltung von Umgebungsvariablen zu sein scheinen, haben sie auch ihre Probleme.
Kosten
Die Verwaltung von Umgebungsvariablen ist seit langem eine interne Aktivität innerhalb von Projekten. Sogar die meisten Bereitstellungsplattformen bieten diese Funktion kostenlos an, da ihnen keine zusätzlichen Kosten dafür entstehen.
Da es sich bei den Secret Managern jedoch um völlig unabhängige Dienste handelt, haben sie ihre eigenen Betriebskosten. Daher müssen die Nutzer/innen diese Kosten tragen, wenn sie diese Dienste nutzen.
Frühe Stadien der Technologie
Da die Technologie noch relativ neu ist, kann man nie sicher sein, wie gut sie in den nächsten Tagen von der Branche angenommen wird. Auch wenn geheime Manager in Bezug auf Sicherheit und einfache Verwaltung sehr vielversprechend sind, könnten der Kostenfaktor und die Bedenken bezüglich der Datenverarbeitung dazu führen, dass die Technologie nur langsam angenommen wird.
Wie man mit Umgebungsvariablen arbeitet
Nachdem du nun das Konzept der Umgebungsvariablen und die Möglichkeiten, sie in eine App zu implementieren, verstanden hast, schauen wir uns an, wie du mit ihnen über das Terminal und in Node.js-basierten Apps arbeiten kannst.
Umgebungsvariablen im Terminal
Da Umgebungsvariablen prozessspezifisch sind, kannst du sie über das Terminal setzen und löschen, damit sie an die Prozesse weitergegeben werden, die dein Terminal startet.
Variablenwerte finden
Um die Liste der Umgebungsvariablen in deinem Terminal anzuzeigen, kannst du die folgenden, für dein Betriebssystem spezifischen Befehle ausführen.
Unter Windows:
set
Unter Linux oder MacOS:
env
Damit wird eine Liste aller verfügbaren Umgebungsvariablen in deinem laufenden Terminal ausgegeben.
Neue Variablen setzen
Um neue Variablen über das Terminal zu setzen, kannst du die folgenden Befehle ausführen.
Unter Windows:
set "VAR_NAME=var_value"
Unter Linux oder MacOS:
VAR_NAME=var_value
Löschen von Variablen
Um eine Umgebungsvariable zu löschen, musst du die folgenden Befehle ausführen.
Unter Windows:
set "VAR_NAME="
Unter Linux oder MacOS:
unset VAR_NAME
Bitte beachte, dass die oben beschriebenen Methoden nur für das Erstellen/Löschen von Umgebungsvariablen für die aktuelle Sitzung des Terminals gelten.
Umgebungsvariablen in Node.js
JavaScript ist derzeit eine der beliebtesten Programmiersprachen. Sie wird sowohl für die Entwicklung von Backend- als auch von Front-End-Anwendungen verwendet und ist damit eine der vielseitigsten Programmiersprachen.
Node.js gehört zu den am häufigsten verwendeten JS-Frameworks für die Erstellung von Backend-Anwendungen. Schauen wir uns an, wie du Umgebungsvariablen in Node.js-basierten Anwendungen einfach handhaben kannst.
Direkter Zugriff auf Umgebungsvariablen
Node.js bietet dir über process.env einen Verweis auf die Umgebungsvariablen deines aktuellen Prozesses. Du kannst die verfügbaren Umgebungsvariablen einsehen, indem du dieses Objekt auf der Konsole ausgibst.
Dieses Objekt enthält Variablen, die für den laufenden Node-Prozess verfügbar sind. Du kannst neue Variablen hinzufügen, indem du sie vor der Ausführung deiner App deklarierst, ähnlich wie hier:
VAR_UNO=SOMETHING node index.js
Wie du sehen kannst, wird die neue Variable zu deinem process.env Objekt hinzugefügt. Allerdings kannst du mit dieser Methode nicht auf Variablen zugreifen, die unter einer .env Datei definiert sind. Dazu musst du ein Paket wie dotenv verwenden, um die Datei .env zur Laufzeit zu laden.
Das Paket dotenv für den Zugriff auf .env-Dateien verwenden
Das Paket dotenv hilft dir, Umgebungsvariablen zu laden, die in .env Dateien im Stammverzeichnis deines Projekts gespeichert sind. Seine Verwendung ist einfach: Du musst es mit dem folgenden Befehl installieren:
npm i [email protected]
Als Nächstes musst du die folgende Codezeile am Anfang des Codes deiner Anwendung einfügen, um das Paket zu initialisieren:
require('dotenv').config()
Das war’s! Jetzt werden die Geheimnisse, die du in einer .env Datei im Stammverzeichnis deines Projekts gespeichert hast, in dein process.env Objekt geladen, sobald die App startet. Wir werden diese Methode später im folgenden Lernprogramm in Aktion sehen.
Tutorial zu Umgebungsvariablen
Der beste Weg, ein technisches Konzept zu verstehen, ist, es in Aktion zu sehen. Hier ist ein kurzes Tutorial, das dir hilft, mit Umgebungsvariablen umzugehen und ihre Verwendung im Detail zu lernen.
In der folgenden Anleitung zeigen wir dir, wie du Umgebungsvariablen auf die drei oben genannten Arten nutzen kannst:.env Dateien, plattformspezifische Variablenmanager und geheime Manager. Alle diese Wege erfordern einen gemeinsamen Schritt, nämlich die Einrichtung eines einfachen Node.js-Projekts.
Erstens: Ein Node.js-Projekt erstellen
Stelle zunächst sicher, dass du Node.js auf deinem System installiert hast. Sobald du Node.js auf deinem System eingerichtet hast, hast du Zugriff auf npm (kurz für Node Package Manager). npm hilft dir, Node-Pakete aus der globalen npm-Registry über die Kommandozeile zu installieren. Das ist besonders nützlich, wenn du Pakete für unser Testprojekt installieren willst.
Als nächstes öffnest du ein Terminal und erstellst ein neues Verzeichnis. Lege darin ein neues Node-Projekt an:
mkdir my-app
cd my-app
npm init
Drücke bei den eingehenden Fragen immer wieder die Eingabetaste, um die Standardoptionen zu akzeptieren. Danach sieht dein Terminal etwa so aus:
Jetzt kannst du dieses Projekt mit einer IDE wie Visual Studio Code oder IntelliJ IDEA öffnen.
Erstelle eine neue Datei im Stammverzeichnis deines Projektordners und speichere sie unter dem Namen index.js. Dies wird der Ausgangspunkt für deine Anwendung sein. Als Nächstes installierst du Express, um schnell REST-Server zu erstellen und zu testen:
npm i express
Sobald du Express installiert hast, füge den folgenden Code in deine index.js Datei ein:
const express = require("express")
const app = express()
app.get("/", (req, res) => {
res.send("Hello world!")
})
app.listen(8080);
Dies ist ein erstes Snippet für einen einfachen „Hello World“-Endpunkt mit Node.js und Express. Führe den folgenden Code in deiner Kommandozeile aus:
node index.js
Damit startest du deine Node + Express App. Wenn du in deinem Webbrowser zu http://localhost:8080 navigierst, erhältst du eine ähnliche Ausgabe:
Das zeigt dir, dass du deine App richtig eingerichtet hast! Im nächsten Schritt musst du deine App so anpassen, dass sie Umgebungsvariablen verwendet. Ändere den Code in index.js so ab, dass er dem folgenden Schnipsel entspricht:
const express = require("express")
const app = express()
app.get("/", (req, res) => {
// the responseMessage object extracts its values from environment variables
// If a value is not found, it instead stores the string "not found"
const responseMessage = {
environment: process.env.environment || "Not found",
apiBaseUrl: process.env.apiBaseUrl || "Not found"
}
res.send(responseMessage)
})
app.listen(8080);
Statt einer „Hello world!“-Nachricht in der Antwort senden wir jetzt ein JSON-Objekt, das zwei Informationen enthält:
environment: Zeigt die aktuelle Umgebung an, in der die App eingesetzt wirdapiBaseUrl: Überträgt die Basis-URL für eine hypothetische API. Wir werden den Wert dieser URL je nach der Umgebung, in der die App eingesetzt wird, ändern.
Falls wir nicht auf die Umgebungsvariablen zugreifen können, enthält das Objekt „Not found“ als Werte für die beiden oben beschriebenen Schlüssel. Bevor du weitermachst, führe den Befehl node index.js erneut aus und du erhältst die folgende Ausgabe:
env Variablen.Das bedeutet, dass deine App derzeit nicht auf die Umgebungsvariablen zugreifen kann. Außerdem haben wir noch nicht einmal die Werte für diese Variablen definiert. In den nächsten Abschnitten sehen wir uns die verschiedenen Möglichkeiten an, dies zu tun.
Typ 1: Umgebungsvariablen über env-Dateien hinzufügen
Beginnen wir mit der einfachsten Art, Umgebungsvariablen hinzuzufügen – env-Dateien. Erstelle im Stammverzeichnis deines Projekts eine neue Datei namens .env und speichere den folgenden Code darin:
environment=DEV
apiBaseUrl=http://dev.myApi.com:8080/v1
Starte deine App neu, indem du den Befehl node index.js noch einmal ausführst und überprüfe die Ausgabe:
env.Du wirst feststellen, dass die Ausgabe immer noch die gleiche ist. Das liegt daran, dass du zwar die Werte der Umgebungsvariablen definiert hast, aber deiner Anwendung nicht wirklich gesagt hast, wo sie sie finden kann. An dieser Stelle kommen Pakete wie dotenv ins Spiel.
Führe den folgenden Befehl aus, um dotenv zu installieren:
npm i [email protected]
Um dotenv in deinem Code zu verwenden, füge den folgenden Code in Zeile 2 deiner index.js ein:
require('dotenv').config()
Starte dann die App neu und prüfe die Ausgabe:
env.Wie du sehen kannst, wurden die Werte für die Umgebungsvariablen aus deiner .env Datei geladen!
Um die Sache etwas aufzupeppen, benennen wir unsere Datei .env in .env.dev um und erstellen eine weitere Datei mit dem Namen .env.staging. Füge das folgende Stück Code in die neue Datei ein:
environment=STAGING
apiBaseUrl=http://staging.myApi.com:3000/v1
Wenn du damit fertig bist, ersetze die Zeile Nummer 2 deiner index.js Datei durch den folgenden Code:
require('dotenv').config({
path: "STAGING" === process.env.NODE_ENV?.toUpperCase() ? './.env.staging' : './.env.dev'
})
console.log(process.env.NODE_ENV)
Was sich hier geändert hat, ist, dass wir jetzt das Paket dotenv anweisen, den Inhalt der Umgebungsvariablen aus einer der beiden verfügbaren Dateien zu holen, die auf einer anderen Umgebungsvariablen namens NODE_ENV basiert. Woher kommt der Wert dieser Umgebungsvariablen? Deinem Terminal.
Um diese Einrichtung zu testen, führe deine App mit dem folgenden Befehl aus:
NODE_ENV=DEV node index.js
Wenn du jetzt localhost:8080 aufrufst, wirst du die folgende Antwort erhalten:
Beende nun die laufende App und starte sie erneut mit dem folgenden Befehl:
NODE_ENV=STAGING node index.js
Wenn du localhost:8080 aufrufst, erhältst du die folgende Antwort:
So kannst du die .env Dateien verwenden, um auf verschiedene Variablensätze zuzugreifen, die von externen Bedingungen abhängen. Die externe Bedingung ist hier die externe Umgebungsvariable NODE_ENV, die im Wesentlichen eine Benutzerumgebungsvariable ist, während environment und apiBaseUrl Laufzeitumgebungsvariablen waren. Das aufrufende Benutzerprofil liefert den Wert der Variable NODE_ENV und die App nutzt ihn, um interne Entscheidungen zu treffen.
Wenn du unter Windows arbeitest, könntest du beim Ausführen der beiden vorherigen Befehle auf Schwierigkeiten stoßen. Das Windows-Terminal lässt es möglicherweise nicht zu, dass du Benutzerumgebungsvariablen mit der Syntax KEY=VALUE zuweist (es sei denn, es handelt sich um Bash unter Windows).
Eine schnelle Lösung ist in diesem Fall die Verwendung von Skripten und cross-env.
Installiere cross-env, indem du den folgenden Befehl ausführst:
npm i --save-dev cross-env
Als Nächstes gehst du zu deiner Datei package.json und änderst den Schlüssel scripts entsprechend:
// …
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start-dev": "cross-env NODE_ENV=DEV node index.js",
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
// …
Jetzt kannst du die folgenden Befehle ausführen, um deine App mit zwei verschiedenen Sets von Umgebungsvariablen zu starten:
npm run start-dev # to start with dev variables
npm run start-staging # to start with staging variables
Dies ist eine universelle Lösung und du kannst diese Skripte auch unter bash/zsh verwenden.
Als Nächstes sehen wir uns an, wie du einen Variablenmanager eines Drittanbieters verwenden kannst.
Typ 2: Native Umgebungsvariablenverwaltung von Heroku verwenden
Um diesem Teil des Tutorials folgen zu können, brauchst du ein Heroku-Konto. Lege ihn an, bevor du fortfährst.
Bevor du die App auf Heroku bereitstellst, musst du ein paar Änderungen an deinem Code vornehmen. Als Erstes fügst du ein neues Skript namens start in dein package.json ein:
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start": "node index.js",
"start-dev": "cross-env NODE_ENV=DEV node index.js",
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
Dieses Skript wird von Heroku verwendet, um deine App zu starten, sobald sie bereitgestellt ist. Außerdem musst du die letzte Zeile deiner index.js Datei wie folgt ändern:
app.listen(process.env.PORT || 3000);
Damit wird sichergestellt, dass die App auf dem von Heroku angegebenen Port bereitgestellt wird.
Als Nächstes musst du das Heroku CLI lokal installieren, damit du von deiner Kommandozeile aus auf deine Heroku-Apps zugreifen kannst. Für dieses Tutorial kannst du den folgenden Befehl verwenden, um das CLI zu installieren:
npm i -g heroku
In der Heroku-Dokumentation wird jedoch empfohlen, die Installation über einen der anderen Wege vorzunehmen, die unter dem oben genannten Link aufgeführt sind, um eine bessere Unterstützung zu erhalten. Nach der Installation führst du den folgenden Befehl aus, um dich bei deinem Heroku-Konto anzumelden:
heroku login
Gehe dann zu dashboard.heroku.com und logge dich in dein Konto ein. Als nächstes erstellst du eine neue App, indem du auf Neu > Neue App erstellen klickst.
Auf der nächsten Seite klickst du auf die Schaltfläche App erstellen, ohne irgendwelche Details einzugeben. Dadurch wird eine neue heroku App mit einem zufälligen Namen für dich erstellt.
So würde das Dashboard deiner App aussehen:
Auf dieser Seite findest du auch eine Anleitung, wie du deine App über das CLI auf Heroku bereitstellen kannst. Hier ist die Liste der Befehle, die du ausführen musst, um deine App auf Heroku bereitzustellen:
git init
heroku git:remote -a whispering-shelf-49396 # change whispering-shelf-49396 with the name of your app. You can get it in your dashboard
git add index.js package-lock.json package.json # do not push the .env files since we'll provide that via the in-app secrets manager git commit -am "Initial commit" git push heroku main Sobald die Bereitstellung erfolgreich abgeschlossen ist, kannst du die bereitgestellte App über das Dashboard ansehen, indem du auf die Schaltfläche App öffnen klickst
Wenn du alles richtig gemacht hast, siehst du die folgende Antwort:
Warum passiert das, fragst du dich vielleicht? Das liegt daran, dass wir die Umgebungsvariablen unserer App noch nicht in irgendeiner Form zur Verfügung gestellt haben. Wenn du dir die Befehle ansiehst, die du für die Bereitstellung der App verwendet hast, wirst du feststellen, dass wir die .env Dateien nicht in unsere Versionskontrolle übertragen haben. Wir haben auch den Wert NODE_ENV nicht im Startskript definiert.
Um nun Umgebungsvariablen in deine App einzubinden, musst du in deinem Heroku Dashboard zu Einstellungen > Config Vars navigieren. Wenn du auf Reveal Config Vars klickst, siehst du einen ähnlichen Bildschirm:
Hier kannst du nun den Inhalt deiner .env Datei eingeben:
Wenn du zurückgehst und die URL deiner App aktualisierst, wirst du feststellen, dass die Werte aktualisiert worden sind:
So kannst du den Secrets Manager einer Bereitstellungsplattform nutzen, um deine Umgebungsvariablen zu verwalten. Dazu musst du die Umgebungsvariablen jedoch manuell über das Dashboard der Plattform verwalten. Wie du bei Heroku sehen kannst, gibt es keine Möglichkeit, einen großen Dump von Umgebungsvariablen aus einer Datei zu importieren, sodass du gezwungen bist, sie einzeln einzugeben. Das kann manchmal ziemlich mühsam sein.
Im nächsten Abschnitt stellen wir dir eine effizientere Methode zur Verwaltung von App-Geheimnissen vor – den Secret Manager.
Typ 3: Verwende Doppler für die Verwaltung von Umgebungsvariablen
Die oben beschriebenen Methoden sind nicht plattformübergreifend einheitlich. Beim Einsatz in der Produktion verlässt man sich normalerweise nicht auf Umgebungsdateien, und bei der lokalen Arbeit ist es nicht möglich, plattformspezifische Variablenmanager zu verwenden. Geheime Manager wie Doppler füllen diese Lücke.
Um sie selbst auszuprobieren, musst du zunächst ein kostenloses Konto bei Doppler erstellen.
Danach kannst du der Anleitung folgen. Wahrscheinlich wird automatisch ein Beispielprojekt mit dem Namen example-project für dich erstellt. Der Einfachheit halber lassen wir es beiseite und erstellen ein neues Projekt für unseren Anwendungsfall.
Gehe zum Dashboard und klicke auf das Plus-Symbol neben Projekte.
Gib als Namen „my-app“ ein und fahre fort. So sollte das Projekt aussehen, wenn es fertig ist:
Klicke auf das Listenelement dev config. Klicke auf Add New Secret und füge zwei Secrets wie folgt hinzu:
Klicke auf die Schaltfläche Speichern, um deine Änderungen zu speichern. Beachte, dass Doppler die Groß- und Kleinschreibung bei der Benennung deiner Geheimnisse nicht unterstützt. Obwohl es im Allgemeinen vorzuziehen ist, die Namen der Geheimnisse in Großbuchstaben zu schreiben, hast du bei Doppler keine andere Wahl. Um die Geheimnisse, die von Doppler geholt werden, zu identifizieren, haben wir ihnen folgende Buchstaben vorangestellt DP_
Jetzt, wo die Variablen in Doppler erstellt und gespeichert sind, können wir sie in unsere Codebasis integrieren. Dazu musst du das Doppler CLI einrichten. Hier ist ein kurzer Überblick über das, was du tun musst.
Zunächst installierst du das CLI lokal, indem du den Anweisungen für dein Betriebssystem folgst. Als Nächstes meldest du dich mit deinem neu erstellten Konto bei der Doppler CLI an, indem du den folgenden Befehl ausführst:
doppler login
Sobald du eingeloggt bist, führe den folgenden Befehl aus, um dich mit deinem Remote-Doppler-Projekt über dein CLI zu verbinden:
doppler setup
Sobald du dich mit dem richtigen Projekt verbunden hast, kannst du mit folgendem Befehl auf deine Geheimnisse zugreifen:
doppler run
Wir werden diesen Befehl jedoch nicht direkt ausführen. Stattdessen fügen wir ihn an eines unserer Startskripte an, damit er automatisch ausgeführt wird, wenn die App startet. Aktualisieren wir die Datei package.json mit dem neuen Run-Skript für die Umgebung dev:
// …
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start": "node index.js",
"start-dev": "doppler run -- node index.js", // This has to be updated
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
// …
Erinnere dich auch daran, dass wir in Doppler neue Variablennamen erstellt haben, die mit DP_ beginnen. Wir müssen also unsere index.js Datei aktualisieren, um auch diese Variable anzuzeigen:
const express = require("express")
require('dotenv').config({
path: "STAGING" === process.env.NODE_ENV?.toUpperCase() ? './.env.staging' : './.env.dev'
})
console.log(process.env.NODE_ENV)
const app = express()
app.get("/", (req, res) => {
// the responseMessage object extracts its values from environment variables
// If a value is not found, it instead stores the string "not found"
const responseMessage = {
environment: process.env.environment || "Not found",
apiBaseUrl: process.env.apiBaseUrl || "Not found",
DP_ENVIRONMENT: process.env.DP_ENVIRONMENT || "Not found" // Add the new variable here
}
res.send(responseMessage)
})
app.listen(process.env.PORT || 3000);
Um die Dinge in Aktion zu sehen, führe den folgenden Befehl aus:
npm run start-dev
So sollte http://localhost:3000 jetzt aussehen:
Die dritte Variable in der Liste (DP_ENVIRONMENT) wird direkt von Doppler geholt.
Als Nächstes kannst du Doppler mit deiner Bereitstellungsplattform verbinden, um über deine bereitgestellte App auf diese Geheimnisse zuzugreifen. Dazu erstellen wir zunächst eine neue Umgebung in Doppler für einen neuen Satz von Einsatzgeheimnissen.
Gehe zurück auf die Startseite deines Projekts my-app. Klicke auf das einzige Listenelement in der Staging-Liste:
Du wirst feststellen, dass die beiden geheimen Variablen, die du in der dev Umgebung definiert hast, hier bereits vorhanden sind, aber es fehlen Werte:
Füge die folgenden Werte hinzu und klicke auf Speichern:
Wenn du hier fertig bist, klickst du auf die Registerkarte Integrationen und Sync hinzufügen auf dieser Seite, um die Verbindung zu deiner Bereitstellungsplattform herzustellen. Du erhältst eine Liste der Plattformen, in die Doppler integriert werden kann:
Da unsere App auf Heroku bereitgestellt wird, klicken wir auf Heroku. Befolge die Schritte auf dem Bildschirm, um deinen Heroku-Account mit Doppler zu verbinden und die erforderlichen Zugriffsrollen festzulegen. Sobald die Verbindung hergestellt ist, siehst du einen ähnlichen Bildschirm:
Wähle als Projekttyp App, wähle deine Heroku-App in der Liste der verfügbaren Apps, wähle stg als zu synchronisierende Config und Nicht importieren in den Importoptionen, da wir keine Geheimnisse von Heroku zu Doppler importieren wollen.
Klicke auf Integration einrichten, wenn du fertig bist. Wenn die Integration erfolgreich durchgeführt wurde, siehst du einen ähnlichen Bildschirm:
Wenn du jetzt den Abschnitt Config Vars im Dashboard deiner Heroku-App anschaust, wirst du feststellen, dass die Variablen von Doppler automatisch zu den Config Vars deines Heroku-Deployments hinzugefügt worden sind:
Du wirst auch feststellen, dass die beiden ursprünglichen Umgebungsvariablen (environment und apiBaseUrl) entfernt wurden. Das liegt daran, dass wir unter Importoptionen die Option Nicht importieren gewählt haben. Du kannst sie bei Bedarf in Heroku wieder hinzufügen.
Das Vorhandensein der neuen Umgebungsvariablen im Abschnitt Config Vars von Heroku zeigt, dass du Doppler erfolgreich so eingerichtet hast, dass er Geheimnisse sowohl lokal in deiner Entwicklungsumgebung als auch in deiner Bereitstellungsumgebung verwaltet, und du kannst den aktualisierten Code in Heroku bereitstellen, um die Änderungen in der bereitgestellten App zu sehen. So sieht es aus, wenn du fertig bist:
Damit ist die Anleitung zum Einrichten von Umgebungsvariablen in einem Node.js-Projekt mit drei gängigen Methoden abgeschlossen. Als Nächstes sehen wir uns an, wie du sicherstellen kannst, dass deine Umgebungsvariablen und ihre Dateien sicher sind, während sie verwendet werden.
Wie du Umgebungsvariablendateien sicher hältst
Auch wenn Umgebungsvariablen in der modernen DevOps-Praxis eine nützliche Ressource sind, musst du dir über die Auswirkungen auf die Sicherheit im Klaren sein, die sie verursachen können. Hier sind einige Tipps, wie du deine Umgebungsvariablendateien sicher und vor neugierigen Blicken geschützt hältst.
Halte env-Dateien aus der Versionskontrolle heraus
Eines der wichtigsten Dinge, die du beim Umgang mit Geheimnissen beachten solltest, ist, sie aus der Versionskontrolle herauszuhalten. Die Versionskontrolle ist ausschließlich dazu da, Änderungen am Quellcode deiner Anwendung zu verfolgen. Alles, was in ein Versionskontrollsystem eingegeben wird, bleibt dort, bis es explizit gelöscht wird, und die meisten Mitglieder deines Teams haben zu Referenzzwecken Zugriff auf diese historischen Daten.
Wenn du die Schlüssel zu deinem AWS-Storage-Bucket oder einem kostenpflichtigen API-Service in einer env-Datei für deine Anwendung gespeichert hast, solltest du sie nicht mit deinem gesamten Entwicklungsteam teilen, es sei denn, sie müssen darauf zugreifen können. Wenn dein Projekt auf einer Plattform wie GitHub als Open Source zur Verfügung steht, könnte das Hinzufügen von env-Dateien zu deinem VCS bedeuten, dass du es mit der ganzen Welt teilst! Env-Dateien sind dafür gedacht, lokal gespeichert zu werden. Du kannst jede Bereitstellungsumgebung über spezielle Methoden mit den relevanten env-Dateien versorgen.
Füge die env-Datei immer zu deiner .gitignore-Datei hinzu (vorausgesetzt, du verwendest git zur Versionskontrolle) oder verwende eine andere Methode, damit dein VCS die env-Dateien beim Übertragen von Änderungen überspringt. Du kannst in Erwägung ziehen, deinem VCS eine Vorlage für die env-Datei hinzuzufügen, damit alle anderen Teammitglieder diese als Referenz für die Erstellung ihrer lokalen env-Dateien verwenden können.
Überprüfe den Paketnamen vor der Installation
Da du normalerweise die meisten Pakete von NPM installierst, wenn du mit einer Node.js-Anwendung arbeitest, solltest du dabei besonders vorsichtig sein. Es ist allgemein bekannt, dass jeder ein NPM-Paket erstellen und verteilen kann. Daher ist es auch nicht verwunderlich, dass die Leute oft Fehler machen, wenn sie den Namen eines Pakets, das sie installieren wollen, eintippen.
Es wurden mehrere Fälle bekannt, in denen bösartige Pakete mit ähnlichen Namen wie beliebte Pakete aufgrund von Tippfehlern versehentlich von Benutzern installiert wurden. Solche Pakete sind darauf ausgelegt, auf die Umgebungsvariablen deiner App zuzugreifen und sie über das Internet an ihre Schöpfer zu senden.
Die einzige Möglichkeit, dich zu schützen, ist, wachsam zu sein, wenn du neue Pakete aus dem Internet installierst.
Bevorzuge geheime Manager gegenüber env-Dateien
Aufgrund von Problemen wie versehentlicher Weitergabe und Formatierungsfehlern sind Umgebungsdateien sicherlich nicht die beste Option für die Verwaltung von Geheimnissen. Hier kommen die Secret Manager ins Spiel. Mit Secret Managern wie Doppler kannst du die Geheimnisse deiner App vollständig von deinem Quellcode trennen und sie auf einer eigenen Plattform verwalten.
Du kannst deinem Team direkt auf der Plattform Zugriff auf diese Geheimnisse gewähren, und deine App kann über verschlüsselte Verbindungen über das Internet darauf zugreifen. Es löst alle Probleme, die mit Umgebungsdateien verbunden sind, und gibt dir gleichzeitig die Flexibilität, verschiedene Geheimnisse für die Umgebungen deiner Anwendung zu verwalten.
Allerdings gibt es auch hier Vorbehalte. Secret Manager befinden sich in einem sehr frühen Stadium ihrer technologischen Entwicklung. Außerdem handelt es sich bei Geheimhaltungsmanagern um Plattformen von Drittanbietern, die ihren eigenen Sicherheitsproblemen unterliegen. Deshalb ist eine sorgfältige Bewertung und Auswahl des richtigen Secret Managers wichtig. Wenn deine Anwendung, dein Entwicklungsteam oder die Anzahl der Geheimnisse deiner Anwendung nicht groß genug ist, könnten Geheimdienstmanager zu viel für dich sein.
Referenztabelle für Umgebungsvariablen
Hier ist ein kurzer Spickzettel, der dir hilft, dich schnell mit den Umgebungsvariablen und ihrer Verwendung vertraut zu machen:
| Definition von Umgebungsvariablen | Variablen, die den Prozessen von ihren aufrufenden Prozessen zur Verfügung gestellt werden |
| Zweck |
|
| Typen | Nur für Windows:
|
| Beliebte Anwendungsbeispiele |
|
| Wie implementierst du diese in deine Anwendung? |
|
Zusammenfassung
Umgebungsvariablen sind wichtig, um sensible Daten von deiner Anwendung zu isolieren. Sie helfen dabei, die Geheimnisse deiner Anwendung zu schützen und ermöglichen es dir, je nach Umgebung der Anwendung einfach zwischen verschiedenen Sets von Geheimnissen zu wechseln. Die Verwaltung dieser Variablen ist jedoch eine weitere Aufgabe für dich.
Wie oben beschrieben, gibt es mehrere Möglichkeiten, Umgebungsvariablen zu sichern. Probiere sie alle aus und finde heraus, welche am besten zu deinem Projekt passt und es beschleunigt.
