Variables d’environnement Python et comment travailler avec elles

par
Tweetez
Partagez
Enregistrer
Partagez
Partagez
0 Partages


Vous souhaitez mieux gérer votre configuration ? Apprenez à travailler avec des variables d’environnement en Python.

Quand j’apprenais Python moi-même, je construisais des projets pour appliquer ce que je venais d’apprendre. Un sous-ensemble de ceux impliqués dans la connexion à une base de données et l’interroger à l’aide de Python. Ce qui signifiait que je devais stocker la configuration de la base de données et les informations sensibles telles que le nom d’utilisateur et le mot de passe pour l’authentification.

Coder en dur des informations aussi sensibles dans un script Python n’était pas une bonne idée. Et j’ai appris à utiliser les fichiers de configuration et les variables d’environnement, ainsi que les modules intégrés de Python pour travailler avec eux.

Ainsi, chaque fois que j’ai besoin d’utiliser des informations sensibles telles que des mots de passe et des clés API dans mes applications, je les définis comme variables d’environnement et les récupère si nécessaire. Dans ce didacticiel, je vais vous expliquer les variables d’environnement et comment les utiliser en Python.

Que sont les variables d’environnement ?

Les variables d’environnement sont des variables externes à votre application qui stockent des informations de configuration, des paramètres système, etc. Ils sont généralement gérés par le système d’exploitation ou l’environnement applicatif. Les principales caractéristiques des variables d’environnement comprennent :

  • Paires nom-valeur : les variables d’environnement se composent d’un nom (également appelé clé) et d’une valeur correspondante.
  • Portée du système : vous pouvez définir des variables d’environnement au niveau du système, les rendant accessibles à tous les processus exécutés sur le système. Si nécessaire, vous pouvez également les modifier ou les définir au niveau de l’application, en affectant uniquement cette application spécifique.
  • Dynamique et mutable : vous pouvez modifier les variables d’environnement pendant l’exécution, offrant ainsi une flexibilité.

Comment les variables d’environnement sont utiles

Les variables d’environnement offrent plusieurs avantages pour la gestion de la configuration et des informations sensibles dans vos applications Python :

  • Séparation des préoccupations : en stockant la configuration en dehors de votre code, vous séparez les préoccupations de gestion de la configuration de la logique de votre application.
  • Sécurité : vous pouvez stocker des données sensibles, telles que des clés API et des informations d’identification de base de données, dans des variables d’environnement, sans les exposer dans le code source, réduisant ainsi le risque d’exposition.
  • Flexibilité : avec les variables d’environnement, la mise à jour des paramètres de configuration est simple, car vous pouvez mettre à jour/apporter des modifications en dehors de la base de code. Les variables d’environnement vous permettent d’ajuster les paramètres de configuration sans modifier votre code. Cette flexibilité est particulièrement utile pour déployer des applications dans différents environnements ou lors de la mise à jour des informations d’identification.

Dans les sections suivantes de ce didacticiel, nous explorerons comment définir, accéder et gérer les variables d’environnement en Python et comment elles améliorent la gestion de la configuration dans vos projets.

Comment définir les variables d’environnement

Vous pouvez définir des variables d’environnement à l’aide de la ligne de commande. La portée de ces variables d’environnement s’applique uniquement à la session en cours et elles ne persistent pas en dehors de la session en cours.

Si vous êtes sur une machine Mac ou Linux, vous pouvez définir une variable d’environnement dans votre session de terminal actuelle comme ceci :

export MY_VARIABLE=my_value

Si vous êtes un utilisateur Windows, vous pouvez définir temporairement une variable d’environnement comme indiqué :

set MY_VARIABLE=my_value

Accéder aux variables d’environnement en Python

Python fournit le module du système d’exploitation pour les fonctionnalités liées au système d’exploitation. Et os.environ est un dictionnaire de variables d’environnement. Les noms des variables d’environnement et leurs valeurs sont respectivement les clés et les valeurs du dictionnaire.

Vous pouvez ainsi accéder aux valeurs des variables d’environnement en utilisant (leurs noms comme) les clés, de la même manière que vous accéderiez aux éléments d’un dictionnaire.

Voici quelques exemples:

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

Jusqu’ici, tout va bien. Mais que se passe-t-il si vous essayez d’accéder à la valeur d’une variable d’environnement qui n’a jamais été définie ?

Essayons d’accéder à API_KEY que nous n’avons pas encore défini :

print(os.environ['API_KEY'])

Comme prévu, vous obtiendrez une KeyError :

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

Gestion des erreurs clés

Vous pouvez gérer KeyError comme indiqué :

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

Cette approche n’arrête pas brusquement l’exécution du programme lorsqu’une exception KeyError est levée. Il fournit cependant un message d’erreur descriptif :

# Output
API_KEY is not set. Please configure it.

Ainsi, lorsque le reste du programme ne s’exécute pas comme prévu, nous savons que nous avons manqué de définir une variable d’environnement requise.

Accès aux variables d’environnement à l’aide de la méthode get()

Vous pouvez utiliser la méthode du dictionnaire get() pour obtenir la valeur d’une variable d’environnement. Au lieu d’une KeyError, la méthode get() renvoie None si la variable n’est pas trouvée.

L’accès à la variable NOT_SET que nous n’avons pas définie renvoie None :

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

Je préfère déclencher une erreur de clé lorsque la variable d’environnement n’est pas définie. Ensuite, laissez-le passer silencieusement ou être englobé dans le None renvoyé par la méthode get().

Mais la méthode get() est utile lorsque nous pouvons transmettre une valeur par défaut pour une variable d’environnement particulière si elle n’est pas définie.

