Želite li unaprediti upravljanje postavkama vaše aplikacije? Otkrijte kako da koristite promenljive okruženja u Pythonu.
Kada sam počinjao učiti Python, kreirao sam projekte da bih primenio nova znanja. Jedan od tih projekata uključivao je povezivanje sa bazom podataka i interakciju sa njom pomoću Pythona. To je značilo da moram da sačuvam konfiguraciju baze podataka i poverljive informacije poput korisničkog imena i lozinke za autentifikaciju.
Direktno upisivanje takvih poverljivih podataka u Python skripte nije bila pametna ideja. Zato sam naučio da koristim konfiguracione datoteke i promenljive okruženja – uz pomoć ugrađenih Python modula za rad sa njima.
Stoga, kada god treba da koristim osetljive informacije, kao što su lozinke i API ključevi u svojim aplikacijama, postavljam ih kao promenljive okruženja i preuzimam ih po potrebi. U ovom vodiču ću vas provesti kroz koncept promenljivih okruženja i pokazati kako da ih koristite u Pythonu.
Šta su promenljive okruženja?
Promenljive okruženja su promenljive koje se nalaze izvan vaše aplikacije i služe za čuvanje konfiguracionih postavki, sistemskih podešavanja i slično. Obično njima upravlja operativni sistem ili okruženje u kojem aplikacija radi. Ključne karakteristike promenljivih okruženja uključuju:
- Parovi naziv-vrednost: Promenljive okruženja se sastoje od naziva (takođe poznatog kao ključ) i odgovarajuće vrednosti.
- Sistemski opseg: Možete podesiti promenljive okruženja na nivou sistema, što ih čini dostupnim svim procesima koji se pokreću na tom sistemu. Takođe ih možete definisati ili izmeniti na nivou aplikacije, utičući samo na tu specifičnu aplikaciju.
- Dinamičke i promenljive: Promenljive okruženja možete menjati tokom rada aplikacije, pružajući fleksibilnost.
Kako su promenljive okruženja korisne
Promenljive okruženja nude nekoliko prednosti za upravljanje konfiguracijom i osetljivim podacima u vašim Python aplikacijama:
- Razdvajanje odgovornosti: Čuvanjem konfiguracije van vašeg koda, odvajate brigu o upravljanju konfiguracijom od logike vaše aplikacije.
- Bezbednost: Možete skladištiti poverljive podatke, kao što su API ključevi i akreditivi za bazu podataka, u promenljivim okruženja – bez izlaganja u izvornom kodu – smanjujući rizik od curenja informacija.
- Fleksibilnost: Sa promenljivama okruženja, ažuriranje konfiguracionih postavki je jednostavno, jer možete unositi promene van samog koda. Promenljive okruženja omogućavaju da prilagodite podešavanja bez potrebe za izmenama u kodu. Ova fleksibilnost je posebno korisna kada primenjujete aplikacije u različitim okruženjima ili prilikom ažuriranja akreditiva.
U narednim delovima ovog vodiča, istražićemo kako da postavite, pristupite i upravljate promenljivim okruženja u Pythonu, i kako one poboljšavaju upravljanje konfiguracijom u vašim projektima.
Kako podesiti promenljive okruženja
Promenljive okruženja možete podesiti pomoću komandne linije. Opseg takvih promenljivih okruženja odnosi se samo na trenutnu sesiju—i ne traju izvan trenutne sesije.
Ako koristite Mac ili Linux računar, možete postaviti promenljivu okruženja u trenutnoj terminalskoj sesiji na sledeći način:
export MY_VARIABLE=my_value
Ako ste korisnik Windows-a, možete privremeno da podesite promenljivu okruženja ovako:
set MY_VARIABLE=my_value
Pristup promenljivim okruženja u Pythonu
Python pruža os modul za funkcionalnost vezanu za operativni sistem. A `os.environ` je rečnik promenljivih okruženja. Nazivi promenljivih okruženja i njihove vrednosti su ključevi i vrednosti rečnika, respektivno.
Dakle, možete pristupiti vrednostima promenljivih okruženja koristeći (njihova imena kao) ključeve – baš kao što biste pristupili elementima rečnika.
Evo nekoliko primera:
import os print(os.environ['HOME']) # Output: /home/balapriya
print(os.environ['USER']) # Output: balapriya
Za sada je sve u redu. Ali šta se dešava ako pokušate da pristupite vrednosti promenljive okruženja koja nikada nije bila podešena?
Hajde da pokušamo da pristupimo `API_KEY` koju još nismo podesili:
print(os.environ['API_KEY'])
Kao što se očekivalo, dobićete `KeyError`:
Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<frozen os>", line 679, in __getitem__ KeyError: 'API_KEY'
Rukovanje ključnim greškama
Možete rukovati `KeyError` kao što je prikazano:
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.')
Ovaj pristup ne zaustavlja naglo izvršavanje programa kada se pojavi izuzetak `KeyError`. Međutim, pruža opisnu poruku o grešci:
# Output API_KEY is not set. Please configure it.
Dakle, kada se ostatak programa ne izvrši kako je očekivano, znamo da smo propustili podešavanje potrebne promenljive okruženja.
Pristupanje promenljivim okruženja korišćenjem metode `get()`
Možete koristiti metodu rečnika `get()` da biste dobili vrednost promenljive okruženja. Umesto `KeyError`, metoda `get()` vraća `None` ako promenljiva nije pronađena.
Pristup promenljivoj `NOT_SET` koju nismo podesili vraća `None`:
print(os.environ.get('NOT_SET'))
# Output: None
Lično više volim podizanje greške `KeyError` kada promenljiva okruženja nije podešena, nego da se program nastavi tiho ili sa `None` koje vraća metoda `get()`.
Ali metoda `get()` je korisna kada želimo da postavimo podrazumevanu vrednost za određenu promenljivu okruženja ako ona nije podešena.
Evo primera:
print(os.environ.get('HOME','/home/user'))
# Output: /home/balapriya
Kako upravljati konfiguracijom sa promenljivim okruženja
Hajde da pogledamo nekoliko praktičnih primera u kojima koristimo promenljive okruženja u našoj aplikaciji.
Primer 1: Konfigurisanje parametara veze sa bazom podataka
Recimo da želite da se povežete na PostgreSQL bazu podataka iz Pythona. Da biste to uradili, možete da instalirate i koristite psycopg2 konektor:
pip install psycopg2
U ovom primeru, koristimo promenljive okruženja da konfigurišemo parametre veze sa bazom podataka. Ako promenljive okruženja nisu podešene, postavljamo podrazumevane vrednosti.
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}')
Primer 2: Upravljanje API ključevima
Hajde da uzmemo još jedan primer koji uključuje korišćenje API ključeva.
Pored ChatGPT interfejsa, možete koristiti i OpenAI API za podršku OpenAI LLM-ovima u vašim aplikacijama.
Kada se prijavite za OpenAI nalog, obično ćete dobiti neke besplatne API kredite sa vremenskim ograničenjem. Uzmite svoj API ključ tako što ćete otići na Settings > View API keys.
Možete da koristite OpenAI Python SDK i framework kao što je LangChain za izradu aplikacija. Da biste to uradili, potrebno je da instalirate biblioteke (u virtuelnom okruženju) koristeći pip:
pip install openai pip install langchain
Evo kako možete da podesite `OPENAI_API_KEY` kao promenljivu okruženja:
import os os.environ["OPENAI_API_KEY"]='your-api-key'
Sada možete da pristupite OpenAI LLM-u u vašoj skripti na sledeći način:
from langchain.llms import OpenAI model=OpenAI(model_name="gpt-3.5-turbo")
Kako izmeniti promenljive okruženja u Pythonu
Možete pristupiti `os.environ` rečniku iz os modula da biste izmenili promenljive okruženja u okviru trenutnog Python procesa:
import os # Modify an existing environment variable or create a new one os.environ['MY_VARIABLE'] = 'new_value'
U Pythonu možete koristiti subprocess modul za pokretanje podprocesa iz postojeće Python skripte, što je korisno kada želite da pokrenete sistemske programe u Pythonu.
U sledećem primeru, menjamo `PATH` promenljivu okruženja pristupom rečniku `os.environ`. Zatim pokrećemo `echo $PATH` kao podproces:
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}')
Vidimo da `PATH` uzima vrednost `/custom/path`:
# Output /custom/path
Opseg izmenjenih promenljivih okruženja
Važno je napomenuti da su ova ažuriranja promenljivih okruženja privremena i važe samo za trenutni Python proces. Kada se skripta završi, promene se odbacuju:
- Trenutni Python proces: Kada modifikujete promenljivu okruženja koristeći `os.environ` u vašoj Python skripti, promena je lokalna za trenutni Python proces. To neće uticati na druge pokrenute procese ili buduće Python sesije.
- Podređeni procesi: Promene promenljivih okruženja koje su napravljene unutar trenutnog Python procesa nasleđuju podređeni procesi koje je kreirala vaša skripta. Na primer, ako pokrenete podproces iz vaše Python skripte (roditeljski proces), podređeni proces će imati pristup izmenjenim promenljivim okruženja (kao što se vidi u primeru).
- Nije sistemski: Promenljive okruženja postavljene unutar Python skripte neće postojati izvan izvršavanja te skripte.
Ako treba da unesete trajne promene u promenljive okruženja na nivou sistema, obično to treba da uradite koristeći metode specifične za operativni sistem.
Kako učitati .env datoteke pomoću python-dotenv
python-dotenv biblioteka je popularan Python paket koji pojednostavljuje proces učitavanja promenljivih okruženja iz `.env` datoteke u vaš Python projekat. Posebno je korisna kada imate više okruženja (npr. razvoj, produkcija) sa različitim konfiguracijama i želite da ova podešavanja zadržite odvojeno od svog izvornog koda.
Instaliranje python-dotenv
Da biste koristili python-dotenv, prvo morate da ga instalirate. Možete ga instalirati – unutar virtuelnog okruženja – koristeći pip, Python menadžer paketa:
pip install python-dotenv
Učitavanje promenljivih okruženja iz .env datoteke
Sada možete kreirati `.env` datoteku u osnovnom direktorijumu vašeg projekta i popuniti je parovima ključ/vrednost, baš kao i obične promenljive okruženja. Hajde da napravimo sledeću `.env` datoteku sa vrednostima čuvara mesta:
API_KEY=your_api_key_here DB_PASSWORD=your_database_password_here
Sada možete učitati promenljive okruženja iz `.env` datoteke koristeći python-dotenv na sledeći način:
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}")
Primetićete da smo koristili `os.getenv(VARIABLE_NAME)` da bismo dobili vrednosti promenljivih okruženja. Ovo je takođe validan (i ređe korišćen) način pristupa promenljivim okruženja.
Evo izlaza:
API Key: your-api-key-here Database Password: your-database-url-here
U ovom primeru:
- Koristimo `load_dotenv()` za učitavanje promenljivih okruženja definisanih u `.env` datoteci u trenutno okruženje.
- Zatim koristimo `os.getenv()` za pristup promenljivim okruženja: `API_KEY` i `DB_PASSWORD`.
Zaključak
I to je to! Nadam se da ste naučili kako da upravljate konfiguracijom i osetljivim podacima koristeći promenljive okruženja u Python aplikacijama. Pokrili smo osnove podešavanja i pristupa promenljivim okruženja, kao i njihovu praktičnu upotrebu u konfigurisanju aplikacija.
Iako su promenljive okruženja svakako korisne u odvajanju konfiguracije od izvornog koda, trebalo bi da čuvate osetljive podatke kao tajne u slučajevima upotrebe u proizvodnji. Za upravljanje tajnama, preporučujem da istražite alate kao što su HashiCorp Vault ili AWS Secrets Manager.