Was sind Umgebungsvariablen: Ein ausführlicher Leitfaden für Anfänger

Umgebungsvariablen ermöglichen die Konfiguration von Anwendungen, ohne den Code zu ändern. Sie trennen externe Daten von der App-Logik, was für angehende Entwickler (und sogar einige erfahrene) ziemlich rätselhaft bleiben kann.

Mit diesem praktischen Leitfaden lüften wir den Schleier über Umgebungsvariablen, damit Sie verstehen, was sie bedeuten, warum sie wichtig sind und wie Sie Umgebungsvariablen sicher nutzen können.

Schnappen Sie sich Ihr Lieblingsgetränk (und vielleicht ein paar Kekse), denn gleich geht es los. Lassen Sie uns die Konzepte von Umgebungsvariablen von Grund auf entschlüsseln.

Was sind Umgebungsvariablen?

Umgebungsvariablen sind dynamisch benannte Werte, die das Verhalten laufender Prozesse auf einem Computer beeinflussen können. Einige wichtige Eigenschaften von Umgebungsvariablen sind:

• Genannt: Beschreibende Variablennamen haben wie APP_MODE Und DB_URL.
• Extern: Werte werden außerhalb des App-Codes über Dateien, Befehlszeilen und Systeme festgelegt.
• Dynamisch: Kann Variablen aktualisieren, ohne Apps neu zu starten.
• Konfiguriert: Code basiert auf Variablen, definiert diese jedoch nicht.
• Entkoppelt: Codekonfigurationen müssen nicht geändert werden, sobald Variablen festgelegt sind.

Hier ist eine Analogie. Stellen Sie sich vor, Sie folgen einem Rezept für Schokoladenkekse. Das Rezept könnte lauten:

• 1 Tasse Zucker hinzufügen
• 1 Stück weiche Butter hinzufügen
• 2 Eier hinzufügen

Anstelle dieser fest codierten Werte könnten Sie stattdessen Umgebungsvariablen verwenden:

• Fügen Sie eine Tasse Zucker hinzu
• Fügen Sie $BUTTER-Stäbchen weicher Butter hinzu
• Fügen Sie $EGGS-Eier hinzu

Bevor Sie die Cookies erstellen, legen Sie die Namen dieser Umgebungsvariablen auf Werte Ihrer Wahl fest:

SUGAR=1 BUTTER=1EGGS=2

Wenn Sie also das Rezept befolgen, würden sich Ihre Zutaten wie folgt auflösen:

• 1 Tasse Zucker hinzufügen
• 1 Stück weiche Butter hinzufügen
• 2 Eier hinzufügen

Dadurch können Sie das Cookie-Rezept konfigurieren, ohne den Rezeptcode zu ändern.

Das gleiche Konzept gilt für Computer und Entwicklung. Mit Umgebungsvariablen können Sie die Umgebung ändern, in der ein Prozess ausgeführt wird, ohne den zugrunde liegenden Code zu ändern. Hier sind einige gängige Beispiele:

• Einstellung der Umgebung auf „Entwicklung“ oder „Produktion“
• Konfigurieren von API-Schlüsseln für externe Dienste
• Weitergabe geheimer Schlüssel oder Zugangsdaten
• Bestimmte Funktionen ein- und ausschalten

Umgebungsvariablen bieten große Flexibilität. Sie können denselben Code in mehreren Umgebungen bereitstellen, ohne den Code selbst zu ändern. Aber lassen Sie uns genauer verstehen, warum sie wertvoll sind.

Warum sind Umgebungsvariablen wertvoll?

Berücksichtigen Sie Umgebungsvariablen wie Anwendungsknöpfe, die für Einwahleinstellungen verwendet werden. Wir werden in Kürze hervorragende Anwendungsfälle untersuchen.

Lassen Sie uns die Intuition darüber festigen, warum Umgebungsvariablen wichtig sind!

Grund Nr. 1: Sie trennen Anwendungscode von Konfigurationen

