Möchten Sie Ihre Konfiguration besser verwalten? Lernen Sie, wie man mit Umgebungsvariablen in Python arbeitet .

Als ich mir Python selbst beigebracht habe, habe ich Projekte erstellt, um das gerade Gelernte anzuwenden. Ein Teil dieser Projekte bestand darin, eine Verbindung zu einer Datenbank herzustellen und sie mit Python abzufragen. Das bedeutete, dass ich die Datenbankkonfiguration und sensible Informationen wie Benutzername und Passwort für die Authentifizierung speichern musste.

Solche sensiblen Informationen in einem Python-Skript fest zu kodieren, war keine gute Idee. Ich habe gelernt, wie man Konfigurationsdateien und Umgebungsvariablen verwendet – zusammen mit den in Python integrierten Modulen, um mit ihnen zu arbeiten.

Wenn ich also sensible Informationen wie Kennwörter und API-Schlüssel in meinen Anwendungen verwenden muss, setze ich sie als Umgebungsvariablen und rufe sie bei Bedarf ab. In diesem Tutorial erkläre ich Ihnen, was Umgebungsvariablen sind und wie Sie mit ihnen in Python arbeiten können.

Was sind Umgebungsvariablen?

Umgebungsvariablen sind Variablen außerhalb Ihrer Anwendung, die Konfigurationsinformationen, Systemeinstellungen und ähnliches speichern. Sie werden normalerweise vom Betriebssystem oder der Anwendungsumgebung verwaltet. Zu den wichtigsten Merkmalen von Umgebungsvariablen gehören:

  • Name-Wert-Paare: Umgebungsvariablen bestehen aus einem Namen (auch als Schlüssel bezeichnet) und einem entsprechenden Wert.
  • Systemumfang: Sie können Umgebungsvariablen auf Systemebene festlegen, so dass sie für alle auf dem System laufenden Prozesse zugänglich sind. Bei Bedarf können Sie sie auch auf Anwendungsebene ändern oder definieren, so dass sie sich nur auf diese spezielle Anwendung auswirken.
  • Dynamisch und veränderlich: Sie können die Umgebungsvariablen während der Laufzeit ändern und sind somit flexibel.

Wie Umgebungsvariablen hilfreich sind

Umgebungsvariablen bieten mehrere Vorteile für die Verwaltung der Konfiguration und sensibler Informationen in Ihren Python-Anwendungen:

  • Trennung der Belange: Indem Sie die Konfiguration außerhalb Ihres Codes speichern, halten Sie die Belange der Konfigurationsverwaltung von Ihrer Anwendungslogik getrennt.
  • Sicherheit: Sie können sensible Daten wie API-Schlüssel und Datenbankanmeldeinformationen in Umgebungsvariablen speichern, ohne sie im Quellcode offenzulegen, und so das Risiko einer Aufdeckung verringern.
  • Flexibilität: Mit Umgebungsvariablen ist es einfach, Konfigurationseinstellungen zu aktualisieren, da Sie Änderungen außerhalb der Codebasis vornehmen können. Mit Umgebungsvariablen können Sie Konfigurationseinstellungen anpassen, ohne Ihren Code zu verändern. Diese Flexibilität ist besonders nützlich, wenn Sie Anwendungen in verschiedenen Umgebungen einsetzen oder Anmeldedaten aktualisieren möchten.

In den folgenden Abschnitten dieses Tutorials erfahren Sie, wie Sie Umgebungsvariablen in Python setzen, darauf zugreifen und sie verwalten können und wie sie die Konfigurationsverwaltung in Ihren Projekten verbessern.

Wie man Umgebungsvariablen setzt

Sie können Umgebungsvariablen über die Kommandozeile setzen. Der Geltungsbereich solcher Umgebungsvariablen gilt nur für die aktuelle Sitzung – undsie bleiben außerhalb der aktuellen Sitzung nicht bestehen.

Auf einem Mac- oder Linux-Rechner können Sie eine Umgebungsvariable in Ihrer aktuellen Terminalsitzung wie folgt setzen:

export MY_VARIABLE=my_value

