Las variables de entorno permiten configurar aplicaciones sin necesidad de cambiar el código. Separan los datos externos de la lógica de la aplicación, lo cual puede resultar bastante misterioso para los desarrolladores novatos (incluso para algunos experimentados).
A través de esta guía práctica, levantaremos el velo alrededor de las variables de entorno para que puedas entender qué implican, por qué son importantes y cómo aprovecharlas con confianza.
Trae tu bebida favorita (y tal vez algunas galletas) porque estamos a punto de sumergirnos en ello. Vamos a desentrañar los conceptos de variables de entorno desde cero.
¿Qué Son las Variables de Entorno?
Las variables de entorno son valores nombrados dinámicos que pueden afectar cómo se comportan los procesos en ejecución en una computadora. Algunas propiedades clave de las variables de entorno son:
- Nombradas: Tienen nombres descriptivos como APP_MODE y DB_URL.
- Externas: Los valores se establecen fuera del código de la aplicación a través de archivos, líneas de comandos y sistemas.
- Dinámicas: Pueden actualizar variables sin reiniciar aplicaciones.
- Configuradas: El código depende de variables, pero no las define.
- Desacopladas: No es necesario modificar las configuraciones de código una vez que se establecen las variables.
Aquí tienes una analogía. Imagina que estás siguiendo una receta de galletas con chispas de chocolate. La receta podría decir:
- Agregar 1 taza de azúcar
- Agregar 1 barra de mantequilla ablandada
- Agregar 2 huevos
En lugar de esos valores codificados directamente, podrías usar variables de entorno en su lugar:
- Agregar $AZÚCAR taza de azúcar
- Agregar $MANTEQUILLA barras de mantequilla ablandada
- Agregar $HUEVOS huevos
Antes de hacer las galletas, configurarías esos nombres de variables de entorno con valores de tu elección:
| AZUCAR=1 MANTEQUILLA=1 HUEVOS=2 |
Entonces, al seguir la receta, tus ingredientes se resolverían como:
- Agregar 1 taza de azúcar
- Agregar 1 barra de mantequilla ablandada
- Agregar 2 huevos
Esto te permite configurar la receta de galletas sin cambiar el código de la receta.
El mismo concepto se aplica a la informática y al desarrollo. Las variables de entorno te permiten alterar el entorno en el que se ejecuta un proceso sin cambiar el código subyacente. Aquí tienes algunos ejemplos comunes:
- Establecer el entorno como “desarrollo” o “producción”
- Configurar claves de API para servicios externos
- Pasar claves secretas o credenciales
- Activar o desactivar ciertas características
Las variables de entorno proporcionan una gran flexibilidad. Puedes implementar el mismo código en múltiples entornos sin cambiar el código en sí mismo. Pero vamos a entender más a fondo por qué son valiosas.
¿Por Qué Son Valiosas las Variables de Entorno?
Considera las variables de entorno como perillas de aplicación utilizadas para ajustar preferencias. Exploraremos excelentes casos de uso en breve.
¡Solidifiquemos la intuición sobre por qué las variables de entorno son importantes!
Razón #1: Separan el Código de la Aplicación de las Configuraciones
Codificar directamente configuraciones y credenciales en tu código puede causar todo tipo de problemas:
- Commit accidental al control de origen
- Reconstrucción y redespliegue de código solo para cambiar un valor
- Problemas de configuración al promover a través de entornos
También conduce a un código desordenado:
| import os # Hard-coded configuration DB_USER = ‘appuser’ DB_PASS = ‘password123’ DB_HOST = ‘localhost’ DB_NAME = ‘myappdb’ def connect_to_db(): print(f”Connecting to {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}”) connect_to_db() |
Esto enreda la lógica del negocio con detalles de configuración. El acoplamiento estrecho hace que el mantenimiento sea arduo con el tiempo:
- Los cambios requieren modificar el código fuente
- Riesgo de filtrar secretos en el control de origen
El uso de variables de entorno reduce estos problemas. Por ejemplo, puedes configurar las variables de entorno DB_USER y DB_NAME.
| # .env file DB_USER=appuser DB_PASS=password123 DB_HOST=localhost DB_NAME=myappdb |
El código de la aplicación puede acceder a las variables de entorno cuando sea necesario, manteniendo el código limpio y simple.
| import os # Load config from environment DB_USER = os.environ[‘DB_USER’] DB_PASS = os.environ[‘DB_PASS’] DB_HOST = os.environ[‘DB_HOST’] DB_NAME = os.environ[‘DB_NAME’] def connect_to_db(): print(f”Connecting to {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}”) connect_to_db() |
Las variables de entorno separan de manera limpia la configuración del código, manteniendo los valores sensibles abstractos en el entorno.
Puedes implementar el mismo código desde desarrollo hasta producción sin cambiar nada. Las variables de entorno pueden diferir entre entornos sin afectar en absoluto al código.
Razón #2: Simplifican la Configuración de las Aplicaciones
Las variables de entorno simplifican el ajuste de las configuraciones sin necesidad de modificar el código:
| # .env file: DEBUG=true |
Así es como podríamos usarlo dentro del archivo de script:
| # Script content: import os DEBUG = os.environ.get(‘DEBUG’) == ‘true’ if DEBUG: print(“In DEBUG mode”) |
Cambiar el modo de depuración solo requiere actualizar el archivo .env, sin necesidad de cambiar el código, reconstruir o implementar de nuevo. Las variables de entorno también ayudan a implementar de manera fluida a través de los entornos:
| import os # Retrieve environment variable to determine the current environment (production or staging) current_env = os.getenv(‘APP_ENV’, ‘staging’) # Default to ‘staging’ if not set # Production API key PROD_API_KEY = os.environ[‘PROD_API_KEY’] # Staging API key STG_API_KEY = os.environ[‘STG_API_KEY’] # Logic that sets api_key based on the current environment if current_env == ‘production’: api_key = PROD_API_KEY else: api_key = STG_API_KEY # Initialize API client with the appropriate API key api = ApiClient(api_key) |
El mismo código puede usar claves API separadas para producción versus preparación sin realizar cambios.
Y por último, permiten alternar funcionalidades sin nuevas implementaciones:
| NEW_FEATURE = os.environ[‘NEW_FEATURE’] == ‘true’ if NEW_FEATURE: enableNewFeature() |
Cambiar la variable NEW_FEATURE activa la funcionalidad instantáneamente dentro de nuestro código. La interfaz para actualizar configuraciones depende de los sistemas:
- Las plataformas en la nube como Heroku utilizan paneles web
- Los servidores utilizan herramientas de comando del sistema operativo
- El desarrollo local puede utilizar archivos .env
Las variables de entorno son beneficiosas al crear aplicaciones, permitiendo a los usuarios configurar elementos según sus requisitos.
Razón #3: Ayudan a Gestionar Secretos y Credenciales
Incluir secretos como claves API, contraseñas y claves privadas directamente en el código fuente plantea riesgos de seguridad sustanciales:
| # Avoid exposing secrets in code! STRIPE_KEY = ‘sk_live_1234abc’ DB_PASSWORD = ‘password123’ stripe.api_key = STRIPE_KEY db.connect(DB_PASSWORD) |
¡Esos credenciales ahora están expuestos si este código se compromete en un repositorio público de GitHub!
Las variables de entorno evitan la fuga al externalizar los secretos:
| import os STRIPE_KEY = os.environ.get(‘STRIPE_KEY’) DB_PASS = os.environ.get(‘DB_PASS’) stripe.api_key = STRIPE_KEY db.connect(DB_PASS) |
Los valores de los secretos reales se establecen en un archivo .env local.
| # .env file STRIPE_KEY=sk_live_1234abc DB_PASS=password123 |
No olvides agregar al archivo .gitignore el archivo .env para mantener los secretos fuera del control de origen. Esto implica definir el archivo .env en un archivo .gitignore en cualquier directorio raíz del repositorio, lo que le indica a git que ignore el archivo durante la creación de confirmaciones.
Esto separa las definiciones de secretos del código de la aplicación, cargándolos de manera segura desde entornos protegidos durante el tiempo de ejecución. El riesgo de exponer accidentalmente credenciales se reduce drásticamente.
Razón #4: Promueven la Consistencia
Imagina tener diferentes archivos de configuración para los entornos de desarrollo, QA y producción:
| # Development DB_HOST = ‘localhost’ DB_NAME = ‘appdb_dev’ # Production DB_HOST = ‘db.myapp.com’ DB_NAME = ‘appdb_prod’ |
Esta discrepancia introduce errores sutiles que son difíciles de detectar. El código que funciona perfectamente en desarrollo podría romperse repentinamente en producción debido a configuraciones desiguales.
Las variables de entorno resuelven esto al centralizar la configuración en un solo lugar:
| DB_HOST=db.myapp.comDB_NAME=appdb_prod |
Ahora, las mismas variables se utilizan de manera consistente en todos los entornos. Ya no tienes que preocuparte por configuraciones aleatorias o incorrectas que se activen.
El código de la aplicación simplemente hace referencia a las variables:
| import os db_host = os.environ[‘DB_HOST’] db_name = os.environ[‘DB_NAME’] db.connect(db_host, db_name) |
Ya sea que la aplicación se ejecute localmente o en un servidor de producción, siempre utiliza el host y el nombre de la base de datos correctos.
Esta uniformidad reduce los errores, mejora la previsibilidad y hace que la aplicación sea más robusta en general. Los desarrolladores pueden tener la confianza de que el código se comportará de manera idéntica en cada entorno.
Cómo Puedes Definir Variables de Entorno
Las variables de entorno pueden definirse en varios lugares, lo que permite flexibilidad para establecerlas y acceder a ellas en todos los procesos y sistemas.
1. Variables de Entorno del Sistema Operativo
La mayoría de los sistemas operativos proporcionan mecanismos integrados para definir variables globales. Esto hace que las variables sean accesibles en todo el sistema para todos los usuarios, aplicaciones, etc.
En sistemas Linux/Unix, las variables pueden definirse en scripts de inicio de shell.
Por ejemplo, ~/.bashrc se puede utilizar para establecer variables a nivel de usuario, mientras que /etc/environment es para variables a nivel de sistema que todos los usuarios pueden acceder.
Las variables también pueden establecerse en línea antes de ejecutar comandos utilizando el comando export o directamente a través del comando env en bash:
| # In ~/.bashrc export DB_URL=localhost export APP_PORT=3000 |
| # In /etc/environment DB_HOST=localhost DB_NAME=mydatabase |
Las variables también pueden establecerse en línea antes de ejecutar comandos:
| export TOKEN=abcdef python app.py |
Definir variables a nivel del sistema operativo las hace globalmente disponibles, lo cual es bastante útil cuando quieres ejecutar la aplicación sin depender de valores internos.
También puedes hacer referencia a las variables definidas en scripts o argumentos de línea de comandos.
| python app.py –db-name $DB_NAME –db-host $DB_HOST –batch-size $BATCH_SIZE |
2. Definición de Variables de Entorno en el Código de la Aplicación
Además de las variables a nivel del sistema operativo, las variables de entorno pueden definirse y accederse directamente dentro del código de la aplicación mientras se ejecuta.
El diccionario os.environ en Python contiene todas las variables de entorno actualmente definidas. Podemos establecer nuevas simplemente agregando pares de clave-valor:
Las variables de entorno también pueden definirse y accederse directamente dentro del código de la aplicación. En Python, el diccionario os.environ contiene todas las variables de entorno definidas:
| import os os.environ[“API_KEY”] = “123456” api_key = os.environ.get(“API_KEY”) |
Entonces, el diccionario os.environ permite establecer y obtener dinámicamente variables de entorno desde el código Python.
La mayoría de los lenguajes vienen con sus bibliotecas, ofreciendo acceso a las variables de entorno durante la ejecución.
También puedes usar frameworks como Express, Django y Laravel para tener integraciones más profundas, como la carga automática de archivos .env que contienen variables de entorno.
3. Creación de Archivos de Configuración Local para Variables de Entorno
Además de las variables a nivel del sistema, las variables de entorno pueden cargarse desde archivos de configuración locales de una aplicación. Esto mantiene los detalles de configuración separados del código, incluso para el desarrollo y prueba locales.
Algunos enfoques populares:
Archivos .env
El formato de archivo .env, popularizado por Node.js, proporciona una forma conveniente de especificar variables de entorno en un formato clave-valor:
| # .env DB_URL=localhost API_KEY=123456 |
Frameworks web como Django y Laravel cargan automáticamente variables definidas en archivos .env en el entorno de la aplicación. Para otros lenguajes como Python, bibliotecas como python-dotenv se encargan de importar archivos .env:
| from dotenv import load_dotenv load_dotenv() # Loads .env variables print(os.environ[‘DB_URL’]) # localhost |
El beneficio de usar archivos .env es que mantienen la configuración limpia y separada sin hacer cambios en el código.
Archivos de Configuración JSON
Para necesidades de configuración más complejas que involucren múltiples variables de entorno, usar archivos JSON o YAML ayuda a organizar las variables juntas:
| // config.json { “api_url”: “https://api.example.com”, “api_key”: “123456”, “port”: 3000 } |
El código de la aplicación puede cargar rápidamente estos datos JSON como un diccionario para acceder a las variables configuradas:
| import json config = json.load(‘config.json’) api_url = config[‘api_url’] api_key = config[‘api_key’] port = config[‘port’] # 3000 |
Esto evita archivos .env desordenados cuando se trata con múltiples configuraciones de aplicaciones.
¿Cómo Acceder a las Variables de Entorno en Diferentes Lenguajes de Programación?
Sin importar cómo elijamos definir las variables de entorno, nuestras aplicaciones necesitan una forma consistente de buscar valores durante la ejecución.
Si bien existen varias formas de definir variables de entorno, el código de la aplicación necesita una manera estándar de acceder a ellas durante la ejecución, independientemente del lenguaje. Aquí hay una descripción general de las técnicas para acceder a las variables de entorno en diferentes lenguajes de programación populares:
Python
Python proporciona el diccionario os.environ para acceder a las variables de entorno definidas:
| import os db = os.environ.get(‘DB_NAME’) print(db) |
Podemos obtener una variable usando os.environ.get(), que devuelve None si no está definida. O acceder directamente a través de os.environ(), lo que generará un KeyError si no está presente.
Métodos adicionales como os.getenv() y os.environ.get() permiten especificar valores predeterminados si no están definidos.
JavaScript (Node.js)
En el código JavaScript de Node.js, las variables de entorno están disponibles en el objeto global process.env:
| // Get env var const db = process.env.DB_NAME; console.log(db); |
Si no está definido, process.env contendrá undefined. También podemos proporcionar valores predeterminados como:
| const db = process.env.DB_NAME || ‘defaultdb’; |
Ruby
Las aplicaciones Ruby acceden a las variables de entorno a través del hash ENV:
| # Access variable db = ENV[‘DB_NAME’] puts db |
También podemos pasar un valor predeterminado si la clave deseada no existe:
| db = ENV.fetch(‘DB_NAME’, ‘defaultdb’) |
PHP
PHP proporciona métodos globales getenv(), $_ENV y $_SERVER para acceder a las variables de entorno:
| // Get env var $db_name = getenv(‘DB_NAME’); // Or access $_ENV or $_SERVER arrays $db_name = $_ENV[‘DB_NAME’]; |
Dependiendo de la fuente de la variable, pueden estar disponibles en diferentes globales.
Java
En Java, el método System.getenv() devuelve variables de entorno que se pueden acceder:
| String dbName = System.getenv(“DB_NAME”); |
Esto permite el acceso a variables definidas a nivel del sistema de forma global en Java.
Por ahora, algunas mejores prácticas en torno a la higiene de las variables de entorno.
Guía de Seguridad de las Variables de Entorno
Cuando se trata de gestionar las variables de entorno de forma segura, debemos tener en cuenta varias mejores prácticas.
Nunca Almacenes Información Sensible en el Código
Primero y más importante, nunca almacenes información sensible como contraseñas, claves de API o tokens directamente en tu código.
Puede ser tentador simplemente codificar una contraseña de base de datos o una clave de cifrado en tu código fuente para un acceso rápido, ¡pero resiste esa tentación!
Si accidentalmente confirmas ese código en un repositorio público en GitHub, básicamente estás difundiendo tus secretos al mundo entero. Imagina si un hacker obtuviera tus credenciales de base de datos de producción solo porque estaban en texto plano en tu base de código. Pensamiento aterrador, ¿verdad?
En su lugar, siempre utiliza variables de entorno para almacenar cualquier tipo de configuración sensible. Mantén tus secretos en un lugar seguro como un archivo .env o una herramienta de gestión de secretos, y haz referencia a ellos en tu código mediante variables de entorno. Por ejemplo, en lugar de hacer algo como esto en tu código Python:
| db_password = “supers3cr3tpassw0rd” |
Almacenarías esa contraseña en una variable de entorno de esta manera:
| # .env file DB_PASSWORD=supers3cr3tpassw0rd |
Y luego accederías a ella en tu código así:
| import os db_password = os.environ.get(‘DB_PASSWORD’) |
De esta manera, tus secretos aún están seguros, incluso si tu código fuente se ve comprometido. Las variables de entorno actúan como una capa de abstracción segura.
Usa Variables Específicas del Entorno
Otra práctica es usar diferentes variables de entorno para cada entorno de la aplicación, como desarrollo, preproducción y producción.
No querrás conectarte accidentalmente a tu base de datos de producción mientras desarrollas localmente solo porque olvidaste actualizar una variable de configuración. Nomina tus variables de entorno para cada entorno:
| # Dev DEV_API_KEY=abc123 DEV_DB_URL=localhost # Production PROD_API_KEY=xyz789 PROD_DB_URL=proddb.amazonaws.com |
Luego, haz referencia a las variables apropiadas en tu código dependiendo del entorno actual. Muchos frameworks como Rails proporcionan archivos de configuración específicos del entorno para este propósito.
Mantén los Secretos Fuera del Control de Versiones
También es crucial mantener tus archivos .env y de configuración que contienen secretos fuera del control de versiones. Agrega .env a tu archivo .gitignore para no comprometerlo accidentalmente en tu repositorio.
Puedes usar git-secrets para escanear información sensible antes de cada commit. Para mayor seguridad, cifra tu archivo de secretos antes de almacenarlo. Herramientas como Ansible Vault y BlackBox pueden ayudar con esto.
Asegura los Secrets en los Servidores de Producción
Cuando administres variables de entorno en tus servidores de producción, evita establecerlas utilizando argumentos de línea de comandos, que pueden ser inspeccionados a través de la tabla de procesos.
En su lugar, usa las herramientas de gestión de entorno de tu sistema operativo o plataforma de orquestación de contenedores. Por ejemplo, puedes usar Kubernetes Secrets para almacenar y exponer secretos de forma segura a tus pods de aplicación.
Utiliza Algoritmos de Encriptación Fuertes
Utiliza algoritmos de encriptación robustos y modernos al encriptar tus secretos, ya sea en tránsito o en reposo. Evita algoritmos obsoletos como DES o MD5, que tienen vulnerabilidades conocidas. En su lugar, opta por algoritmos estándar de la industria como AES-256 para encriptación simétrica y RSA-2048 o ECDSA para encriptación asimétrica.
Rota los Secrets Regularmente
Rota tus secretos regularmente, especialmente si sospechas que pueden haber sido comprometidos. Trata los secretos como lo harías con una contraseña, actualizándolos cada pocos meses. Una herramienta de gestión de secretos como Hashicorp Vault o AWS Secrets Manager puede ayudar a automatizar este proceso.
Ten Cuidado con el Registro y la Información de Errores
Ten cuidado con el registro y la información de errores. Asegúrate de no registrar ninguna variable de entorno que contenga valores sensibles. Si estás utilizando una herramienta de seguimiento de errores de terceros, configúrala para sanitizar datos sensibles. ¡Lo último que quieres es que tus secretos aparezcan en un seguimiento de stack en un panel de informes de excepciones!
¿Cuándo Evitar las Variables de Entorno?
Hay varios casos en los que se deben evitar las variables de entorno:
Gestión de Configuraciones Complejas
El uso de variables de entorno para gestionar la configuración de sistemas de software complejos puede volverse desordenado y propenso a errores. A medida que aumenta el número de parámetros de configuración, terminas con nombres de variables de entorno largos que pueden chocar accidentalmente. Además, no hay una forma fácil de organizar valores de configuración relacionados juntos.
En lugar de variables de entorno, considera usar archivos de configuración en un formato como JSON o YAML. Estos te permiten:
- Agrupar parámetros de configuración relacionados juntos en una estructura anidada.
- Evitar colisiones de nombres encapsulando la configuración en ámbitos y espacios de nombres.
- Definir tipos de datos personalizados en lugar de solo cadenas.
- Ver y modificar rápidamente las configuraciones utilizando un editor de texto.
Almacenamiento de Información Sensible
Si bien las variables de entorno parecen fáciles de inyectar configuraciones externas como claves de API, contraseñas de bases de datos, etc., esto puede causar problemas de seguridad.
El problema es que las variables de entorno son accesibles globalmente en un proceso. Entonces, si existe una vulnerabilidad en parte de tu aplicación, podría comprometer los secretos almacenados en las variables de entorno.
Un enfoque más seguro es utilizar un servicio de gestión de secretos que maneje el cifrado y el control de acceso. Estos servicios permiten almacenar datos sensibles externamente y proporcionan SDK para recuperar valores de aplicación.
Por lo tanto, considera usar una solución de gestión de secretos dedicada en lugar de variables de entorno para credenciales y claves privadas. Esto reduce el riesgo de exponer accidentalmente datos sensibles a través de vulnerabilidades o registros no deseados.
Trabajar Con Múltiples Entornos
La gestión de variables de entorno puede volverse tediosa a medida que las aplicaciones crecen y se implementan en múltiples entornos (desarrollo, pruebas, pruebas, producción). Puede que tengas datos de configuración fragmentados repartidos en varios scripts de bash, herramientas de implementación, etc.
Una solución de gestión de configuración ayuda a consolidar todas las configuraciones específicas del entorno en un lugar centralizado. Esto podría ser archivos en un repositorio, un servidor de configuración dedicado o integrado con tus pipelines de CI/CD.
Si el objetivo es evitar la duplicación de variables de entorno, tiene más sentido tener una única fuente de verdad para las configuraciones.
Compartir Configuraciones Entre Equipos
Dado que las variables de entorno se originan localmente por proceso, compartir y sincronizar datos de configuración entre diferentes equipos que trabajan en la misma aplicación o conjunto de servicios se vuelve muy difícil.
Cada equipo puede mantener su propia copia de los valores de configuración en diferentes scripts de bash, manifiestos de implementación, etc. Esta configuración descentralizada conduce a lo siguiente:
- Deriva de configuración: Sin una única fuente de verdad, es fácil que la configuración sea inconsistente en los entornos a medida que diferentes equipos realizan cambios independientes.
- Falta de visibilidad: No hay una forma centralizada de ver, buscar y analizar todo el estado de configuración en todos los servicios. Esto hace extremadamente difícil entender cómo está configurado un servicio.
- Desafíos de auditoría: Los cambios en las variables de entorno no se rastrean de ninguna manera estándar, lo que dificulta auditar quién cambió qué configuración y cuándo.
- Dificultades de prueba: Sin una forma fácil de capturar y compartir la configuración, asegurar entornos consistentes para desarrollo y pruebas se vuelve extremadamente complicado.
En lugar de este enfoque fragmentado, tener una solución de configuración centralizada permite a los equipos gestionar la configuración desde una plataforma o repositorio único.
Construye Tus Aplicaciones Con Variables De Entorno Para El Largo Plazo.
A medida que tu aplicación crece, considera cómo es posible que necesites formas más avanzadas de gestionar su configuración.
Lo que parece sencillo ahora podría complicarse más adelante. Es probable que necesites mejores formas de controlar el acceso, compartir configuraciones de equipo, organizar todo claramente y actualizar configuraciones sin problemas.
No te acorrales solo usando variables de entorno desde el principio. Debes planificar cómo manejar las configuraciones a medida que tus necesidades se expandan.
Si bien las variables de entorno son excelentes para manejar datos centrados en el entorno como credenciales de inicio de sesión, nombres de bases de datos, IPs locales, etc., quieres crear un sistema que siga principios sólidos como seguridad, compartibilidad, organización y la capacidad de adaptarse a los cambios rápidamente.
Las alternativas que discutimos, como el uso de un archivo o servicio de configuración dedicado, tienen características valiosas que se alinean con esos principios. Esto te ayudará a seguir avanzando rápidamente sin detenerte.