Das direkte Codieren von Konfigurationen und Anmeldeinformationen in Ihren Code kann zu allen möglichen Problemen führen:

• Versehentliche Commits zur Quellcodeverwaltung
• Code neu erstellen und erneut bereitstellen, nur um einen Wert zu ändern
• Konfigurationsprobleme bei der umgebungsübergreifenden Heraufstufung

Es führt auch zu unordentlichem Code:

import os# Hard-coded configurationDB_USER = 'appuser' DB_PASS = 'password123'DB_HOST = 'localhost'DB_NAME = 'myappdb'def connect_to_db():  print(f"Connecting to {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}")  connect_to_db()

Dadurch wird die Geschäftslogik mit Konfigurationsdetails verknüpft. Eine enge Kopplung macht die Wartung mit der Zeit mühsam:

• Änderungen erfordern eine Änderung des Quellcodes
• Es besteht die Gefahr, dass Geheimnisse in die Quellcodeverwaltung gelangen

Die Verwendung von Umgebungsvariablen verringert diese Probleme. Sie können beispielsweise die Umgebungsvariablen DB_USER und DB_NAME festlegen.

# .env fileDB_USER=appuserDB_PASS=password123  DB_HOST=localhostDB_NAME=myappdb

Der Anwendungscode kann bei Bedarf auf die Umgebungsvariablen zugreifen, wodurch der Code sauber und einfach bleibt.

import os# Load config from environment DB_USER = os.environ['DB_USER']DB_PASS = os.environ['DB_PASS'] DB_HOST = os.environ['DB_HOST']DB_NAME = os.environ['DB_NAME']def connect_to_db():  print(f"Connecting to {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}")  connect_to_db()

Umgebungsvariablen trennen die Konfiguration sauber vom Code und sorgen dafür, dass vertrauliche Werte in der Umgebung abstrahiert werden.

Sie können denselben Code von der Entwicklung bis zur Produktion bereitstellen, ohne etwas zu ändern. Die Umgebungsvariablen können sich zwischen den Umgebungen unterscheiden, ohne dass sich dies auf den Code auswirkt.

Grund Nr. 2: Sie vereinfachen die Konfiguration von Anwendungen

Umgebungsvariablen vereinfachen die Optimierung von Konfigurationen, ohne den Code zu berühren:

# .env file:DEBUG=true

So könnten wir es in der Skriptdatei verwenden:

# Script content:import osDEBUG = os.environ.get('DEBUG') == 'true' if DEBUG:   print("In DEBUG mode")

Das Umschalten des Debug-Modus erfordert nur die Aktualisierung der .env-Datei – es sind keine Codeänderungen, Neuerstellung oder erneute Bereitstellung erforderlich. „Env-Variablen“, kurz „Env-Variablen“, helfen auch bei der nahtlosen Bereitstellung in verschiedenen Umgebungen:

import os# Retrieve environment variable to determine the current environment (production or staging)current_env = os.getenv('APP_ENV', 'staging')  # Default to 'staging' if not set# Production API keyPROD_API_KEY = os.environ['PROD_API_KEY']# Staging API keySTG_API_KEY = os.environ['STG_API_KEY']# Logic that sets api_key based on the current environmentif current_env == 'production':    api_key = PROD_API_KEYelse:    api_key = STG_API_KEY# Initialize API client with the appropriate API keyapi = ApiClient(api_key)

Derselbe Code kann ohne Änderungen separate API-Schlüssel für Produktion und Staging verwenden.

Und schließlich ermöglichen sie das Umschalten von Funktionen ohne neue Bereitstellungen:

NEW_FEATURE = os.environ['NEW_FEATURE'] == 'true'if NEW_FEATURE:   enableNewFeature()

Wechseln NEUE FUNKTION var aktiviert die Funktionalität sofort in unserem Code. Die Schnittstelle zum Aktualisieren von Konfigurationen hängt von den Systemen ab:

