Python-omgevingsvariabelen: wat je moet weten

Omgevingsvariabelen zijn krachtige mechanismen om configuratiedetails van je ontwikkelproject flexibel en veilig op te slaan. Ze bevatten sleutel-waardekoppelingen die toegankelijk zijn voor programmeertalen zoals Python en houden die informatie verborgen voor nieuwsgierige blikken. In deze tutorial leer je onmisbare concepten en technieken om omgevingsvariabelen in Python te maken en te beheren.

Wat zijn omgevingsvariabelen?

Omgevingsvariabelen zijn naam-waardekoppelingen die ergens veilig in je besturingssysteem zijn opgeslagen. Meestal zien ze er zo uit:

API_KEY=1akn4nka-aqwej3

In Python kun je zulke variabelen gebruiken om gevoelige informatie op te slaan die bij je ontwikkelproject hoort. Gevoelige informatie kan zijn:

• API-sleutels om toegang te krijgen tot andermans applicaties
• Gebruikersnamen en wachtwoorden om via scripts in te loggen op applicaties
• Database-inloggegevens
• alles wat een beveiligingsprobleem kan veroorzaken als het per ongeluk wordt blootgesteld.

Als je bijvoorbeeld een Python-script schrijft dat je AWS-inloggegevens openlijk gebruikt en dat script per ongeluk naar GitHub commit, is er een kans dat kwaadwillenden het ontdekken en je AWS-rekening flink verhogen (dit gebeurt echt).

Een ander voordeel van omgevingsvariabelen is flexibiliteit in configuratie. Je kunt instellingen (database-URL’s, paden) eenvoudig aanpassen door omgevingsvariabelen te wijzigen zonder je code te veranderen. Dit is vooral handig als je dezelfde instelling in meerdere delen van je project gebruikt.

Laten we dus leren hoe je er in Python mee werkt.

Omgevingsvariabelen ophalen met Pythons os-module

Om bestaande omgevingsvariabelen op je systeem op te halen, kun je de os-module gebruiken. Die heeft de functie .getenv om variabelen op te halen:

import os
os.getenv("USER")

'bexgboost'

Hierboven haal ik de systeemgebruikersnaam op, die op alle systemen is ingebouwd. Er zijn er veel meer, zoals het pad naar je thuismap:

os.getenv("HOME")

'/home/bexgboost'

Of het pad naar je Conda-uitvoerbestand:

os.getenv("CONDA_EXE")

'/home/bexgboost/anaconda3/bin/conda'

Dus wanneer je conda-commando’s uitvoert, weet je terminal zo welk programma gestart moet worden.

Maar wat gebeurt er als je probeert een variabele op te halen die niet bestaat:

os.getenv("MYDATABASE")

De functie .getenv() geeft dan niets terug, maar dat gedrag kun je aanpassen. Je kunt de parameter default gebruiken om een eigen waarde te retourneren als een variabele niet bestaat:

os.getenv("COMPUTER_PASSWORD", default="Nope!")

'Nope!'

De functie .getenv() is de beste methode om bestaande variabelen op te halen.

In andere bronnen kom je echter ook andere methoden tegen, zoals het attribuut .environ, dat een woordenboek (dictionary) met alle omgevingsvariabelen teruggeeft:

current_directory = os.environ.get("PWD", None)
current_directory

'/home/bexgboost/articles/2024/4_april'

Omdat het een dictionary is, kun je haakjesnotatie gebruiken (niet aanbevolen) of de functie .get() om een waarde op te halen.

os heeft ook toegang tot misschien wel de belangrijkste systeemvariabele, genaamd PATH. PATH bevat de absolute paden naar alle uitvoerbare bestanden die op je systeem zijn geïnstalleerd, dus hij is behoorlijk lang:

os.getenv("PATH")[:46]

'/home/bexgboost/.local/bin:/home/bexgboost/bin'

Elke pad in PATH is gescheiden door een dubbele punt. Laten we de lengte van PATH op mijn systeem tellen:

def count_path_items():
   items = os.getenv("PATH").split(":")

   return len(items)

count_path_items()

79

79! Niet slecht.

De library python-dotenv gebruiken om omgevingsvariabelen in Python effectief te beheren

Aangepaste omgevingsvariabelen instellen

Nu we weten hoe we bestaande variabelen kunnen uitlezen, kijken we hoe we eigen variabelen instellen. De eerste methode is het gebruik van de dictionary os.environ:

# Maak een nieuwe omgevingsvariabele aan
os.environ["NEW_VARIABLE"] = "42"  # Verwacht altijd een stringwaarde

os.getenv("NEW_VARIABLE")

'42'

Deze methode is echter niet erg handig, omdat alle nieuwe variabelen verloren gaan zodra de huidige sessie eindigt.

Gelukkig is er een duurzamere manier om omgevingsvariabelen op te slaan met behulp van .env-bestanden (uitgesproken als dot-env). Deze bestanden hebben overal dezelfde syntaxis, wat betekent dat ze op elk besturingssysteem werken. Zo ziet een voorbeeld van een .env-bestand eruit:

CUSTOM_API_LINK=https://myapi.com/v1/api
SNOWFLAKE_USERNAME=bexgboost
MYSQL_DATABASE_PASSWORD=as3ndf03

Voor nu definieert het slechts drie variabelen. Om dit bestand te lezen en de inhoud eruit te halen, gebruiken we een library genaamd python-dotenv:

$ pip install python-dotenv

Vervolgens importeren we in een Python-script of een Jupyter Notebook de functie load_dotenv en roepen die aan:

from dotenv import load_dotenv

load_dotenv()

True

Als het geen .env-bestand in de huidige map kan vinden, doorzoekt het alle bovenliggende mappen en geeft True terug als het bestand is gevonden.

Ik heb het bovenstaande .env-bestand in mijn thuismap opgeslagen ~/.env; daarom kon load_dotenv het vinden.

Om je eigen bestanden te maken, kun je het commando touch in de terminal gebruiken of een teksteditor zoals VSCode:

$ touch ~/.env

De syntaxis van .env-bestanden is vrij flexibel. Je kunt bijvoorbeeld variabelen instellen met waarden over meerdere regels (moeten tussen aanhalingstekens staan):

LONG_ENV="This is an environment
variable with a long message"

Gebruik escape-tekens:

LONG_ENV="This value uses an \"escape character"

Je kunt ook commentaar aan het bestand toevoegen voor later naslagwerk:

# You can also add comments anywhere with a hashtag
CUSTOM_API_LINK=https://myapi.com/v1/api
SNOWFLAKE_USERNAME=bexgboost
MYSQL_DATABASE_PASSWORD=as3ndf03

Het is ook mogelijk om de waarde van de ene variabele in een andere te gebruiken met de syntaxis ${VAR_NAME}:

FIRST_NAME=John
LAST_NAME=Doe
FULL_NAME="I am ${FIRST_NAME} ${LAST_NAME}"

Aangepaste omgevingsvariabelen ophalen met python-dotenv

Aangepaste variabelen ophalen gaat hetzelfde als eerder: gebruik gewoon de os-module:

import os

os.getenv("CUSTOM_API_LINK")

'https://myapi.com/v1/api'

os.getenv("SNOWFLAKE_USERNAME")

'bexgboost'

Zorg ervoor dat je eerst load_dotenv aanroept.

Als je .env-bestand ergens staat waar load_dotenv het niet kan bereiken, kun je er een direct pad naartoe aan doorgeven, zoals hieronder:

load_dotenv("/home/bexgboost/somewhere/unreachable/.env")

True

Werken met .env-bestanden in Jupyter

Zodra je Python-dotenv hebt geïnstalleerd, hoef je het niet in Python te importeren als je Jupyter gebruikt. De library wordt geleverd met een Jupyter-magic die het automatisch laadt:

# Voer dit overal in de notebook uit om EV's uit .env te laden
%load_ext dotenv
%dotenv

Daarna kun je opnieuw de os-module gebruiken:

import os

os.getenv("SNOWFLAKE_USERNAME")

'bexgboost'

Best practices voor het gebruik van omgevingsvariabelen in Python

In deze sectie zetten we een paar best practices op een rij om ervoor te zorgen dat omgevingsvariabelen veilig en volledig bruikbaar blijven.

1. Voeg .env-bestanden altijd toe aan .gitignore, zodat je ze niet per ongeluk naar GitHub commit.

# Maak .gitignore aan als het niet bestaat
$ touch .gitignore
$ echo ".env" >> .gitignore

2. Gebruik bij het definiëren van variabelen beschrijvende namen in HOOFDLETTERS.

# Goed
DEBUG=True
LOGGING_VERBOSITY=3

# Slecht
debug=True
LV=3

3. Maak één enkel .env-bestand om systeemwijd variabelen op te slaan die je in elk project nodig hebt.

$ touch ~/.env

4. Beheer de scope van je .env-bestanden. Maak aparte bestanden voor verschillende delen van je ontwikkelworkflow, zoals hieronder:

$ touch development/.env.development
$ touch testing/.env.testing
$ touch production/.env.production

De functie load_dotenv herkent ze.

Als je meerdere .env-bestanden met verschillende namen maakt, pas je .gitignore-bestand dan aan zodat ze allemaal worden uitgesloten van git-indexering:

# Let op de asterisk *
$ echo ".env*" >> .gitignore

Conclusie

In dit artikel hebben we alle essentiële concepten en technieken geleerd om omgevingsvariabelen in Python effectief te beheren. We hebben gezien hoe je bestaande variabelen ophaalt met de Python OS-module en hoe je aangepaste waarden maakt met de library python-dotenv. We hebben ook geleerd hoe je .env-bestanden schrijft die voldoen aan best practices.

Wil je meer leren over software-engineering met Python? Bekijk dan onze cursus Software Engineering Principles in Python.

Je kunt ook onze Python Programming Skill Track bekijken, die je met praktijkoefeningen en projecten van beginner naar gevorderde Pythonista brengt.