Todo lo que necesitas saber sobre las variables de entorno de Python

Las variables de entorno son potentes mecanismos para almacenar detalles de configuración de tu proyecto de desarrollo de forma flexible y segura. Almacenan pares clave-valor de datos accesibles mediante lenguajes de programación como Python y mantienen esa información oculta de miradas indiscretas. En este tutorial, aprenderás conceptos y técnicas imprescindibles para crear y gestionar variables de entorno en Python.

¿Qué son las variables de entorno?

Las variables de entorno son pares nombre-valor almacenados en algún lugar seguro de tu sistema operativo. Lo más frecuente es que tengan este aspecto:

API_KEY=1akn4nka-aqwej3

En Python, puedes utilizar este tipo de variables para almacenar información sensible relacionada con tu proyecto de desarrollo. La información sensible puede ser:

• Claves API para acceder a las aplicaciones de otros
• Nombre de usuario y contraseñas para acceder a las aplicaciones mediante scripts
• Credenciales de la base de datos
• cualquier cosa que pudiera causar un problema de seguridad si se expusiera accidentalmente.

Por ejemplo, si escribes un script en Python que utiliza abiertamente tus credenciales de AWS y lo envías accidentalmente a GitHub, existe la posibilidad de que lo descubran personas malintencionadas y aumenten significativamente tu factura de AWS (se sabe que esto ocurre).

Otra ventaja de las variables de entorno es la configurabilidad. Puedes ajustar fácilmente la configuración (URL de bases de datos, rutas de archivos) modificando las variables de entorno sin cambiar tu código. Esta función es especialmente útil si utilizas la misma configuración en varias partes de tu proyecto.

Así que vamos a aprender a trabajar con ellos en Python.

Cómo recuperar variables de entorno en el módulo os de Python

Para recuperar las variables de entorno existentes en tu sistema, puedes utilizar el módulo os. Dispone de la función .getenv para recuperar variables:

import os
os.getenv("USER")

'bexgboost'

Arriba, estoy recuperando el nombre de usuario del sistema, que está incorporado en todos los sistemas. Hay muchos otros como el camino de casa:

os.getenv("HOME")

'/home/bexgboost'

O la ruta de tu ejecutable Conda:

os.getenv("CONDA_EXE")

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

Así, cuando ejecutas comandos de conda, así es como tu terminal sabe qué aplicación ejecutar.

Pero, ¿qué ocurre si intentas recuperar una variable que no existe?

os.getenv("MYDATABASE")

La función .getenv() no devuelve nada, pero podemos cambiar ese comportamiento. Puedes utilizar su parámetro default para devolver un valor personalizado si la variable no existe:

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

'Nope!'

La función .getenv() es el mejor método para recuperar variables existentes.

Sin embargo, en otras fuentes, puede que veas métodos diferentes, como el atributo .environ, que devuelve un diccionario con todas las variables de entorno:

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

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

Como se trata de un diccionario, puedes utilizar la notación entre paréntesis (no recomendada) o la función .get() para recuperar un valor.

os también tiene acceso a la que quizá sea la variable más importante del sistema, llamada PATH. PATH contiene las rutas absolutas a todos los ejecutables instalados en tu sistema, por lo que es bastante larga:

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

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

Cada ruta en PATH está separada por dos puntos. Vamos a contar la longitud de PATH en mi sistema:

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

   return len(items)

count_path_items()

79

79! No está mal.

Uso de la biblioteca python-dotenv para gestionar eficazmente las variables de entorno en Python

Establecer variables de entorno personalizadas

Ahora que sabemos cómo extraer variables existentes, veamos cómo establecer variables personalizadas. El primer método es utilizar el diccionario os.environ:

# Create a new environment variable
os.environ["NEW_VARIABLE"] = "42"  # Always expects a string value

os.getenv("NEW_VARIABLE")

'42'

Sin embargo, este método no es muy útil, ya que todas las nuevas variables se perderán cuando finalice la sesión actual.

