Variabilele de mediu Python și cum să lucrați cu ele

Cuprins

Vrei să-ți organizezi mai bine setările? Descoperă cum poți utiliza variabilele de mediu în Python.

Când am început să învăț Python pe cont propriu, am creat proiecte pentru a aplica cunoștințele nou dobândite. Multe dintre ele implicau conectarea la o bază de date și interogarea acesteia folosind Python. Asta însemna că trebuia să salvez informații de configurare ale bazei de date și detalii sensibile, precum numele de utilizator și parola pentru autentificare.

Înglobarea acestor date confidențiale direct în codul Python nu era o soluție bună. Așa am învățat să folosesc fișiere de configurare și variabile de mediu, împreună cu modulele încorporate ale Python, pentru a gestiona aceste date.

Așadar, de fiecare dată când am nevoie să folosesc informații delicate, cum ar fi parole și chei API în aplicațiile mele, le definesc ca variabile de mediu și le accesez când este necesar. În acest tutorial, te voi ghida prin lumea variabilelor de mediu și cum să lucrezi cu ele în Python.

Ce sunt variabilele de mediu?

Variabilele de mediu sunt variabile externe aplicației tale, care stochează date de configurare, setări de sistem și alte informații similare. De obicei, sunt gestionate de sistemul de operare sau de mediul aplicației. Iată câteva caracteristici esențiale ale variabilelor de mediu:

Asocieri nume-valoare: variabilele de mediu constau dintr-un nume (numit și cheie) și o valoare aferentă.
Sferă la nivel de sistem: Poți defini variabile de mediu la nivel de sistem, făcându-le disponibile pentru toate procesele care rulează pe acel sistem. Dacă este nevoie, le poți modifica sau defini și la nivel de aplicație, afectând doar aplicația respectivă.
Dinamice și modificabile: variabilele de mediu pot fi modificate în timpul execuției, oferind flexibilitate.

Care este utilitatea variabilelor de mediu?

Variabilele de mediu oferă numeroase avantaje pentru gestionarea setărilor și a informațiilor sensibile din aplicațiile tale Python:

Separarea responsabilităților: stocând configurația în afara codului, menții gestionarea setărilor separată de logica aplicației.
Securitate: poți stoca date sensibile, precum chei API și credențiale ale bazelor de date, în variabile de mediu, fără a le afișa în codul sursă, reducând riscul de expunere.
Flexibilitate: Cu variabilele de mediu, actualizarea setărilor de configurare este ușoară, deoarece poți face modificări în afara codului. Variabilele de mediu îți permit să ajustezi setările fără a modifica codul. Această flexibilitate este utilă mai ales la implementarea aplicațiilor în medii diferite sau la actualizarea credențialelor.

În următoarele secțiuni ale acestui tutorial, vom vedea cum poți seta, accesa și gestiona variabilele de mediu în Python și cum acestea îmbunătățesc organizarea configurației în proiectele tale.

Cum setezi variabilele de mediu?

Variabilele de mediu pot fi setate folosind linia de comandă. Sfera acestor variabile este limitată la sesiunea curentă și nu persistă după încheierea acesteia.

Dacă folosești un sistem Mac sau Linux, poți seta o variabilă de mediu în sesiunea curentă a terminalului, astfel:

export MY_VARIABLE=valoare_mea

Dacă folosești Windows, poți seta temporar o variabilă de mediu, după cum urmează:

set MY_VARIABLE=valoare_mea

Cum accesezi variabilele de mediu în Python?

Python oferă modulul os pentru funcții legate de sistemul de operare. `os.environ` este un dicționar ce conține variabilele de mediu. Numele variabilelor de mediu și valorile lor sunt cheile, respectiv valorile dicționarului.

Așadar, poți accesa valorile variabilelor de mediu folosind numele lor ca și chei, exact cum ai accesa elementele unui dicționar.

Iată câteva exemple:

import os
print(os.environ['HOME'])
# Ieșire: /home/utilizator

print(os.environ['USER'])
# Ieșire: utilizator

Până aici, totul bine. Dar ce se întâmplă dacă încerci să accesezi valoarea unei variabile de mediu care nu a fost niciodată definită?

Să încercăm să accesăm `API_KEY` pe care nu am definit-o:

print(os.environ['API_KEY'])

După cum ne așteptam, vei primi o eroare `KeyError`:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<frozen os>", line 679, in __getitem__
KeyError: 'API_KEY'

