Python környezeti változók, és hogyan kell dolgozni velük

Szerző:
Tweet
Share
Share
Pin

Szeretnéd jobban kezelni a konfigurációt? Ismerje meg, hogyan kell dolgozni a környezeti változókkal a Pythonban.

Amikor Pythonon tanítottam magam, projekteket építettem, hogy alkalmazzam a most tanultakat. Az adatbázishoz való csatlakozásban részt vevők részhalmaza, és Python használatával lekérdezik azt. Ez azt jelentette, hogy tárolnom kellett az adatbázis-konfigurációt és az olyan érzékeny információkat, mint a felhasználónév és a jelszó a hitelesítéshez.

Az ilyen érzékeny információk Python-szkriptben való kemény kódolása nem volt jó ötlet. Megtanultam a konfigurációs fájlok és környezeti változók használatát – a Python beépített moduljaival együtt.

Így amikor érzékeny információkat, például jelszavakat és API-kulcsokat kell használnom az alkalmazásaimban, környezeti változóként állítom be őket, és szükség szerint lekérem őket. Ebben az oktatóanyagban végigvezetem a környezeti változókon, és bemutatom, hogyan dolgozhat velük Pythonban.

Mik azok a környezeti változók?

A környezeti változók az alkalmazáson kívüli változók, amelyek konfigurációs információkat, rendszerbeállításokat és hasonlókat tárolnak. Ezeket általában az operációs rendszer vagy az alkalmazási környezet kezeli. A környezeti változók fő jellemzői a következők:

  • Név-érték párok: A környezeti változók egy névből (más néven kulcsból) és egy megfelelő értékből állnak.
  • Rendszer hatóköre: A környezeti változókat rendszerszinten állíthatja be, így elérhetővé téve azokat a rendszeren futó összes folyamat számára. Ha szükséges, ezeket az alkalmazás szintjén is módosíthatja vagy meghatározhatja, csak az adott alkalmazást érintve.
  • Dinamikus és változtatható: A környezeti változókat futás közben módosíthatja, így rugalmasságot biztosít.

Hogyan hasznosak a környezeti változók?

A környezeti változók számos előnyt kínálnak a Python-alkalmazások konfigurációjának és bizalmas információinak kezeléséhez:

  • Aggályok elkülönítése: Ha a konfigurációt a kódon kívül tárolja, akkor a konfigurációkezeléssel kapcsolatos aggályokat elkülönítve tartja az alkalmazás logikájától.
  • Biztonság: Kényes adatokat, például API-kulcsokat és adatbázis-hitelesítő adatokat tárolhat a környezeti változókban – anélkül, hogy azokat a forráskódban felfedné – ezzel csökkentve a kitettség kockázatát.
  • Rugalmasság: A környezeti változókkal a konfigurációs beállítások frissítése egyszerű, mivel a kódbázison kívül is frissíthet/módosíthat. A környezeti változók lehetővé teszik a konfigurációs beállítások módosítását a kód módosítása nélkül. Ez a rugalmasság különösen hasznos alkalmazások különböző környezetekben történő üzembe helyezésekor vagy a hitelesítő adatok frissítésekor.
  A hatékony képernyő- és videórögzítő eszköz

Az oktatóanyag következő szakaszaiban megvizsgáljuk, hogyan állíthatunk be, érhetünk el és kezelhetünk környezeti változókat a Pythonban, és hogyan javítják ezek a konfigurációkezelést a projektekben.

A környezeti változók beállítása

A környezeti változókat a parancssor segítségével állíthatja be. Az ilyen környezeti változók hatóköre csak az aktuális munkamenetre vonatkozik, és nem maradnak fenn az aktuális munkameneten kívül.

Ha Mac vagy Linux gépet használ, beállíthat egy környezeti változót az aktuális terminálmunkamenetben, például:

export MY_VARIABLE=my_value

Ha Ön Windows-felhasználó, ideiglenesen beállíthat egy környezeti változót az alábbi módon:

set MY_VARIABLE=my_value

Hozzáférés a környezeti változókhoz a Pythonban