Wenn Sie ein Windows-Benutzer sind, können Sie eine Umgebungsvariable vorübergehend wie folgt setzen:

set MY_VARIABLE=mein_wert

Zugriff auf Umgebungsvariablen in Python

Python bietet das os-Modul für betriebssystembezogene Funktionen. Und os.environ ist ein Wörterbuch der Umgebungsvariablen. Die Namen der Umgebungsvariablen und ihre Werte sind die Schlüssel bzw. Werte des Wörterbuchs.

Sie können also auf die Werte der Umgebungsvariablen zugreifen, indem Sie (ihre Namen als) Schlüssel verwenden, so wie Sie auf die Elemente eines Wörterbuchs zugreifen würden.

Hier sind ein paar Beispiele:

importieren Sie os
print(os.environ['HOME'])
# Ausgabe: /home/balapriya
print(os.environ['USER'])
# Ausgabe: balapriya

So weit, so gut. Aber was passiert, wenn Sie versuchen, auf den Wert einer Umgebungsvariablen zuzugreifen, die nie gesetzt wurde?

Lassen Sie uns versuchen, auf API_KEY zuzugreifen, den wir noch nicht gesetzt haben:

print(os.environ['API_KEY'])

Wie erwartet, erhalten Sie einen KeyError:

Traceback (letzter Aufruf):
  Datei "<stdin>", Zeile 1, in <module&gt
  Datei "<frozen os>", Zeile 679, in __getitem__
KeyError: 'API_KEY'

Behandlung von Schlüsselfehlern

Sie können den KeyError wie gezeigt behandeln:

importieren os

try:
	api_key = os.environ['API_KEY']
	print(f'API_KEY ist gesetzt auf: {api_key}')
except KeyError:
	print('API_KEY ist nicht gesetzt. Bitte konfigurieren Sie ihn.')

Bei diesem Ansatz wird die Ausführung des Programms nicht abrupt unterbrochen, wenn eine KeyError-Ausnahme ausgelöst wird. Er liefert jedoch eine aussagekräftige Fehlermeldung:

# Ausgabe
API_KEY ist nicht gesetzt. Bitte konfigurieren Sie ihn.

Wenn also der Rest des Programms nicht wie erwartet ausgeführt wird, wissen wir, dass wir es versäumt haben, eine erforderliche Umgebungsvariable zu setzen.

Zugriff auf Umgebungsvariablen mit der Methode get()

Sie können die Dictionary-Methode get() verwenden, um den Wert einer Umgebungsvariablen zu ermitteln. Anstelle eines KeyError gibt die get() -Methode None zurück, wenn die Variable nicht gefunden wird.

Der Zugriff auf die Variable NOT_SET, die wir nicht gesetzt haben, gibt None zurück:

print(os.environ.get('NOT_SET'))
# Ausgabe: Keine

Ich ziehe es vor, einen Key Error auszulösen, wenn die Umgebungsvariable nicht gesetzt ist. Dann lassen Sie sie stillschweigend passieren oder sie wird in der None, die die get() -Methode zurückgibt, subsumiert.

Aber die get() -Methode ist hilfreich, wenn wir einen Standardwert für eine bestimmte Umgebungsvariable übergeben können, wenn sie nicht gesetzt ist.

Hier ist ein Beispiel:

print(os.environ.get('HOME','/home/user'))
# Ausgabe: /home/balapriya

Wie man die Konfiguration mit Umgebungsvariablen verwaltet

Lassen Sie uns nun ein paar praktische Beispiele betrachten, in denen wir Umgebungsvariablen in unserer Anwendung verwenden.

Beispiel 1: Konfigurieren der Parameter für die Datenbankverbindung

Configuring-Database-Connection-Parameters

Angenommen, Sie möchten von Python aus eine Verbindung zu einer PostgreSQL-Datenbank herstellen. Dazu können Sie den psycopg2 Connector installieren und verwenden:

pip install psycopg2

In diesem Beispiel verwenden wir Umgebungsvariablen, um die Parameter für die Datenbankverbindung zu konfigurieren. Wenn die Umgebungsvariablen nicht gesetzt sind, stellen wir Standardwerte zur Verfügung, die Sie verwenden können.

