«`html
Ønsker du å forbedre måten du administrerer konfigurasjonen din på? Lær hvordan du bruker miljøvariabler effektivt i Python.
Da jeg begynte å lære Python, utviklet jeg prosjekter for å praktisere det jeg hadde lært. En del av dette innebar å koble til databaser og utføre spørringer med Python. Dette krevde at jeg lagret databasekonfigurasjon og sensitiv informasjon som brukernavn og passord for autentisering.
Det var ikke lurt å hardkode slik sensitiv informasjon direkte inn i et Python-skript. Derfor lærte jeg å bruke konfigurasjonsfiler og miljøvariabler, i kombinasjon med Pythons innebygde moduler.
Nå, når jeg trenger å bruke sensitiv informasjon som passord og API-nøkler i applikasjonene mine, setter jeg dem som miljøvariabler og henter dem når det er nødvendig. I denne veiledningen vil jeg forklare hva miljøvariabler er og hvordan du jobber med dem i Python.
Hva er miljøvariabler?
Miljøvariabler er dynamiske verdier utenfor selve applikasjonen som lagrer konfigurasjonsdata, systeminnstillinger og lignende. De administreres vanligvis av operativsystemet eller applikasjonsmiljøet. Her er noen nøkkelegenskaper for miljøvariabler:
- Navn-verdi-par: Miljøvariabler består av et unikt navn (også kjent som en nøkkel) og en tilhørende verdi.
- Systemomfang: Miljøvariabler kan defineres på systemnivå, og dermed være tilgjengelige for alle prosesser som kjører på systemet. De kan også endres eller settes på applikasjonsnivå, og påvirker kun den spesifikke applikasjonen.
- Dynamisk og foranderlig: Miljøvariabler kan endres mens applikasjonen kjører, noe som gir fleksibilitet.
Hvordan miljøvariabler er nyttige
Miljøvariabler har flere fordeler når det gjelder å håndtere konfigurasjon og sensitiv informasjon i Python-applikasjoner:
- Adskillelse av ansvarsområder: Ved å lagre konfigurasjon utenfor koden, holdes konfigurasjonsadministrasjon adskilt fra applikasjonslogikken.
- Sikkerhet: Sensitive data, som API-nøkler og databaselegitimasjon, kan lagres i miljøvariabler uten å eksponeres direkte i kildekoden. Dette reduserer risikoen for eksponering.
- Fleksibilitet: Det er enkelt å oppdatere konfigurasjonsinnstillinger via miljøvariabler, ettersom endringer kan gjøres utenfor selve koden. Dette gjør det enkelt å tilpasse konfigurasjonen for forskjellige miljøer eller ved oppdatering av legitimasjon.
I de neste avsnittene vil vi undersøke hvordan du setter, får tilgang til og administrerer miljøvariabler i Python, og hvordan de bidrar til å forbedre konfigurasjonsadministrasjonen i dine prosjekter.
Hvordan sette miljøvariabler
Du kan sette miljøvariabler via kommandolinjen. Området for disse variablene gjelder kun for gjeldende økt, og de vedvarer ikke utenfor denne økten.
For Mac- eller Linux-brukere, kan du sette en miljøvariabel i gjeldende terminaløkt på denne måten:
export MY_VARIABLE=min_verdi
Hvis du bruker Windows, kan du sette en miljøvariabel midlertidig slik:
set MY_VARIABLE=min_verdi
Få tilgang til miljøvariabler i Python
Python tilbyr os-modulen for operativsystemrelatert funksjonalitet. `os.environ` er en ordbok som inneholder miljøvariabler. Navnene på variablene er nøklene i ordboken, og verdiene er de tilhørende verdiene.
Du får tilgang til verdien av en miljøvariabel ved å bruke navnet som en nøkkel, akkurat som du ville gjort med elementer i en vanlig ordbok.
Her er et par eksempler:
import os print(os.environ['HOME']) # Output: /home/balapriya
print(os.environ['USER']) # Output: balapriya
Så langt, så bra. Men hva skjer hvis du prøver å hente verdien av en miljøvariabel som ikke er satt?
La oss prøve å få tilgang til `API_KEY` som vi ikke har satt enda:
print(os.environ['API_KEY'])
Som forventet får vi 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 av nøkkelfeil
Du kan håndtere `KeyError` på følgende måte:
import os
try:
api_key = os.environ['API_KEY']
print(f'API_KEY er satt til: {api_key}')
except KeyError:
print('API_KEY er ikke satt. Konfigurer den.')
Denne tilnærmingen vil ikke brått avslutte programmet når en `KeyError` oppstår. Isteden gir den en beskrivende feilmelding:
# Output API_KEY er ikke satt. Konfigurer den.
Dermed vil vi vite at en nødvendig miljøvariabel ikke er konfigurert dersom resten av programmet ikke kjører som forventet.
Få tilgang til miljøvariabler ved å bruke `get()`-metoden
Du kan bruke ordbokens `get()`-metode for å hente verdien av en miljøvariabel. I stedet for å returnere en `KeyError`, vil `get()`-metoden returnere `None` hvis variabelen ikke finnes.
Å hente `NOT_SET`-variabelen som vi ikke har konfigurert vil returnere `None`:
print(os.environ.get('NOT_SET'))
# Output: None
Jeg foretrekker å utløse en `KeyError` når en miljøvariabel ikke er definert, istedenfor å la det passere eller lagre `None` som `get()`-metoden returnerer.
`get()`-metoden er derimot nyttig når vi kan angi en standardverdi for en bestemt miljøvariabel hvis den ikke er definert.
Her er et eksempel:
print(os.environ.get('HOME','/home/bruker'))
# Output: /home/balapriya
Hvordan administrere konfigurasjon med miljøvariabler
La oss se på noen praktiske eksempler der vi bruker miljøvariabler i applikasjonene våre.
Eksempel 1: Konfigurere databasetilkoblingsparametere
Anta at du ønsker å koble til en PostgreSQL-database fra Python. For å gjøre dette kan du installere og bruke `psycopg2`-tilkoblingen:
pip install psycopg2
I dette eksemplet bruker vi miljøvariabler til å konfigurere databasetilkoblingsparametrene. Hvis miljøvariablene ikke er satt, gir vi standardverdier som skal brukes.
import os
import psycopg2
# Hent databasekonfigurasjon fra miljøvariabler
db_host = os.environ.get('DB_HOST', 'localhost')
db_port = os.environ.get('DB_PORT', '5432')
db_user = os.environ.get('DB_USER', 'minbruker')
db_password = os.environ.get('DB_PASSWORD', 'mittpassord')
# Opprett en databaseforbindelse
try:
connection = psycopg2.connect(
host=db_host,
port=db_port,
user=db_user,
password=db_password,
database="mydb"
)
print('Koblet til databasen!')
except Exception as e:
print(f'Feil ved tilkobling til databasen: {e}')
Eksempel 2: Administrere API-nøkler
La oss se på et annet eksempel som involverer bruk av API-nøkler.
I tillegg til ChatGPT-grensesnittet kan du også bruke OpenAI API for å benytte OpenAI LLM-er i dine applikasjoner.
Når du registrerer deg for en OpenAI-konto, vil du (vanligvis se) noen gratis tidsbegrensede API-kreditter. Du kan finne API-nøkkelen din under Innstillinger > Vis API-nøkler.
Du kan bruke Open AI Python SDK og et rammeverk som LangChain til å bygge applikasjoner. For å gjøre dette, må du installere bibliotekene (i et virtuelt miljø) med `pip`:
pip install openai pip install langchain
Slik kan du sette `OPENAI_API_KEY` som en miljøvariabel:
import os os.environ["OPENAI_API_KEY"]='din-api-nøkkel'
Du kan nå få tilgang til Open AI LLM-er i skriptet ditt slik:
from langchain.llms import OpenAI model=OpenAI(model_name="gpt-3.5-turbo")
Hvordan endre miljøvariabler i Python
Du kan endre miljøvariabler i den gjeldende Python-prosessen ved å endre `os.environ`-ordboken fra `os`-modulen:
import os # Endre en eksisterende miljøvariabel eller opprett en ny os.environ['MY_VARIABLE'] = 'ny_verdi'
I Python kan du bruke `subprocess`-modulen til å opprette delprosesser fra eksisterende Python-skript. Dette er nyttig når du vil kjøre systemprogrammer i Python.
I det følgende eksemplet endrer vi `PATH`-miljøvariabelen ved å endre `os.environ`-ordboken. Deretter kjører vi `echo $PATH` som en delprosess:
import os
import subprocess
# Sett en tilpasset miljøvariabel for delprosessen
os.environ['PATH'] = '/tilpasset/sti'
# Kjør en delprosess som aksesserer PATH-miljøvariabelen
result = subprocess.run("echo $PATH", shell=True, stdout=subprocess.PIPE)
output = result.stdout.decode()
print(output)
print(f'Delprosessens output: {output}')
Vi ser at `PATH` har verdien `/tilpasset/sti`:
# Output /tilpasset/sti
Omfanget av de endrede miljøvariablene
Det er viktig å merke seg at disse oppdateringene av miljøvariabler er midlertidige, og kun gjelder for den gjeldende Python-prosessen. Endringene forkastes når skriptet avsluttes:
- Gjeldende Python-prosess: Når du endrer en miljøvariabel ved hjelp av `os.environ` i et Python-skript, er endringen lokal for den gjeldende Python-prosessen. Det vil ikke påvirke andre kjørende prosesser eller fremtidige Python-økter.
- Underordnede prosesser: Endringer i miljøvariabler som gjøres i den gjeldende Python-prosessen arves av underordnede prosesser som opprettes av skriptet. Hvis du for eksempel oppretter en underprosess fra et Python-skript, vil underprosessen ha tilgang til de endrede miljøvariablene (som vist i eksemplet).
- Ikke systemomfattende: Miljøvariabler satt i et Python-skript vil ikke vedvare utenom utførelsen av det skriptet.
Hvis du trenger å gjøre permanente endringer i miljøvariabler på systemnivå, må du vanligvis gjøre dette ved å bruke operativsystemspesifikke metoder.
Hvordan laste inn `.env`-filer med `python-dotenv`
`python-dotenv`-biblioteket er en populær Python-pakke som forenkler prosessen med å laste inn miljøvariabler fra en `.env`-fil til et Python-prosjekt. Dette er spesielt nyttig når du har flere miljøer (for eksempel utvikling, produksjon) med forskjellige konfigurasjoner, og du ønsker å holde disse innstillingene adskilt fra kildekoden.
Installerer `python-dotenv`
For å bruke `python-dotenv`, må du installere det først. Du kan installere det – i et virtuelt miljø – ved å bruke `pip`, Python-pakkehåndtereren:
pip install python-dotenv
Laster inn miljøvariabler fra en `.env`-fil
Du kan nå opprette en `.env`-fil i prosjektets rotkatalog og fylle den med nøkkel-verdi-par, akkurat som vanlige miljøvariabler. La oss lage følgende `.env`-fil med plassholderverdier:
API_KEY=din_api_nøkkel_her DB_PASSWORD=ditt_databasepassord_her
Du kan nå laste inn miljøvariablene fra `.env`-filen ved å bruke `python-dotenv` slik:
import os
from dotenv import load_dotenv
# Last miljøvariabler fra .env-filen
load_dotenv()
# Hent miljøvariablene
api_key = os.getenv("API_KEY")
database_password = os.getenv("DB_PASSWORD")
# Skriv ut miljøvariablene
print(f"API-nøkkel: {api_key}")
print(f"Databasepassord: {database_password}")
Merk at vi har brukt `os.getenv(VARIABEL_NAVN)` for å hente verdiene av miljøvariablene. Dette er også en gyldig (og mindre vanlig) måte å få tilgang til miljøvariabler på.
Her er output:
API-nøkkel: din_api_nøkkel_her Databasepassord: ditt_databasepassord_her
I dette eksemplet:
- Vi bruker `load_dotenv()` for å laste miljøvariablene definert i `.env`-filen inn i det gjeldende miljøet.
- Deretter bruker vi `os.getenv()` for å hente miljøvariablene: `API_KEY` og `DB_PASSWORD`.
Konklusjon
Og det var det hele! Jeg håper du har lært hvordan du administrerer konfigurasjon og sensitiv informasjon ved å bruke miljøvariabler i Python-applikasjoner. Vi har gått gjennom det grunnleggende om å sette og få tilgang til miljøvariabler, samt deres praktiske bruk ved konfigurering av applikasjoner.
Selv om miljøvariabler er nyttige for å skille konfigurasjon fra kildekoden, bør du lagre sensitive variabler som hemmeligheter i produksjonstilfeller. For å administrere hemmeligheter, anbefaler jeg å utforske verktøy som HashiCorp Vault eller AWS Secrets Manager.
«`