A Python biztosítja a os modul operációs rendszerrel kapcsolatos funkciókhoz. Az os.environ pedig a környezeti változók szótára. A környezeti változók nevei és értékei a szótár kulcsai, illetve értékei.

Így a környezeti változók értékeit úgy érheti el – a nevüket használva, mint a kulcsokat –, ahogyan egy szótár elemeit is elérheti.

Íme néhány példa:

import os
print(os.environ['HOME'])
# Output: /home/balapriya
print(os.environ['USER'])
# Output: balapriya

Eddig jó. De mi történik, ha megpróbál hozzáférni egy olyan környezeti változó értékéhez, amely soha nem volt beállítva?

Próbáljuk meg elérni a még be nem állított API_KEY-t:

print(os.environ['API_KEY'])

Ahogy az várható volt, egy KeyError üzenetet fog kapni:

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

Kulcshibák kezelése

A KeyError-t az alábbi módon kezelheti:

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.')

Ez a megközelítés nem állítja le hirtelen a program végrehajtását, ha KeyError kivételt észlel. Ez azonban egy leíró hibaüzenetet ad:

# Output
API_KEY is not set. Please configure it.

Tehát amikor a program többi része nem a várt módon fut, akkor tudjuk, hogy nem állítottunk be egy szükséges környezeti változót.

Környezeti változók elérése a get() metódussal

A get() szótári metódus segítségével lekérheti egy környezeti változó értékét. KeyError helyett a get() metódus None-t ad vissza, ha a változó nem található.

Az általunk be nem állított NOT_SET változó elérése None értéket ad vissza:

print(os.environ.get('NOT_SET'))
# Output: None

Ha a környezeti változó nincs beállítva, akkor jobban szeretem a Key Error jelzést. Ezután hagyja csendben átmenni, vagy bekerüljön a None-ba, amelyet a get() metódus ad vissza.

  Hol lehet streamelni a HGTV-t, miután elvágta a kábelt

De a get() metódus akkor hasznos, ha egy adott környezeti változó alapértelmezett értéket adhatunk át, ha az nincs beállítva.

Íme egy példa:

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

A konfiguráció kezelése környezeti változókkal

Most vegyünk néhány gyakorlati példát, ahol környezeti változókat használunk az alkalmazásunkban.

1. példa: Adatbázis-kapcsolati paraméterek konfigurálása

Tegyük fel, hogy egy PostgreSQL adatbázishoz szeretne csatlakozni Pythonból. Ehhez telepítheti és használhatja a psycopg2 csatlakozót:

pip install psycopg2

Ebben a példában környezeti változókat használunk az adatbázis-kapcsolat paramétereinek konfigurálására. Ha a környezeti változók nincsenek beállítva, akkor alapértelmezett értékeket biztosítunk.

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}')

2. példa: API-kulcsok kezelése

Vegyünk egy másik példát, amely magában foglalja az API-kulcsok használatát.

A ChatGPT felületen kívül az OpenAI API-t is használhatja az OpenAI LLM-ek támogatására alkalmazásaiban.

Amikor regisztrál egy OpenAI-fiókra, (általában) néhány ingyenes, időben korlátozott API-jóváírást kap. Fogja meg API-kulcsát a Beállítások > API-kulcsok megtekintése menüpontban.

Alkalmazások készítéséhez használhatja az Open AI Python SDK-t és egy olyan keretrendszert, mint a LangChain. Ehhez telepítenie kell a könyvtárakat (virtuális környezetben) a pip segítségével:

pip install openai
pip install langchain

A következőképpen állíthatja be az OPENAI_API_KEY-t környezeti változóként:

import os
os.environ["OPENAI_API_KEY"]='your-api-key'

Mostantól elérheti az Open AI LLM-eket a szkriptjében, így:

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

A környezeti változók módosítása a Pythonban

Az os.environ szótárba koppintva az os modulból módosíthatja a környezeti változókat az aktuális Python folyamaton belül:

import os

# Modify an existing environment variable or create a new one
os.environ['MY_VARIABLE'] = 'new_value'