importieren os
importieren psycopg2  

# Datenbankkonfiguration aus Umgebungsvariablen abrufen
db_host = os.environ.get('DB_HOST', 'localhost')
db_port = os.environ.get('DB_PORT', '5432')
db_user = os.environ.get('DB_USER', 'meinBenutzer')
db_password = os.environ.get('DB_PASSWORD', 'meinpasswort')

# Stellen Sie eine Datenbankverbindung her
try:
	connection = psycopg2.connect(
    	host=db_host,
    	port=db_port,
    	user=db_user,
    	password=db_password,
    	database='mydb'
	)
	print('Verbindung zur Datenbank hergestellt!')
except Exception as e:
	print(f'Fehler beim Verbinden mit der Datenbank: {e}')

Beispiel 2: Verwaltung von API-Schlüsseln

Nehmen wir ein weiteres Beispiel, das die Verwendung von API-Schlüsseln beinhaltet.

Neben der ChatGPT-Schnittstelle können Sie auch die OpenAI API verwenden, um OpenAI LLMs in Ihren Anwendungen zu unterstützen.

Wenn Sie sich für ein OpenAI-Konto anmelden, erhalten Sie (normalerweise) einige kostenlose, zeitlich begrenzte API-Credits. Holen Sie sich Ihren API-Schlüssel, indem Sie zu Einstellungen > API-Schlüssel anzeigen navigieren.

Sie können das Open AI Python SDK und ein Framework wie LangChain verwenden, um Anwendungen zu erstellen. Dazu müssen Sie die Bibliotheken (in einer virtuellen Umgebung) mit pip installieren:

pip install openai
pip install langchain

So können Sie den OPENAI_API_KEY als Umgebungsvariable setzen:

os importieren
os.environ["OPENAI_API_KEY"]='ihr-api-schlüssel'

Jetzt können Sie in Ihrem Skript auf die Open AI LLMs wie folgt zugreifen

from langchain.llms import OpenAI
model=OpenAI(model_name="gpt-3.5-turbo")

Wie Sie Umgebungsvariablen in Python ändern

Sie können auf das Wörterbuch os.environ aus dem os-Modul zugreifen, um Umgebungsvariablen innerhalb des aktuellen Python-Prozesses zu ändern:

os importieren

# Ändern Sie eine bestehende Umgebungsvariable oder erstellen Sie eine neue
os.environ['MEINE_VARIABLE'] = 'neuer_wert'

In Python können Sie das Modul subprocess verwenden, um Unterprozesse aus einem bestehenden Python-Skript heraus zu starten. Das ist hilfreich, wenn Sie Systemprogramme in Python ausführen möchten.

Im folgenden Beispiel ändern wir die Umgebungsvariable PATH, indem wir das Wörterbuch os.environ anzapfen. Anschließend führen wir echo $PATH als Unterprozess aus:

import os
import subprocess

# Setzen Sie eine benutzerdefinierte Umgebungsvariable für den Unterprozess
os.environ['PATH'] = '/custom/path'

# Starten Sie einen Unterprozess, der auf die Umgebungsvariable PATH zugreift
result = subprocess.run("echo $PATH", shell=True, stdout=subprocess.PIPE)
output = result.stdout.decode()
print(ausgabe)
print(f'Ausgabe des Unterprozesses: {Ausgabe}')

Wir sehen, dass der PATH den Wert von /custom/path annimmt:

# Ausgabe
/custom/path

Umfang der geänderten Umgebungsvariablen

Es ist wichtig zu beachten, dass diese Aktualisierungen der Umgebungsvariablen temporär sind und nur für den aktuellen Python-Prozess gelten. Sobald das Skript beendet wird, werden die Änderungen verworfen:

  • Aktueller Python-Prozess: Wenn Sie eine Umgebungsvariable mit os.environ in Ihrem Python-Skript ändern, ist die Änderung lokal für den aktuellen Python-Prozess. Sie wirkt sich nicht auf andere laufende Prozesse oder zukünftige Python-Sitzungen aus.
  • Untergeordnete Prozesse: Änderungen an Umgebungsvariablen, die innerhalb des aktuellen Python-Prozesses vorgenommen werden, werden an die von Ihrem Skript erstellten Kindprozesse weitergegeben. Wenn Sie z.B. einen Unterprozess von Ihrem Python-Skript (Elternprozess) erzeugen, hat der Unterprozess Zugriff auf die geänderten Umgebungsvariablen (wie im Beispiel zu sehen).
  • Nicht systemweit: Umgebungsvariablen, die innerhalb eines Python-Skripts gesetzt werden, bleiben außerhalb der Ausführung des Skripts nicht bestehen.