Cum gestionezi erorile de tip cheie?

Poți gestiona `KeyError` așa cum se arată mai jos:

import os

try:
  api_key = os.environ['API_KEY']
  print(f'API_KEY este setată la: {api_key}')
except KeyError:
  print('API_KEY nu este definită. Te rugăm să o configurezi.')

Această abordare nu oprește brusc execuția programului când apare o excepție `KeyError`. În schimb, oferă un mesaj de eroare descriptiv:

# Ieșire
API_KEY nu este definită. Te rugăm să o configurezi.

Astfel, dacă restul programului nu funcționează cum era de așteptat, știm că am omis să definim o variabilă de mediu necesară.

Cum accesezi variabilele de mediu folosind metoda `get()`?

Poți folosi metoda `get()` a dicționarului pentru a obține valoarea unei variabile de mediu. Spre deosebire de `KeyError`, metoda `get()` returnează `None` dacă variabila nu este găsită.

Accesarea variabilei `NOT_SET` pe care nu am definit-o returnează `None`:

print(os.environ.get('NOT_SET'))
# Ieșire: None

Personal, prefer să se genereze o eroare de tip cheie când variabila de mediu nu este definită. Apoi, o ignor sau o subsumez în `None`-ul returnat de metoda `get()`.

Însă, metoda `get()` este utilă când putem defini o valoare implicită pentru o anumită variabilă de mediu dacă aceasta nu este setată.

Iată un exemplu:

print(os.environ.get('HOME','/home/utilizator'))
# Ieșire: /home/balapriya

Cum gestionezi configurația cu variabile de mediu?

Acum vom lua câteva exemple practice în care folosim variabilele de mediu în aplicația noastră.

Exemplul 1: Configurare parametrii de conectare la baza de date

Să presupunem că vrei să te conectezi la o bază de date PostgreSQL din Python. Pentru asta, poți instala și folosi conectorul `psycopg2`:

pip install psycopg2

În acest exemplu, folosim variabile de mediu pentru a configura parametrii de conectare la baza de date. Dacă variabilele de mediu nu sunt definite, folosim valori implicite.

import os
import psycopg2  

# Extrage configurația bazei de date din variabilele de mediu
db_host = os.environ.get('DB_HOST', 'localhost')
db_port = os.environ.get('DB_PORT', '5432')
db_user = os.environ.get('DB_USER', 'utilizator_meu')
db_password = os.environ.get('DB_PASSWORD', 'parola_mea')

# Stabilește o conexiune la baza de date
try:
  connection = psycopg2.connect(
      host=db_host,
      port=db_port,
      user=db_user,
      password=db_password,
      database="baza_mea"
  )
  print('Conectat la baza de date!')
except Exception as e:
  print(f'Eroare la conectarea la baza de date: {e}')

Exemplul 2: Gestionare chei API

Să luăm un alt exemplu care implică folosirea cheilor API.

Pe lângă interfața ChatGPT, poți utiliza și API-ul OpenAI pentru a integra modele lingvistice mari (LLM) în aplicațiile tale.

Când te înregistrezi pentru un cont OpenAI, vei primi (de obicei) câteva credite API gratuite, limitate în timp. Obții cheia API navigând la Setări > Vezi cheile API.

Poți folosi SDK-ul Open AI Python și un cadru de lucru precum LangChain pentru a construi aplicații. Pentru asta, trebuie să instalezi bibliotecile (într-un mediu virtual) folosind pip:

pip install openai
pip install langchain

Iată cum poți defini `OPENAI_API_KEY` ca variabilă de mediu:

import os
os.environ["OPENAI_API_KEY"]='cheia_ta_api'

Acum poți accesa modelul lingvistic Open AI (LLM) în scriptul tău astfel:

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

Cum modifici variabilele de mediu în Python?

Poți accesa dicționarul `os.environ` din modulul `os` pentru a modifica variabilele de mediu în procesul Python curent:

import os

# Modifică o variabilă de mediu existentă sau creează una nouă
os.environ['MY_VARIABLE'] = 'valoare_noua'

În Python, poți folosi modulul subprocess pentru a lansa subprocese din scriptul Python curent. Asta este util când vrei să rulezi programe de sistem în Python.