• Cloud-Plattformen wie Heroku nutzen Web-Dashboards
• Server verwenden Betriebssystembefehlstools
• Lokale Entwickler können .env-Dateien verwenden

Umgebungsvariablen sind beim Erstellen von Anwendungen von Vorteil, da sie es Benutzern ermöglichen, Elemente gemäß ihren Anforderungen zu konfigurieren.

Grund Nr. 3: Sie helfen bei der Verwaltung von Geheimnissen und Anmeldeinformationen

Das Überprüfen von Geheimnissen wie API-Schlüsseln, Passwörtern und privaten Schlüsseln direkt im Quellcode birgt erhebliche Sicherheitsrisiken:

# Avoid exposing secrets in code!STRIPE_KEY = 'sk_live_1234abc'DB_PASSWORD = 'password123'stripe.api_key = STRIPE_KEY db.connect(DB_PASSWORD)

Diese Anmeldeinformationen werden jetzt offengelegt, wenn dieser Code in ein öffentliches GitHub-Repository übertragen wird!

Umgebungsvariablen verhindern Lecks durch die Externalisierung von Geheimnissen:

import osSTRIPE_KEY = os.environ.get('STRIPE_KEY')  DB_PASS = os.environ.get('DB_PASS')   stripe.api_key = STRIPE_KEY  db.connect(DB_PASS)

Die tatsächlichen Geheimwerte werden in einer lokalen .env-Datei festgelegt.

# .env fileSTRIPE_KEY=sk_live_1234abcDB_PASS=password123

Vergessen Sie nicht .gitignore die .env-Datei, um Geheimnisse vor der Quellcodeverwaltung zu schützen. Dazu gehört die Definition der .env-Datei in einer .gitignore-Datei in einem beliebigen Repo-Root, was Git anweist, die Datei während der Commit-Erstellung zu ignorieren.

Dadurch werden geheime Definitionen vom Anwendungscode getrennt und zur Laufzeit sicher aus geschützten Umgebungen geladen. Das Risiko einer versehentlichen Preisgabe von Zugangsdaten verringert sich drastisch.

Grund Nr. 4: Sie fördern die Konsistenz

Stellen Sie sich vor, Sie hätten unterschiedliche Konfigurationsdateien für Entwicklungs-, Qualitätssicherungs- und Produktionsumgebungen:

# DevelopmentDB_HOST = 'localhost'DB_NAME = 'appdb_dev'# ProductionDB_HOST = 'db.myapp.com'DB_NAME = 'appdb_prod'

Diese Diskrepanz führt zu subtilen Fehlern, die schwer zu erkennen sind. Code, der in der Entwicklung einwandfrei funktioniert, kann aufgrund nicht übereinstimmender Konfigurationen plötzlich zu Produktionsunterbrechungen führen.

Umgebungsvariablen lösen dieses Problem, indem sie die Konfiguration an einem Ort zentralisieren:

DB_HOST=db.myapp.comDB_NAME=appdb_prod

Jetzt werden in allen Umgebungen konsistent dieselben Variablen verwendet. Sie müssen sich keine Sorgen mehr über zufällige oder falsche Einstellungen machen.

Der Anwendungscode verweist einfach auf die Variablen:

import osdb_host = os.environ['DB_HOST']db_name = os.environ['DB_NAME']db.connect(db_host, db_name)

Unabhängig davon, ob die App lokal oder auf einem Produktionsserver ausgeführt wird, verwendet sie immer den richtigen Datenbankhost und -namen.

Diese Einheitlichkeit reduziert Fehler, verbessert die Vorhersehbarkeit und macht die App insgesamt robuster. Entwickler können darauf vertrauen, dass sich der Code in jeder Umgebung gleich verhält.

Wie können Sie Umgebungsvariablen definieren?

Umgebungsvariablen können an mehreren Stellen definiert werden, was eine flexible Einstellung und den Zugriff auf sie über Prozesse und Systeme hinweg ermöglicht.

1. Umgebungsvariablen des Betriebssystems