Wenn Sie dauerhafte Änderungen an Umgebungsvariablen auf Systemebene vornehmen möchten, müssen Sie dazu normalerweise betriebssystemspezifische Methoden verwenden.

Wie man .env Dateien mit python-dotenv lädt

Die Bibliothek python-dotenv ist ein beliebtes Python-Paket, das das Laden von Umgebungsvariablen aus einer .env-Datei in Ihr Python-Projekt vereinfacht. Sie ist besonders hilfreich, wenn Sie mehrere Umgebungen (z.B. Entwicklung, Produktion) mit unterschiedlichen Konfigurationen haben und diese Einstellungen von Ihrem Quellcode getrennt halten möchten.

Installieren von python-dotenv

Um python-dotenv zu verwenden, müssen Sie es zunächst installieren. Sie können es – innerhalb einer virtuellen Umgebung – mit pip, dem Python-Paketmanager, installieren:

pip install python-dotenv

Laden von Umgebungsvariablen aus einer .env Datei

Sie können nun eine .env-Datei im Stammverzeichnis Ihres Projekts erstellen und diese mit Schlüssel-Wert-Paaren füllen, genau wie normale Umgebungsvariablen. Lassen Sie uns die folgende .env-Datei mit Platzhalterwerten erstellen:

API_KEY=Ihr_api_key_hier
DB_PASSWORD=Ihr_Datenbank_Passwort_hier

Sie können nun die Umgebungsvariablen mit python-dotenv wie folgt aus der .env Datei laden:

import os
from dotenv import load_dotenv

# Laden der Umgebungsvariablen aus der .env-Datei
load_dotenv()

# Zugriff auf die Umgebungsvariablen
api_key = os.getenv("API_KEY")
datenbank_passwort = os.getenv("DB_PASSWORT")

# Drucken Sie die Umgebungsvariablen aus
print(f "API-Schlüssel: {api_key}")
print(f "Datenbank-Passwort: {Datenbank_Passwort}")

Beachten Sie, dass wir os.getenv(VARIABLE_NAME) verwendet haben, um die Werte der Umgebungsvariablen zu erhalten. Dies ist auch eine gültige (und weniger gebräuchliche) Methode für den Zugriff auf Umgebungsvariablen.

Hier ist die Ausgabe:

API-Schlüssel: ihr-api-schlüssel-hier
Datenbank-Passwort: ihre-datenbank-url-hier

In diesem Beispiel:

  • Wir verwenden load_dotenv(), um die in der Datei .env definierten Umgebungsvariablen in die aktuelle Umgebung zu laden.
  • Anschließend verwenden wir os.getenv(), um auf die Umgebungsvariablen zuzugreifen: API_KEY und DB_PASSWORD.

Fazit

Und das war’s schon! Ich hoffe, Sie haben gelernt, wie Sie die Konfiguration und sensible Informationen mit Hilfe von Umgebungsvariablen in Python-Anwendungen verwalten können. Wir haben die Grundlagen des Setzens von und des Zugriffs auf Umgebungsvariablen sowie deren praktische Verwendung bei der Konfiguration von Anwendungen behandelt.

Während Umgebungsvariablen sicherlich hilfreich sind, um die Konfiguration vom Quellcode zu trennen, sollten Sie sensible Variablen in Produktionsanwendungen als Geheimnisse speichern.

Für die Verwaltung von Geheimnissen empfehle ich Tools wie HashiCorp Vault oder AWS Secrets Manager.

Als Nächstes können Sie auch etwas über Python Floats und Python Flask lesen.