În exemplul următor, modificăm variabila de mediu `PATH` prin accesarea dicționarului `os.environ`. Apoi, rulăm `echo $PATH` ca subproces:

import os
import subprocess

# Definește o variabilă de mediu personalizată pentru subproces
os.environ['PATH'] = '/cale/personalizata'

# Rulează un subproces care accesează variabila de mediu PATH
result = subprocess.run("echo $PATH", shell=True, stdout=subprocess.PIPE)
output = result.stdout.decode()
print(output)
print(f'Ieșirea subprocesului: {output}')

Observăm că `PATH` preia valoarea `/cale/personalizata`:

# Ieșire
/cale/personalizata

Sfera variabilelor de mediu modificate

Este important de reținut că aceste modificări ale variabilelor de mediu sunt temporare și sunt valabile doar pentru procesul Python curent. Când scriptul se termină, modificările sunt eliminate:

Procesul Python curent: Când modifici o variabilă de mediu folosind `os.environ` în scriptul Python, modificarea este locală procesului Python curent. Nu va afecta alte procese care rulează sau sesiunile viitoare Python.
Procese copil: Modificările variabilelor de mediu făcute în procesul Python curent sunt moștenite de procesele copil create de scriptul tău. De exemplu, dacă lansezi un subproces din scriptul Python (procesul părinte), subprocesul va avea acces la variabilele de mediu modificate (după cum se vede în exemplu).
Nu la nivel de sistem: Variabilele de mediu setate într-un script Python nu vor persista după încheierea execuției acelui script.

Dacă este nevoie să faci modificări persistente la variabilele de mediu la nivel de sistem, de obicei trebuie să folosești metode specifice sistemului de operare.

Cum încarci fișiere `.env` cu `python-dotenv`?

Biblioteca `python-dotenv` este un pachet Python popular care simplifică procesul de încărcare a variabilelor de mediu dintr-un fișier `.env` în proiectul tău Python. Este deosebit de util când ai mai multe medii (de exemplu, dezvoltare, producție) cu setări diferite și vrei să păstrezi aceste setări separate de codul sursă.

Instalarea `python-dotenv`

Pentru a folosi `python-dotenv`, trebuie să-l instalezi mai întâi. Poți face asta folosind `pip`, managerul de pachete Python, într-un mediu virtual:

pip install python-dotenv

Încărcarea variabilelor de mediu dintr-un fișier `.env`

Acum, poți crea un fișier `.env` în directorul rădăcină al proiectului și să-l populezi cu asocieri cheie-valoare, similar cu variabilele de mediu obișnuite. Să creăm următorul fișier `.env` cu valori generice:

API_KEY=cheia_ta_api
DB_PASSWORD=parola_ta_baza_de_date

Acum poți încărca variabilele de mediu din fișierul `.env` folosind `python-dotenv` astfel:

import os
from dotenv import load_dotenv

# Încarcă variabilele de mediu din fișierul .env
load_dotenv()

# Accesează variabilele de mediu
api_key = os.getenv("API_KEY")
database_password = os.getenv("DB_PASSWORD")

# Afișează variabilele de mediu
print(f"Cheie API: {api_key}")
print(f"Parolă bază de date: {database_password}")

Observă că am folosit `os.getenv(VARIABLE_NAME)` pentru a obține valorile variabilelor de mediu. Aceasta este, de asemenea, o modalitate validă (și mai puțin folosită) de a accesa variabilele de mediu.

Iată rezultatul:

Cheie API: cheia_ta_api
Parolă bază de date: parola_ta_baza_de_date

În acest exemplu:

Folosim `load_dotenv()` pentru a încărca variabilele de mediu definite în fișierul `.env` în mediul curent.
Apoi, folosim `os.getenv()` pentru a accesa variabilele de mediu: `API_KEY` și `DB_PASSWORD`.

Concluzie

Asta este tot! Sper că ai învățat cum să gestionezi configurația și informațiile sensibile folosind variabilele de mediu în aplicațiile Python. Am acoperit elementele de bază ale definirii și accesării variabilelor de mediu, precum și utilizarea lor practică în configurarea aplicațiilor.

Deși variabilele de mediu sunt foarte utile pentru separarea configurației de codul sursă, ar trebui să stochezi variabilele sensibile ca secrete în cazurile de utilizare din producție. Pentru gestionarea secretelor, îți recomand să explorezi instrumente precum HashiCorp Vault sau AWS Secrets Manager.