Pythonban használhatja a alfolyamat modul részfolyamatok létrehozásához a meglévő Python-szkriptből. Ez akkor hasznos, ha rendszerprogramokat szeretne futtatni Pythonban.

A következő példában az os.environ szótárba koppintva módosítjuk a PATH környezeti változót. Ezután az echo $PATH-t alfolyamatként futtatjuk:

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}')

Látjuk, hogy a PATH a /custom/path értékét veszi fel:

# Output
/custom/path

A módosított környezeti változók hatóköre

Fontos megjegyezni, hogy ezek a környezeti változók frissítései ideiglenesek, és csak az aktuális Python-folyamatra érvényesek. Amint a szkript leáll, a módosítások elvetődnek:

  • Jelenlegi Python-folyamat: Ha a Python-szkriptben az os.environ használatával módosít egy környezeti változót, a változás az aktuális Python-folyamat helyi értékét érinti. Nem lesz hatással a többi futó folyamatra vagy a jövőbeli Python-munkamenetekre.
  • Gyermekfolyamatok: Az aktuális Python-folyamatban végrehajtott környezeti változó-módosításokat a szkript által létrehozott gyermekfolyamatok öröklik. Ha például létrehoz egy alfolyamatot a Python-szkriptből (szülőfolyamat), akkor az utódfolyamat hozzáfér a módosított környezeti változókhoz (amint a példában is látható).
  • Nem rendszerszintű: A Python-szkriptben beállított környezeti változók nem maradnak fenn a szkript végrehajtásán kívül.
  Részletes betekintés a színelméletbe tervezők számára

Ha rendszerszinten állandó változtatásokat kell végrehajtania a környezeti változókon, akkor ezt általában operációs rendszer-specifikus módszerekkel kell megtennie.

.env fájlok betöltése a python-dotenv segítségével

A python-dotenv könyvtár egy népszerű Python-csomag, amely leegyszerűsíti a környezeti változók betöltését egy .env fájlból a Python-projektbe. Ez különösen akkor hasznos, ha több környezete (pl. fejlesztési, éles) különböző konfigurációkkal rendelkezik, és ezeket a beállításokat külön szeretné tartani a forráskódtól.

A python-dotenv telepítése

A python-dotenv használatához először telepítenie kell. Telepítheti – virtuális környezetben – a pip, a Python csomagkezelő segítségével:

pip install python-dotenv

Környezeti változók betöltése .env fájlból

Mostantól létrehozhat egy .env fájlt a projekt gyökérkönyvtárában, és feltöltheti kulcs-érték párokkal, akárcsak a szokásos környezeti változókat. Hozzuk létre a következő .env fájlt helyőrző értékekkel:

API_KEY=your_api_key_here
DB_PASSWORD=your_database_password_here

Most már betöltheti a környezeti változókat az .env fájlból a python-dotenv használatával, így:

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}")

Figyelje meg, hogy az os.getenv(VARIABLE_NAME) függvényt használtuk a környezeti változók értékeinek lekéréséhez. Ez is egy érvényes (és ritkábban használt) módja a környezeti változók elérésének.

Íme a kimenet:

API Key: your-api-key-here
Database Password: your-database-url-here

Ebben a példában:

  • A load_dotenv() segítségével töltjük be az .env fájlban meghatározott környezeti változókat az aktuális környezetbe.
  • Ezután az os.getenv() segítségével érjük el a következő környezeti változókat: API_KEY és DB_PASSWORD.

Következtetés

És ez egy pakolás! Remélem, megtanulta, hogyan kezelheti a konfigurációt és az érzékeny információkat a Python-alkalmazások környezeti változóival. Kitértünk a környezeti változók beállításának és elérésének alapjaira, valamint gyakorlati használatukra az alkalmazások konfigurálásakor.

Bár a környezeti változók minden bizonnyal hasznosak a konfiguráció és a forráskód elkülönítésében, az érzékeny változókat éles felhasználási esetekben titokként kell tárolnia. A titkok kezeléséhez olyan eszközöket ajánlok, mint pl HashiCorp Vault vagy AWS Secrets Manager.

Tweet
Share
Share
Pin