Vil du administrere din konfiguration bedre? Lær, hvordan du arbejder med miljøvariabler i Python.
Da jeg underviste mig selv i Python, byggede jeg projekter for at anvende det, jeg lige havde lært. En delmængde af de involverede, der opretter forbindelse til en database og forespørger den ved hjælp af Python. Hvilket betød, at jeg skulle gemme databasekonfigurationen og følsomme oplysninger såsom brugernavn og adgangskode til godkendelse.
Hård kodning af sådanne følsomme oplysninger i et Python-script var ikke en god idé. Og jeg lærte, hvordan man bruger konfigurationsfiler og miljøvariabler – sammen med Pythons indbyggede moduler til at arbejde med dem.
Så hver gang jeg skal bruge følsomme oplysninger såsom adgangskoder og API-nøgler i mine applikationer, indstiller jeg dem som miljøvariabler og henter dem efter behov. I denne tutorial vil jeg lede dig gennem miljøvariabler, og hvordan du arbejder med dem i Python.
Indholdsfortegnelse
Hvad er miljøvariabler?
Miljøvariabler er variabler uden for din applikation, som gemmer konfigurationsoplysninger, systemindstillinger og lignende. De administreres typisk af operativsystemet eller applikationsmiljøet. Nøglekarakteristika for miljøvariabler omfatter:
- Navne-værdi-par: Miljøvariabler består af et navn (også kendt som en nøgle) og en tilsvarende værdi.
- Systemomfang: Du kan indstille miljøvariabler på systemniveau, hvilket gør dem tilgængelige for alle processer, der kører på systemet. Hvis det er nødvendigt, kan du også ændre eller definere dem på applikationsniveau, hvilket kun påvirker den specifikke applikation.
- Dynamisk og foranderlig: Du kan ændre miljøvariabler under kørsel, hvilket giver fleksibilitet.
Hvordan miljøvariabler er nyttige
Miljøvariabler tilbyder adskillige fordele ved styring af konfiguration og følsomme oplysninger i dine Python-applikationer:
- Adskillelse af bekymringer: Ved at gemme konfiguration uden for din kode holder du bekymringerne omkring konfigurationsstyring adskilt fra din applikationslogik.
- Sikkerhed: Du kan gemme følsomme data, såsom API-nøgler og databaselegitimationsoplysninger, i miljøvariabler – uden at udsætte dem i kildekoden – hvilket reducerer risikoen for eksponering.
- Fleksibilitet: Med miljøvariabler er opdatering af konfigurationsindstillinger enkel, da du kan opdatere/foretage ændringer uden for kodebasen. Miljøvariabler giver dig mulighed for at justere konfigurationsindstillinger uden at ændre din kode. Denne fleksibilitet er især nyttig til at implementere applikationer til forskellige miljøer eller ved opdatering af legitimationsoplysninger.
I de følgende afsnit af denne øvelse vil vi undersøge, hvordan du indstiller, får adgang til og administrerer miljøvariabler i Python, og hvordan de forbedrer konfigurationsstyringen i dine projekter.
Sådan indstilles miljøvariabler
Du kan indstille miljøvariabler ved hjælp af kommandolinjen. Omfanget af sådanne miljøvariabler gælder kun for den aktuelle session – og de fortsætter ikke uden for den aktuelle session.
Hvis du er på en Mac- eller Linux-maskine, kan du indstille en miljøvariabel i din aktuelle terminalsession som sådan:
export MY_VARIABLE=my_value
Hvis du er en Windows-bruger, kan du indstille en miljøvariabel midlertidigt som vist:
set MY_VARIABLE=my_value
Få adgang til miljøvariabler i Python
Python leverer os modul til operativsystemrelateret funktionalitet. Og os.environ er en ordbog over miljøvariabler. Navnene på miljøvariablerne og deres værdier er henholdsvis nøglerne og værdierne i ordbogen.
Så du kan få adgang til værdierne af miljøvariabler – ved at bruge (deres navne som) nøglerne – på samme måde som du ville få adgang til elementer i en ordbog.
Her er et par eksempler:
import os print(os.environ['HOME']) # Output: /home/balapriya
print(os.environ['USER']) # Output: balapriya
Så langt så godt. Men hvad sker der, hvis du forsøger at få adgang til værdien af en miljøvariabel, der aldrig blev indstillet?
Lad os prøve at få adgang til API_KEY, som vi endnu ikke har indstillet:
print(os.environ['API_KEY'])
Som forventet får du en KeyError:
Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<frozen os>", line 679, in __getitem__ KeyError: 'API_KEY'
Håndtering af nøglefejl
Du kan håndtere KeyError som vist:
import os
try:
api_key = os.environ['API_KEY']
print(f'API_KEY is set to: {api_key}')
except KeyError:
print('API_KEY is not set. Please configure it.')
Denne fremgangsmåde stopper ikke brat udførslen af programmet, når der opstår en KeyError-undtagelse. Det giver dog en beskrivende fejlmeddelelse:
# Output API_KEY is not set. Please configure it.
Så når resten af programmet ikke kører som forventet, ved vi, at vi har savnet at indstille en påkrævet miljøvariabel.
Adgang til miljøvariabler ved hjælp af get()-metoden
Du kan bruge ordbogsmetoden get() til at få værdien af en miljøvariabel. I stedet for en KeyError returnerer get()-metoden Ingen, hvis variablen ikke findes.
Adgang til NOT_SET-variablen, som vi ikke har sat, returnerer Ingen:
print(os.environ.get('NOT_SET'))
# Output: None
Jeg foretrækker at rejse en nøglefejl, når miljøvariablen ikke er indstillet. Lad det derefter passere lydløst eller indordnes i den Ingen, som get()-metoden returnerer.
Men metoden get() er nyttig, når vi kan indsætte en standardværdi for en bestemt miljøvariabel, hvis den ikke er indstillet.
Her er et eksempel:
print(os.environ.get('HOME','/home/user'))
# Output: /home/balapriya
Sådan administreres konfiguration med miljøvariabler
Lad os nu tage et par praktiske eksempler, hvor vi bruger miljøvariabler i vores applikation.
Eksempel 1: Konfiguration af databaseforbindelsesparametre
Lad os sige, at du vil oprette forbindelse til en PostgreSQL-database fra Python. For at gøre det kan du installere og bruge psycopg2-stikket:
pip install psycopg2
I dette eksempel bruger vi miljøvariabler til at konfigurere databaseforbindelsesparametrene. Hvis miljøvariablerne ikke er indstillet, giver vi standardværdier til brug.
import os
import psycopg2
# Retrieve database configuration from environment variables
db_host = os.environ.get('DB_HOST', 'localhost')
db_port = os.environ.get('DB_PORT', '5432')
db_user = os.environ.get('DB_USER', 'myuser')
db_password = os.environ.get('DB_PASSWORD', 'mypassword')
# Establish a database connection
try:
connection = psycopg2.connect(
host=db_host,
port=db_port,
user=db_user,
password=db_password,
database="mydb"
)
print('Connected to the database!')
except Exception as e:
print(f'Error connecting to the database: {e}')
Eksempel 2: Håndtering af API-nøgler
Lad os tage et andet eksempel, der involverer brugen af API-nøgler.
Ud over ChatGPT-grænsefladen kan du også bruge OpenAI API til at understøtte OpenAI LLM’er i dine applikationer.
Når du tilmelder dig en OpenAI-konto, vil du (typisk se) nogle gratis tidsbegrænsede API-kreditter. Grib din API-nøgle ved at navigere til Indstillinger > Se API-nøgler.
Du kan bruge Open AI Python SDK og et framework som LangChain til at bygge applikationer. For at gøre det skal du installere bibliotekerne (i et virtuelt miljø) ved hjælp af pip:
pip install openai pip install langchain
Sådan kan du indstille OPENAI_API_KEY som en miljøvariabel:
import os os.environ["OPENAI_API_KEY"]='your-api-key'
Du kan nu få adgang til Open AI LLM’erne i dit script som sådan:
from langchain.llms import OpenAI model=OpenAI(model_name="gpt-3.5-turbo")
Sådan ændres miljøvariabler i Python
Du kan bruge os.environ-ordbogen fra os-modulet for at ændre miljøvariabler inden for den aktuelle Python-proces:
import os # Modify an existing environment variable or create a new one os.environ['MY_VARIABLE'] = 'new_value'
I Python kan du bruge delprocesmodul at skabe underprocesser fra eksisterende Python-script. Hvilket er nyttigt, når du vil køre systemprogrammer i Python.
I det følgende eksempel ændrer vi PATH-miljøvariablen ved at trykke ind i os.environ-ordbogen. Vi kører derefter echo $PATH som en underproces:
import os
import subprocess
# Set a custom environment variable for the subprocess
os.environ['PATH'] = '/custom/path'
# Run a subprocess that accesses the PATH environment variable
result = subprocess.run("echo $PATH", shell=True, stdout=subprocess.PIPE)
output = result.stdout.decode()
print(output)
print(f'Subprocess output: {output}')
Vi ser, at PATH tager værdien af /custom/path:
# Output /custom/path
Omfanget af de ændrede miljøvariabler
Det er vigtigt at bemærke, at disse miljøvariableopdateringer er midlertidige og kun er gyldige for den aktuelle Python-proces. Når scriptet afsluttes, kasseres ændringerne:
- Nuværende Python-proces: Når du ændrer en miljøvariabel ved hjælp af os.environ i dit Python-script, er ændringen lokal for den aktuelle Python-proces. Det vil ikke påvirke andre kørende processer eller fremtidige Python-sessioner.
- Underordnede processer: Ændringer i miljøvariabler foretaget inden for den aktuelle Python-proces nedarves af underordnede processer, der er oprettet af dit script. For eksempel, hvis du afføder en underproces fra dit Python-script (overordnet proces), vil den underordnede proces have adgang til de ændrede miljøvariabler (som det ses i eksemplet).
- Ikke hele systemet: Miljøvariabler, der er indstillet i et Python-script, vil ikke eksistere uden for det pågældende scripts udførelse.
Hvis du skal foretage vedvarende ændringer af miljøvariabler på systemniveau, skal du typisk gøre det ved at bruge operativsystemspecifikke metoder.
Sådan indlæses .env-filer med python-dotenv
Det python-dotenv bibliotek er en populær Python-pakke, der forenkler processen med at indlæse miljøvariabler fra en .env-fil til dit Python-projekt. Det er især nyttigt, når du har flere miljøer (f.eks. udvikling, produktion) med forskellige konfigurationer, og du ønsker at holde disse indstillinger adskilt fra din kildekode.
Installation af python-dotenv
For at bruge python-dotenv skal du først installere det. Du kan installere det – inde i et virtuelt miljø – ved hjælp af pip, Python-pakkehåndteringen:
pip install python-dotenv
Indlæser miljøvariabler fra en .env-fil
Du kan nu oprette en .env-fil i dit projekts rodmappe og udfylde den med nøgleværdi-par, ligesom almindelige miljøvariabler. Lad os oprette følgende .env-fil med pladsholderværdier:
API_KEY=your_api_key_here DB_PASSWORD=your_database_password_here
Du kan nu indlæse miljøvariablerne fra .env-filen ved at bruge python-dotenv sådan:
import os
from dotenv import load_dotenv
# Load environment variables from .env file
load_dotenv()
# Access the environment variables
api_key = os.getenv("API_KEY")
database_password = os.getenv("DB_PASSWORD")
# Print out the env variables
print(f"API Key: {api_key}")
print(f"Database Password: {database_password}")
Bemærk, at vi har brugt os.getenv(VARIABLE_NAME) til at få værdierne af miljøvariablerne. Dette er også en gyldig (og mindre almindeligt brugt) måde at få adgang til miljøvariabler på.
Her er outputtet:
API Key: your-api-key-here Database Password: your-database-url-here
I dette eksempel:
- Vi bruger load_dotenv() til at indlæse miljøvariablerne defineret i .env-filen i det aktuelle miljø.
- Vi bruger derefter os.getenv() til at få adgang til miljøvariablerne: API_KEY og DB_PASSWORD.
Konklusion
Og det er en indpakning! Jeg håber, du har lært, hvordan du administrerer konfiguration og følsomme oplysninger ved hjælp af miljøvariabler i Python-applikationer. Vi har dækket det grundlæggende i indstilling og adgang til miljøvariabler, såvel som deres praktiske brug ved konfiguration af applikationer.
Selvom miljøvariabler bestemt er nyttige til at adskille config fra kildekoden, bør du gemme følsomme variabler som hemmeligheder i produktionstilfælde. Til håndtering af hemmeligheder anbefaler jeg at udforske værktøjer som HashiCorp Vault eller AWS Secrets Manager.