Afortunadamente, existe un método más duradero de almacenar variables de entorno mediante el uso de archivos .env (pronunciado dot-env). Estos archivos tienen la misma sintaxis, lo que significa que funcionarán en cualquier sistema operativo. Éste es el aspecto de un archivo .env de ejemplo:

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

Por ahora, sólo define tres variables. Para leer este archivo y extraer su contenido, utilizaremos una biblioteca llamada python-dotenv:

$ pip install python-dotenv

Luego, en un script de Python o en un Jupyter Notebook importaremos su función load_dotenv y la llamaremos:

from dotenv import load_dotenv

load_dotenv()

True

Si no encuentra un archivo .env dentro del directorio actual, buscará en todos los directorios padre y devolverá True si lo encuentra.

Guardé el archivo .env anterior en mi directorio personal ~/.env; por eso load_dotenv pudo encontrarlo.

Para crear tus propios archivos, puedes utilizar el comando touch en el terminal o utilizar un editor de texto como VSCode:

$ touch ~/.env

La sintaxis de los archivos .env es bastante flexible. Por ejemplo, puedes establecer variables con valores de varias líneas (deben llevar comillas):

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

Utiliza caracteres de escape:

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

También puedes añadir comentarios al archivo para futuras consultas:

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

También es posible utilizar el valor de una variable dentro de otra utilizando la sintaxis ${VAR_NAME}:

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

Recuperar variables de entorno personalizadas con python-dotenv

Recuperar variables personalizadas es igual que antes: sólo tienes que utilizar el módulo os:

import os

os.getenv("CUSTOM_API_LINK")

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

os.getenv("SNOWFLAKE_USERNAME")

'bexgboost'

Asegúrate de llamar primero a load_dotenv.

Si tu archivo .env se encuentra en algún lugar inalcanzable para load_dotenv, puedes pasarle una ruta directa como la que se muestra a continuación:

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

True

Trabajar con archivos .env en Jupyter

Una vez que instales Python-dotenv, no tendrás que importarlo a Python si utilizas Jupyter. La biblioteca viene con un método mágico Jupyter que la carga automáticamente:

# Run this anywhere in the notebook to load EVs from .env
%load_ext dotenv
%dotenv

Entonces, podrás volver a utilizar el módulo os:

import os

os.getenv("SNOWFLAKE_USERNAME")

'bexgboost'

Buenas prácticas para utilizar variables de entorno en Python

En esta sección, enumeraremos algunas prácticas recomendadas para garantizar que las variables de entorno permanezcan seguras y plenamente utilizables.

1. Añade siempre los archivos de .env a .gitignore para no enviarlos accidentalmente a GitHub.

# Create .gitignore if it doesn't exist
$ touch .gitignore
$ echo ".env" >> .gitignore

2. Al definir variables, utiliza nombres descriptivos, todos en MAYÚSCULAS.

# Good
DEBUG=True
LOGGING_VERBOSITY=3

# Bad
debug=True
LV=3

3. Crea un único archivo .env para almacenar las variables de todo el sistema que necesites en cada proyecto.

$ touch ~/.env

4. Controla el alcance de tus archivos .env. Crea archivos separados para las distintas partes de tu flujo de trabajo de desarrollo, como se indica a continuación:

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

La función load_dotenv los reconocerá.

Si creas varios archivos .env con nombres diferentes, cambia tu archivo .gitignore para que todos ellos queden excluidos de la indexación de git:

# Pay attention to the asterisk *
$ echo ".env*" >> .gitignore

Conclusión

En este artículo, hemos aprendido todos los conceptos y técnicas esenciales para gestionar eficazmente las variables de entorno en Python. Descubrimos cómo recuperar variables existentes con el módulo Python OS y cómo crear valores personalizados con la biblioteca python-dotenv. También aprendimos a escribir archivos .env que se ajusten a las mejores prácticas.

Si quieres aprender más sobre ingeniería de software en Python, consulta nuestro curso Principios de ingeniería de software en Python.

También puedes consultar nuestro Curso de Habilidades de Programación en Python, que te llevará de principiante a Pythonista avanzado con ejercicios prácticos y proyectos.