Die meisten Betriebssysteme bieten integrierte Mechanismen zum Definieren globaler Variablen. Dadurch sind die Variablen systemweit für alle Benutzer, Anwendungen usw. zugänglich.

Auf Linux/Unix-Systemen können Variablen in Shell-Startskripten definiert werden.

Beispielsweise kann ~/.bashrc zum Festlegen von Variablen auf Benutzerebene verwendet werden, während /etc/environment für systemweite Variablen vorgesehen ist, auf die alle Benutzer zugreifen können.

Variablen können auch inline vor der Ausführung von Befehlen mit dem Export-Befehl oder direkt über den env-Befehl in der Bash festgelegt werden:

# In ~/.bashrcexport DB_URL=localhostexport APP_PORT=3000

# In /etc/environmentDB_HOST=localhostDB_NAME=mydatabase

Variablen können auch vor der Ausführung von Befehlen inline gesetzt werden:

export TOKEN=abcdefpython app.py

Durch die Definition von Variablen auf Betriebssystemebene werden diese global verfügbar, was sehr hilfreich ist, wenn Sie die App unabhängig von internen Werten ausführen möchten.

Sie können auch in Skripts oder Befehlszeilenargumenten auf definierte Variablen verweisen.

python app.py --db-name $DB_NAME --db-host $DB_HOST --batch-size $BATCH_SIZE

2. Definieren von Umgebungsvariablen im Anwendungscode

Zusätzlich zu Variablen auf Betriebssystemebene können Umgebungsvariablen während der Ausführung direkt im Anwendungscode definiert und darauf zugegriffen werden.

Der os.environ Das Wörterbuch in Python enthält alle aktuell definierten Umgebungsvariablen. Wir können neue festlegen, indem wir einfach Schlüssel-Wert-Paare hinzufügen:

Umgebungsvariablen können auch direkt im Anwendungscode definiert und darauf zugegriffen werden. In Python enthält das Wörterbuch os.environ alle definierten Umgebungsvariablen:

import osos.environ["API_KEY"] = "123456" api_key = os.environ.get("API_KEY")

Das os.environ-Wörterbuch ermöglicht also das dynamische Festlegen und Abrufen von Umgebungsvariablen innerhalb des Python-Codes.

Die meisten Sprachen sind mit ihren Bibliotheken gebündelt und bieten zur Laufzeit Zugriff auf Umgebungsvariablen.

Sie können auch Frameworks wie Express, Django und Laravel verwenden, um tiefere Integrationen zu erreichen, z. B. das automatische Laden von .env-Dateien mit Umgebungsvariablen.

3. Erstellen lokaler Konfigurationsdateien für Umgebungsvariablen

Zusätzlich zu Variablen auf Systemebene können Umgebungsvariablen aus den lokalen Konfigurationsdateien einer Anwendung geladen werden. Dadurch bleiben Konfigurationsdetails vom Code getrennt, auch für lokale Entwicklung und Tests.

Einige beliebte Ansätze:

.env-Dateien

Die von Node.js populär gemachte .env-Dateiformatkonvention bietet eine praktische Möglichkeit, Umgebungsvariablen in einem Schlüsselwertformat anzugeben:

# .envDB_URL=localhostAPI_KEY=123456

Web-Frameworks wie Django und Laravel laden in .env-Dateien definierte Variablen automatisch in die Anwendungsumgebung. Für andere Sprachen wie Python übernehmen Bibliotheken wie python-dotenv den Import von .env-Dateien:

from dotenv import load_dotenvload_dotenv() # Loads .env variablesprint(os.environ['DB_URL']) # localhost

Der Vorteil der Verwendung von .env-Dateien besteht darin, dass die Konfiguration sauber und getrennt bleibt, ohne dass Änderungen am Code vorgenommen werden müssen.

JSON-Konfigurationsdateien

Bei komplexeren Konfigurationsanforderungen mit mehreren Umgebungsvariablen hilft die Verwendung von JSON- oder YAML-Dateien dabei, Variablen gemeinsam zu organisieren:

// config.json{  "api_url": "https://api.example.com",  "api_key": "123456",   "port": 3000}

Der Anwendungscode kann diese JSON-Daten dann schnell als Wörterbuch laden, um auf konfigurierte Variablen zuzugreifen:

import jsonconfig = json.load('config.json')  api_url = config['api_url']api_key = config['api_key'] port = config['port'] # 3000

Dies verhindert unordentliche Dotenv-Dateien beim Umgang mit mehreren App-Konfigurationen.

Wie greifen Sie auf Umgebungsvariablen in verschiedenen Programmiersprachen zu?

Unabhängig davon, wie wir Umgebungsvariablen definieren, benötigen unsere Anwendungen eine konsistente Methode zum Nachschlagen von Werten während der Laufzeit.

Während es verschiedene Möglichkeiten gibt, Umgebungsvariablen zu definieren, benötigt der Anwendungscode unabhängig von der Sprache eine Standardmethode für den Zugriff zur Laufzeit. Hier ist eine Übersicht über Techniken zum Zugriff auf Umgebungsvariablen in gängigen Sprachen:

Python

Python stellt das Wörterbuch os.environ für den Zugriff auf definierte Umgebungsvariablen bereit:

import osdb = os.environ.get('DB_NAME')print(db)

Mit os.environ.get() können wir eine Variable abrufen, die None zurückgibt, wenn sie nicht definiert ist. Oder greifen Sie direkt über os.environ() zu, was KeyError auslöst, wenn es nicht vorhanden ist.

Zusätzliche Methoden wie os.getenv() und os.environ.get() ermöglichen die Angabe von Standardwerten, wenn diese nicht festgelegt sind.

JavaScript (Node.js)

Im JavaScript-Code von Node.js sind Umgebungsvariablen für das globale Objekt „process.env“ verfügbar:

// Get env varconst db = process.env.DB_NAME;console.log(db);

Wenn undefiniert, enthält process.env undefiniert. Wir können auch Standardwerte liefern wie:

const db = process.env.DB_NAME || 'defaultdb';

Rubin

Ruby-Anwendungen greifen über den ENV-Hash auf Umgebungsvariablen zu:

# Access variable db = ENV['DB_NAME']  puts db

Wir können auch einen Standardwert übergeben, wenn der gewünschte Schlüssel nicht existiert:

db = ENV.fetch('DB_NAME', 'defaultdb')

PHP

PHP bietet globale Methoden getenv(), $_ENV und $_SERVER für den Zugriff auf Umgebungsvariablen:

// Get env var$db_name = getenv('DB_NAME');// Or access $_ENV or $_SERVER arrays $db_name = $_ENV['DB_NAME'];

Abhängig von der Variablenquelle können sie in verschiedenen Globals verfügbar sein.

Java

In Java gibt die Methode System.getenv() env-Variablen zurück, auf die zugegriffen werden kann:

String dbName = System.getenv("DB_NAME");

Dies ermöglicht den Zugriff auf Variablen, die auf Systemebene global in Java definiert sind.

Vorerst einige Best Practices rund um die Hygiene bei Umgebungsvariablen.

Leitfaden zur Sicherheit von Umgebungsvariablen

Wenn es um die sichere Verwaltung von Umgebungsvariablen geht, sollten wir einige Best Practices im Hinterkopf behalten.

Speichern Sie niemals vertrauliche Informationen im Code

Speichern Sie in erster Linie niemals vertrauliche Informationen wie Passwörter, API-Schlüssel oder Token direkt in Ihrem Code.

Es mag verlockend sein, für einen schnellen Zugriff einfach ein Datenbankkennwort oder einen Verschlüsselungsschlüssel fest in Ihren Quellcode einzukodieren, aber widerstehen Sie diesem Drang!