Voici un exemple :

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

Comment gérer la configuration avec des variables d’environnement

Prenons maintenant quelques exemples pratiques dans lesquels nous utilisons des variables d’environnement dans notre application.

Exemple 1 : configuration des paramètres de connexion à la base de données

Supposons que vous souhaitiez vous connecter à une base de données PostgreSQL depuis Python. Pour ce faire, vous pouvez installer et utiliser le connecteur psycopg2 :

pip install psycopg2

Dans cet exemple, nous utilisons des variables d’environnement pour configurer les paramètres de connexion à la base de données. Si les variables d’environnement ne sont pas définies, nous fournissons des valeurs par défaut à utiliser.

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

Exemple 2 : Gérer les clés API

Prenons un autre exemple impliquant l’utilisation de clés API.

En plus de l’interface ChatGPT, vous pouvez également utiliser l’API OpenAI pour prendre en charge les LLM OpenAI dans vos applications.

Lorsque vous vous inscrivez pour un compte OpenAI, vous recevez (généralement) des crédits API gratuits à durée limitée. Récupérez votre clé API en accédant à Paramètres > Afficher les clés API.

Vous pouvez utiliser le SDK Open AI Python et un framework comme LangChain pour créer des applications. Pour ce faire, vous devez installer les bibliothèques (dans un environnement virtuel) à l’aide de pip :

pip install openai
pip install langchain

Voici comment définir OPENAI_API_KEY comme variable d’environnement :

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

Vous pouvez maintenant accéder aux LLM Open AI dans votre script comme ceci :

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

Comment modifier les variables d’environnement en Python

Vous pouvez accéder au dictionnaire os.environ à partir du module os pour modifier les variables d’environnement dans le processus Python actuel :

import os

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

En Python, vous pouvez utiliser le module de sous-processus pour générer des sous-processus à partir d’un script Python existant. Ce qui est utile lorsque vous souhaitez exécuter des programmes système en Python.

Dans l’exemple suivant, nous modifions la variable d’environnement PATH en accédant au dictionnaire os.environ. Nous exécutons ensuite echo $PATH en tant que sous-processus :

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

On voit que le PATH prend la valeur de /custom/path :

# Output
/custom/path

Portée des variables d’environnement modifiées

Il est important de noter que ces mises à jour de variables d’environnement sont temporaires et ne sont valables que pour le processus Python actuel. Une fois le script terminé, les modifications sont ignorées :

  • Processus Python actuel : lorsque vous modifiez une variable d’environnement à l’aide de os.environ dans votre script Python, la modification est locale au processus Python actuel. Cela n’affectera pas les autres processus en cours d’exécution ni les futures sessions Python.
  • Processus enfants : les modifications apportées aux variables d’environnement dans le processus Python actuel sont héritées par les processus enfants créés par votre script. Par exemple, si vous générez un sous-processus à partir de votre script Python (processus parent), le processus enfant aura accès aux variables d’environnement modifiées (comme le montre l’exemple).
  • Pas à l’échelle du système : les variables d’environnement définies dans un script Python ne persisteront pas en dehors de l’exécution de ce script.

Si vous devez apporter des modifications persistantes aux variables d’environnement au niveau du système, vous devez généralement le faire à l’aide de méthodes spécifiques au système d’exploitation.

Comment charger des fichiers .env avec python-dotenv

Le bibliothèque python-dotenv est un package Python populaire qui simplifie le processus de chargement des variables d’environnement à partir d’un fichier .env dans votre projet Python. Cela est particulièrement utile lorsque vous disposez de plusieurs environnements (par exemple, développement, production) avec des configurations différentes et que vous souhaitez conserver ces paramètres séparés de votre code source.

Installation de python-dotenv

Pour utiliser python-dotenv, vous devez d’abord l’installer. Vous pouvez l’installer (dans un environnement virtuel) à l’aide de pip, le gestionnaire de packages Python :

pip install python-dotenv

Chargement de variables d’environnement à partir d’un fichier .env

Vous pouvez maintenant créer un fichier .env dans le répertoire racine de votre projet et le remplir avec des paires clé-valeur, tout comme les variables d’environnement classiques. Créons le fichier .env suivant avec des valeurs d’espace réservé :

API_KEY=your_api_key_here
DB_PASSWORD=your_database_password_here

Vous pouvez maintenant charger les variables d’environnement à partir du fichier .env en utilisant python-dotenv comme ceci :

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

Notez que nous avons utilisé os.getenv(VARIABLE_NAME) pour obtenir les valeurs des variables d’environnement. C’est également un moyen valide (et moins couramment utilisé) d’accéder aux variables d’environnement.

Voici le résultat :

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

Dans cet exemple :

  • Nous utilisons load_dotenv() pour charger les variables d’environnement définies dans le fichier .env dans l’environnement actuel.
  • Nous utilisons ensuite os.getenv() pour accéder aux variables d’environnement : API_KEY et DB_PASSWORD.

Conclusion

Et c’est fini ! J’espère que vous avez appris à gérer la configuration et les informations sensibles à l’aide de variables d’environnement dans les applications Python. Nous avons couvert les bases de la définition et de l’accès aux variables d’environnement, ainsi que leur utilisation pratique dans la configuration des applications.

Bien que les variables d’environnement soient certainement utiles pour séparer la configuration du code source, vous devez stocker les variables sensibles en tant que secrets dans les cas d’utilisation en production. Pour gérer les secrets, je recommande d’explorer des outils comme Coffre HashiCorp ou Gestionnaire de secrets AWS.