Wenn Sie diesen Code versehentlich in ein öffentliches Repository auf GitHub übertragen, geben Sie Ihre Geheimnisse im Wesentlichen an die ganze Welt weiter. Stellen Sie sich vor, ein Hacker hätte die Anmeldeinformationen für Ihre Produktionsdatenbank erhalten, nur weil diese im Klartext in Ihrer Codebasis vorlagen. Beängstigender Gedanke, oder?

Verwenden Sie stattdessen immer Umgebungsvariablen, um vertrauliche Konfigurationen jeglicher Art zu speichern. Bewahren Sie Ihre Geheimnisse an einem sicheren Ort wie einer .env-Datei oder einem Geheimnisverwaltungstool auf und verweisen Sie in Ihrem Code über Umgebungsvariablen darauf. Anstatt beispielsweise so etwas in Ihrem Python-Code zu tun:

db_password = "supers3cr3tpassw0rd"

Sie würden dieses Passwort in einer Umgebungsvariablen wie dieser speichern:

# .env fileDB_PASSWORD=supers3cr3tpassw0rd

Und greifen Sie dann in Ihrem Code darauf zu:

import osdb_password = os.environ.get('DB_PASSWORD')

Auf diese Weise bleiben Ihre Geheimnisse auch dann sicher, wenn Ihr Quellcode kompromittiert wird. Umgebungsvariablen fungieren als sichere Abstraktionsschicht.

Verwenden Sie umgebungsspezifische Variablen

Eine andere Praxis besteht darin, für jede Anwendungsumgebung, z. B. Entwicklung, Staging und Produktion, unterschiedliche Umgebungsvariablen zu verwenden.

Sie möchten nicht versehentlich eine Verbindung zu Ihrer Produktionsdatenbank herstellen, während Sie lokal entwickeln, nur weil Sie vergessen haben, eine Konfigurationsvariable zu aktualisieren! Namespace Ihrer Umgebungsvariablen für jede Umgebung:

# DevDEV_API_KEY=abc123DEV_DB_URL=localhost# ProductionPROD_API_KEY=xyz789PROD_DB_URL=proddb.amazonaws.com

Verweisen Sie dann abhängig von der aktuellen Umgebung auf die entsprechenden Variablen in Ihrem Code. Viele Frameworks wie Rails stellen zu diesem Zweck umgebungsspezifische Konfigurationsdateien bereit.

Halten Sie Geheimnisse von der Versionskontrolle fern

Es ist außerdem wichtig, dass Ihre .env- und Konfigurationsdateien, die Geheimnisse enthalten, nicht der Versionskontrolle unterliegen. Fügen Sie .env zu Ihrem hinzu .gitignore damit Sie es nicht versehentlich in Ihr Repository übertragen.

Sie können verwenden git-secrets um vor jedem Commit nach vertraulichen Informationen zu suchen. Für zusätzliche Sicherheit verschlüsseln Sie Ihre Secrets-Datei, bevor Sie sie speichern. Tools wie Ansible Vault und BlackBox können dabei helfen.

Sichere Geheimnisse auf Produktionsservern

Vermeiden Sie bei der Verwaltung von Umgebungsvariablen auf Ihren Produktionsservern deren Festlegung mithilfe von Befehlszeilenargumenten, die über die Prozesstabelle überprüft werden können.

Verwenden Sie stattdessen die Umgebungsverwaltungstools Ihres Betriebssystems oder Ihrer Container-Orchestrierungsplattform. Sie können beispielsweise Kubernetes Secrets verwenden, um Geheimnisse sicher zu speichern und in Ihren Anwendungs-Pods offenzulegen.

Verwenden Sie starke Verschlüsselungsalgorithmen

Verwenden Sie robuste und moderne Verschlüsselungsalgorithmen, wenn Sie Ihre Geheimnisse verschlüsseln, egal ob während der Übertragung oder im Ruhezustand. Vermeiden Sie veraltete Algorithmen wie DES oder MD5, die bekannte Schwachstellen aufweisen. Entscheiden Sie sich stattdessen für branchenübliche Algorithmen wie AES-256 für symmetrische Verschlüsselung und RSA-2048 oder ECDSA für asymmetrische Verschlüsselung.

Wechseln Sie Secrets regelmäßig

Wechseln Sie Ihre Geheimnisse regelmäßig, insbesondere wenn Sie den Verdacht haben, dass sie kompromittiert wurden. Behandeln Sie Geheimnisse wie ein Passwort – aktualisieren Sie sie alle paar Monate. Ein Secrets-Management-Tool wie Hashicorp Vault oder AWS Secrets Manager kann dabei helfen, diesen Prozess zu automatisieren.

Seien Sie vorsichtig bei der Protokollierung und Fehlerberichterstattung

Seien Sie vorsichtig bei der Protokollierung und Fehlerberichterstattung. Stellen Sie sicher, dass Sie keine Umgebungsvariablen protokollieren, die vertrauliche Werte enthalten. Wenn Sie ein Fehlerverfolgungstool eines Drittanbieters verwenden, konfigurieren Sie es so, dass vertrauliche Daten bereinigt werden. Das Letzte, was Sie wollen, ist, dass Ihre Geheimnisse in einem Stack-Trace auf einem Ausnahmeberichts-Dashboard angezeigt werden!

Wann sollten Umgebungsvariablen vermieden werden?

Es gibt mehrere Fälle, in denen Umgebungsvariablen vermieden werden sollten:

Verwalten komplexer Konfigurationen

Die Verwendung von Umgebungsvariablen zur Verwaltung der Konfiguration komplexer Softwaresysteme kann chaotisch und fehleranfällig sein. Wenn die Anzahl der Konfigurationsparameter zunimmt, erhalten Sie lange Umgebungsvariablennamen, die unbeabsichtigt kollidieren können. Es gibt auch keine einfache Möglichkeit, verwandte Konfigurationswerte zusammenzufassen.

Erwägen Sie anstelle von Umgebungsvariablen die Verwendung von Konfigurationsdateien in einem Format wie JSON oder YAML. Damit können Sie:

• Gruppieren Sie verwandte Konfigurationsparameter in einer verschachtelten Struktur.
• Vermeiden Sie Namenskollisionen, indem Sie die Konfiguration in Bereiche und Namespaces kapseln.
• Definieren Sie benutzerdefinierte Datentypen statt nur Zeichenfolgen.
• Mit einem Texteditor können Sie Konfigurationen schnell anzeigen und ändern.

Speichern sensibler Informationen

Während Umgebungsvariablen scheinbar leicht externe Konfigurationen wie API-Schlüssel, Datenbankkennwörter usw. einschleusen können, kann dies zu Sicherheitsproblemen führen.

Das Problem besteht darin, dass auf Umgebungsvariablen in einem Prozess global zugegriffen werden kann. Wenn also ein Exploit in einem Teil Ihrer Anwendung vorhanden ist, könnte dieser die in Umgebungsvariablen gespeicherten Geheimnisse gefährden.

Ein sichererer Ansatz ist die Verwendung eines Geheimverwaltungsdienstes, der die Verschlüsselung und Zugriffskontrolle übernimmt. Diese Dienste ermöglichen die externe Speicherung sensibler Daten und stellen SDKs zum Abrufen von Anwendungswerten bereit.

Erwägen Sie daher die Verwendung einer dedizierten Geheimnisverwaltungslösung anstelle von Umgebungsvariablen für Anmeldeinformationen und private Schlüssel. Dies verringert das Risiko, dass sensible Daten durch Exploits oder unbeabsichtigte Protokollierung versehentlich offengelegt werden.

Arbeiten mit mehreren Umgebungen

Die Verwaltung von Umgebungsvariablen kann mühsam werden, wenn Anwendungen wachsen und in mehreren Umgebungen (Entwicklung, Staging, Staging, Produktion) bereitgestellt werden. Möglicherweise verfügen Sie über fragmentierte Konfigurationsdaten, die über verschiedene Bash-Skripte, Bereitstellungstools usw. verteilt sind.

Eine Konfigurationsmanagementlösung hilft dabei, alle umgebungsspezifischen Einstellungen an einem zentralen Ort zu konsolidieren. Dies können Dateien in einem Repository, einem dedizierten Konfigurationsserver oder integriert in Ihre CI/CD-Pipelines sein.

Wenn das Ziel darin besteht, die Duplizierung von Umgebungsvariablen zu vermeiden, ist eine einzige Quelle der Wahrheit für Konfigurationen sinnvoller.

Teilen der Konfiguration zwischen Teams

Da Umgebungsvariablen lokal pro Prozess bezogen werden, wird die gemeinsame Nutzung und Synchronisierung von Konfigurationsdaten zwischen verschiedenen Teams, die an derselben Anwendung oder Dienstreihe arbeiten, sehr schwierig.

Jedes Team kann seine Kopie der Konfigurationswerte in verschiedenen Bash-Skripten, Bereitstellungsmanifesten usw. verwalten. Diese dezentrale Konfiguration führt zu Folgendem:

1. Konfigurationsdrift: Da es keine einheitliche Quelle der Wahrheit gibt, ist es leicht, dass die Konfiguration in verschiedenen Umgebungen inkonsistent wird, wenn verschiedene Teams unabhängige Änderungen vornehmen.
2. Mangelnde Sichtbarkeit: Es gibt keine zentrale Möglichkeit, den gesamten Konfigurationsstatus aller Dienste anzuzeigen, zu durchsuchen und zu analysieren. Dies macht es äußerst schwierig zu verstehen, wie ein Dienst konfiguriert ist.
3. Prüfungsherausforderungen: Änderungen an Umgebungsvariablen werden nicht standardmäßig nachverfolgt, sodass es schwierig ist zu überprüfen, wer wann welche Konfiguration geändert hat.
4. Schwierigkeiten beim Testen: Da es keine Möglichkeit gibt, einfach Snapshots zu erstellen und die Konfiguration zu teilen, wird die Sicherstellung konsistenter Umgebungen für Entwicklung und Tests äußerst umständlich.

Anstelle dieses fragmentierten Ansatzes ermöglicht eine zentralisierte Konfigurationslösung Teams, die Konfiguration von einer einzigen Plattform oder einem einzigen Repository aus zu verwalten.

Erstellen Sie Ihre Apps langfristig mit Umgebungsvariablen

Wenn Ihre Anwendung wächst, überlegen Sie, ob Sie möglicherweise erweiterte Möglichkeiten zur Verwaltung ihrer Konfigurationseinstellungen benötigen.

Was jetzt einfach erscheint, könnte später komplizierter werden. Sie benötigen wahrscheinlich bessere Möglichkeiten, den Zugriff zu kontrollieren, Teameinstellungen zu teilen, alles klar zu organisieren und Konfigurationen reibungslos zu aktualisieren.

Lassen Sie sich nicht in die Enge treiben, indem Sie von Anfang an nur Umgebungsvariablen verwenden. Sie möchten planen, wie Sie mit Konfigurationen umgehen, wenn Ihre Anforderungen wachsen.

Während sich Umgebungsvariablen hervorragend für den Umgang mit umgebungsbezogenen Daten wie Anmeldeinformationen, Datenbanknamen, lokalen IP-Adressen usw. eignen, möchten Sie ein System erstellen, das soliden Prinzipien wie Sicherheit, Gemeinsamkeit, Organisation und der Fähigkeit, sich schnell an Änderungen anzupassen, folgt.

Die von uns besprochenen Alternativen, wie die Verwendung einer dedizierten Konfigurationsdatei oder eines dedizierten Dienstes, verfügen über wertvolle Funktionen, die mit diesen Prinzipien übereinstimmen. Das wird Ihnen helfen, schnell voranzukommen, ohne ausgebremst zu werden.