Variables de entorno en Linux: cómo configurarlas

Las variables de entorno en Linux se han convertido en un pilar esencial para el trabajo diario de administradores de sistemas, desarrolladores, estudiantes de programación y prácticamente cualquier persona que interactúe con un servidor.

No creas que las variables de entorno solo te servirán para proyectos de software gigantes. En realidad, resultan muy valiosas para cualquier contexto. Necesitas un valor que se reutiliza en varias partes de tu script? Una ruta que apunte a un directorio en concreto? El usuario actual, la ruta donde se aloja tu proyecto web, la configuración de tu editor predeterminado, etc. Todo esto se maneja con variables de entorno. 

¿Qué son las variables de entorno en Linux?

Para empezar, conviene aclarar qué son exactamente estas variables de entorno. De forma básica, podemos decir que las variables de entorno son valores nombrados que residen en el entorno de ejecución de cada proceso en Linux (y otros sistemas basados en Unix, e incluso en Windows bajo otros mecanismos). Estos valores se comparten o “heredan” a los procesos que se lanzan a partir de la shell original.

Es como si tuvieras un pequeño “archibo” de información que todo proceso puede mirar para saber configuraciones que necesita. Por ejemplo, si en tu sistema tienes definida la variable PATH, esto le indica al sistema en qué directorios buscar los ejecutables cuando llamas a un comando. Sin esta variable, el sistema no sabría dónde ubicar los binarios como ls, echo, cat, etc.

Las variables de entorno, entonces, cumplen la función de almacenar parámetros y configuraciones que las aplicaciones y los scripts pueden leer, sin necesidad de especificarlos de nuevo en cada ocasión. En lugar de reescribir valores y rutas en tu código, lo que harás es leer estos datos de las variables, lo que genera flexibilidad y facilita la mantención de tus proyectos.

¿Por qué las variables de entorno son fundamentales en Linux?

En Linux, la filosofía es “todo es un archivo” o “todo se maneja como un archivo”. Bajo esa perspectiva, muchos comportamientos del sistema se controlan por medio de pequeños valores y configuraciones que viven en diferentes rincones de tu disco duro y en la memoria. Aquí entra en juego la relevancia de las variables de entorno.

1. Reutilización: Muchas aplicaciones necesitan saber dónde encontrar ciertos archivos, librerías o rutas de instalación. En lugar de que cada aplicación repita la misma información, se definen variables de entorno que centralizan esos datos.

2. Facilidad de configuración: Imagínate que cambias de editor de texto predeterminado. Si tu sistema lee la variable EDITOR para saber qué editor usar, solo necesitas cambiar ese valor, y todos los programas que dependan de EDITOR se ajustarán de inmediato.

3. Aislamiento de credenciales: En muchos casos, las contraseñas o keys de acceso a bases de datos y servicios externos se guardan en variables de entorno para evitar ponerlas en el código. Aunque esto tiene sus detalles de seguridad (lo veremos más adelante), sigue siendo un método común para proteger información sensible y evitar el versionado de contraseñas en repositorios públicos.

4. Herencia a subprocesos: Cuando ejecutas un script, este hereda las variables de entorno del proceso padre. Esto facilita que tus scripts tengan acceso directo a valores críticos, sin necesidad de pasarlos como argumentos cada vez.

5. Facilitan despliegues: En entornos de producción, es habitual que la configuración de la aplicación (como URLs, credenciales de API, parámetros de debug, etc.) se maneje con variables de entorno. Así, puedes tener el mismo binario o contenedor y desplegarlo en distintos escenarios, simplemente cambiando los valores de entorno.

Principales variables de entorno en Linux

Hay un conjunto de variables de entorno que suelen aparecer en todas las distribuciones de Linux y que es importante conocer. A continuación, describo algunas de las más populares y su utilidad. Recuerda que no existe un listado oficial inamovible, pero estas son casi omnipresentes y te encontrarás con ellas en tu día a día.

PATH

La variable PATH es probablemente la más crucial. Indica las rutas donde el sistema buscará ejecutables cada vez que llamas a un comando. Por ejemplo, si tienes un programa llamado mi_script en /home/usuario/scripts/, y deseas ejecutarlo sin poner la ruta completa, podrías añadir /home/usuario/scripts/ a la variable PATH. Así, basta con teclear mi_script en la terminal y listo, sin necesidad de /home/usuario/scripts/mi_script.

HOME

La variable HOME señala el directorio personal del usuario. Si tu nombre de usuario es “juan”, normalmente HOME será /home/juan. Muchas aplicaciones acuden a esta variable para ubicar archivos de configuración del usuario, descargas, etc.

USER

La variable USER (en algunos sistemas también aparece como USERNAME) contiene el nombre del usuario actual. Si bien puede parecer obvio que tú sepas quién eres, a veces es importante para scripts o aplicaciones que requieren ese dato para logs, rutas de archivo personalizadas, etc.

SHELL

Guarda la shell que tu usuario está usando, por ejemplo /bin/bash o /bin/zsh. Esto se utiliza frecuentemente para verificar el entorno de ejecución y para fines de compatibilidad en algunos scripts.

PWD

Significa “Print Working Directory”. Contiene la ruta del directorio en el que estás posicionado en la shell actual. Muy útil si tu script necesita saber dónde está ubicado el usuario en cada momento.

LANG o LC_*

Estas variables indican la configuración regional y el idioma que tu sistema emplea para mostrar textos, formatos de fecha, de moneda, etc. Por ejemplo, LANG=es_ES.UTF-8 implica que tu sistema usa el idioma español de España con codificación UTF-8.

EDITOR o VISUAL

Determina qué editor de texto debería usarse por defecto en algunas aplicaciones y scripts (como crontab -e, que a veces respeta esta variable para abrir el editor preferido).

Estas son solo algunas de las variables de entorno que encontrarás con más frecuencia. Existen otras muchas, pero con estas ya tienes una base sólida.

Cómo ver las variables de entorno actuales

Antes de modificar o crear nuevas variables, es ideal que sepas cómo listar las que están activas en tu shell. Para esto, existen varios comandos útiles en Linux:

• printenv: Muestra todas las variables de entorno o, si le pasas como argumento el nombre de una variable concreta, solo te mostrará su valor. Ejemplo: printenv PATH.
• env: Parecido a printenv, lista todas las variables de entorno que están disponibles en el entorno actual.
• set: Muestra no solo las variables de entorno, sino también variables de shell y funciones definidas. Puede ser un listado muy largo.

Por ejemplo, si abres una terminal y escribes env, verás una enumeración de pares NOMBRE=VALOR que representan todas las variables disponibles en ese instante. Gracias a esta información, puedes diagnosticar por qué tal o cual programa falla: tal vez falte una variable o tenga un valor incorrecto.

Cómo configurar variables de entorno de forma temporal

Si deseas crear o modificar una variable de entorno en una sesión puntual, sin afectarla para futuros inicios de sesión, puedes hacerlo en la shell directamente. Para ello, utilizas el comando export en Bash (o la sintaxis equivalente en otras shells).

Supongamos que quieres establecer una variable de entorno llamada MI_VARIABLE y darle el valor “HolaMundo”. Basta con:

Ahora, si haces echo $MI_VARIABLE, verás el valor asignado. Esta variable estará disponible hasta que cierres la sesión actual de la terminal. Si abres una nueva sesión, ya no existirá (a menos que la definas de nuevo o la tengas en un archivo de configuración).

Lo mismo se aplica para modificar una variable existente. Por ejemplo, si quieres añadir un directorio a la variable PATH, harías:

Con esta línea, incluyes la ruta /home/usuario/scripts al inicio de la ruta de búsqueda. Y no te preocupes, no has perdido el contenido anterior, pues lo hemos concatenado usando $PATH.

Ten presente que la definición temporal de variables es muy útil para hacer pruebas o cambiar el entorno de un script de forma puntual. Pero si necesitas que el cambio persista entre sesiones, entonces tienes que optar por la configuración permanente.

Cómo configurar variables de entorno de forma permanente

Configurar variables de entorno de forma permanente implica editár algunos archivos que se cargan cada vez que abres una sesión. Dependiendo de tu shell y de tu distribución de Linux, estos archivos pueden cambiar. Los más comunes son:

• ~/.bashrc: Se carga para shells interactivas no relacionadas con login. Si tu usuario usa Bash (lo más habitual en muchos sistemas), aquí puedes añadir tus export para que se apliquen siempre que abras la terminal.
• ~/.bash_profile o ~/.profile: Se cargan en shells de login. Dependiendo de la configuración, se puede usar uno u otro.
• ~/.zshrc: En caso de que uses Zsh, este archivo cumple la misma función que .bashrc para Bash.

La estrategia más frecuente es editar el archivo .bashrc (o el que use tu shell por defecto) y añadir las líneas de exportación que deseas. Por ejemplo, puedes abrirlo con un editor de tu preferencia:

Y al final, añadir:

Después de guardar el archivo, ejecuta:

para recargar la configuración sin tener que cerrar y abrir la terminal. Así, la próxima vez que abras una sesión, tus variables de entorno estarán listas y configuradas permanentemente.

Configurar variables de entorno a nivel de sistema

Si deseas que la configuración sea válida para todos los usuarios del sistema, puedes editar archivos globales, como /etc/environment o /etc/profile. Ten cuidado, porque los cambios que hagas ahí afectarán a todos los usuarios, y un error podría provocar que el sistema se comporte mal. Además, algunas distribuciones utilizan archivos adicionales para la configuración de entornos gráficos y servicios. Por ello, revisa la documentación de tu distribución si necesitas ajustes más específicos.

Herencia de variables: cómo pasa la información a los subprocesos

Cuando un proceso en Linux crea un subproceso (por ejemplo, cuando lanzas un script desde la terminal), ese subproceso hereda las variables de entorno del proceso padre. Por eso, si defines una variable en tu sesión de shell y ejecutas un script, este script podrá usar esa variable sin que se la pases directamente como argumento.

Sin embargo, la herencia no va en sentido inverso. Si dentro de un script modificas o creas nuevas variables de entorno, esas variables no volverán a la shell madre a menos que hagas trucos especiales (como ejecutar el script con un source script.sh en lugar de ./script.sh). Esto es importante para diseñar scripts que configuran el entorno: si deseas que la shell superior se vea afectada, necesitas “cargar” el script en la propia shell, no ejecutarlo como un proceso aparte.

Uso de archivos .env

En muchos proyectos, sobre todo en aplicaciones web, se recurre a archivos .env para almacenar variables de entorno específicas de un proyecto. El contenido de un .env suele ser algo así:

Luego, frameworks y herramientas (por ejemplo, algunas basadas en scripts Bash o en lenguajes como Node.js con librerías específicas) leen este archivo y lo cargan en el entorno de la aplicación. Esto permite separar la configuración de la aplicación del código, algo muy valioso para no exponer credenciales en repositorios públicos. Sin embargo, es esencial mantener estos archivos .env fuera de tu repositorio de código o en un lugar seguro, para no comprometer datos sensibles.

Buenas prácticas al manejar variables de entorno

El manejo de variables de entorno puede parecer trivial, pero hay una serie de buenas prácticas que te harán la vida más sencilla:

• Nombres claros: Usa nombres descriptivos, por ejemplo, DB_HOST, API_KEY, REDIS_PORT, etc. Evita nombres genéricos como “VAR1” o “DATA”, que a la larga generan confusiones.

• Separación de entornos: Procura que los valores en desarrollo, pruebas y producción sean distintos. No quieres tener la misma clave de base de datos para todo. De nuevo, los archivos .env suelen ser la solución.

• Privilegios adecuados: Si guardas variables sensibles en archivos del sistema, verifica los permisos de lectura/escritura. Evita que usuarios sin autorización puedan leer contraseñas y tokens.

• Evitar exponer credenciales: No subas tus .env a repositorios públicos. Usa mecanismos de configuración que no arriesguen la confidencialidad de tus datos.

• Documenta: Sí, aunque parezca obvio, documentar las variables que usa tu proyecto o tu sistema es vital para que otros (o tú en el futuro) entiendan cómo está estructurado el entorno.

Problemas comunes y cómo resolverlos

Aunque las variables de entorno sean un recurso poderoso, también generan ciertos dolores de cabeza si no se manejan bien. Veamos algunos de los fallos habituales:

1. Variables no disponibles en scripts
A veces defines una variable en tu terminal y luego ejecutas un script, pero el script no “ve” esa variable. Esto ocurre cuando no haces export. Recuerda que VAR="valor" solo la define en tu shell, mientras que export VAR="valor" la hereda a los subprocesos.

2. Cambios no permanentes
Si haces export en tu sesión y luego cierras la terminal, al reabrirla no encuentras tus variables. La solución es añadir las líneas de exportación en tu ~/.bashrc o el archivo adecuado para tu shell.

3. Conflictos con variables globales
Si modificas archivos como /etc/environment o /etc/profile, es posible que entre en conflicto con valores que definen paquetes o servicios de tu distribución. Por ello, edita con cautela y siempre haz un respaldo antes de cambiar esos archivos.

4. Desbordamiento del PATH
Agregar de forma indiscriminada rutas a PATH puede hacer que termine siendo muy largo y confuso, además de generar confusión al sistema si existen binarios con el mismo nombre en distintas rutas. Sé ordenado, añade solo lo imprescindible y elimina rutas obsoletas.

5. Errores tipográficos
Un error tan simple como export PAT=/usr/local/bin:$PATH (en lugar de PATH) puede hacer que el sistema no encuentre comandos. Asegúrate de teclear con cuidado y revisa valores inmediatamente después de modificarlos.

Variables de entorno y seguridad

El uso de variables de entorno es una forma recurrente de gestionar credenciales y configuraciones sensibles, sobre todo para no incrustar datos confidenciales en el código. Sin embargo, hay que tener en cuenta ciertas precauciones:

• No confíes ciegamente: Aunque las variables de entorno evitan poner contraseñas en el código, si un atacante tiene acceso al servidor, podría leer las variables con comandos como env o printenv. Por eso, lo principal es proteger el acceso al servidor.

• Permisos restrictivos: Si usas archivos .env, ponles permisos de lectura sólo para el usuario que realmente los necesite (chmod 600 puede ser útil en muchos casos).

• No expongas variables en logs: Hay aplicaciones que al fallar imprimen su entorno. Revisa que tus logs no contengan información sensible.

• Segmentación de usuarios: Para minimizar riesgos, trabaja con distintos usuarios en el sistema y define únicamente las variables de entorno que cada uno necesita. De ese modo, un usuario con acceso limitado no puede ver datos que no le atañen.

El rol de las variables de entorno en flujos de integración y despliegue

Con la popularización de contenedores y flujos de integración continua (CI/CD), las variables de entorno han cobrado aún más importancia. Por ejemplo, si usas contenedores, es habitual que al iniciar el contenedor se inyecten valores como:

Esto permite que tu contenedor se ejecute con la configuración adecuada sin tener que recrearlo cada vez. También es común en pipelines de CI/CD, donde la plataforma de integración (como GitLab, GitHub Actions, etc.) define variables de entorno para compilar, testear y desplegar tu aplicación, diferenciando entornos de staging y producción sin cambiar el código base.

Aplicaciones prácticas en el día a día

Aunque suene muy orientado al ámbito de servidores y scripts, las variables de entorno te pueden servir en tareas cotidianas. Por ejemplo:

• Si usas un editor de texto que se ejecuta en terminal, puedes definir la variable EDITOR o VISUAL para que cualquier acción que requiera editar texto abra tu editor favorito.

• Si trabajas con scripts que necesitan conectarse a una base de datos local, defines variables como DB_HOST, DB_USER, DB_PASS en tu ~/.bashrc para no tener que recordar credenciales a cada rato.

• Para desarrollar aplicaciones web, donde en local usas la base de datos en localhost, y en producción usas otro host, puedes simplificar todo con variables de entorno y un .env.

• Para personalizar el color o comportamiento de tu prompt en Bash o Zsh, muchas veces se manipulan variables internas como PS1, que controla cómo se ve tu línea de comando.

La importancia de la portabilidad

Gracias a las variables de entorno, puedes lograr que tus scripts sean portátiles en distintos sistemas, siempre que configures adecuadamente los valores necesarios. En lugar de incrustar rutas absolutas (por ejemplo, /home/juan/miscript), puedes usar la variable HOME para ubicar el directorio del usuario, o la variable PATH para buscar binarios sin codificar una ruta fija. Esto hace que tus scripts se ejecuten sin mayores complicaciones en diferentes entornos.

Cómo depurar problemas relacionados con variables de entorno

¿Alguna vez te has encontrado con un comportamiento extraño en tu terminal? ¿Ejecutas un comando y el sistema te dice que no existe, cuando estás seguro de que sí está instalado? Muy a menudo, la raíz del problema se halla en la configuración de las variables de entorno. He aquí pasos simples para depurar:

• Verifica con env | grep NOMBRE_VARIABLE para ver si la variable existe y cuál es su valor.
• Revisa si en el archivo ~/.bashrc o equivalente tienes definiciones contradictorias o repetidas.
• Comprueba si has editado archivos globales como /etc/environment que podrían haber sobrescrito la variable.
• Haz echo $PATH para ver si verdaderamente la ruta del binario está incluida.
• Prueba abriendo una nueva sesión o ejecutando source ~/.bashrc si tus cambios no surten efecto.

A menudo, solo con estos pasos puedes detectar rápidamente si hay un error ortográfico o si una variable está sobrescrita por otra definición posterior.

Cuándo usar export y cuándo usar set

En el caso de Bash, export hace que una variable sea accesible a procesos hijos. set, por otra parte, también se emplea para definir variables locales de la shell, pero no necesariamente las “exporta”. Este matiz es importante: si deseas que tus scripts y subprocesos tengan acceso a la variable, debes usar export.

En shells como Zsh, la lógica es similar, aunque sus archivos de configuración pueden diferir un poco. En cualquier caso, la idea es que export es la palabra clave que te asegura la variable llegue a todos los rincones que lo necesiten.

Variables de entorno y scripting avanzado

Cuando te sumerges en scripting más avanzado, verás que las variables de entorno son esenciales para escribir programas robustos y genéricos. Por ejemplo, un script que realice copias de seguridad puede leer variables como BACKUP_SOURCE, BACKUP_DEST, BACKUP_LOG desde el entorno, lo que te permitirá cambiar fuentes, destinos o rutas de log sin modificar el cuerpo del script.

En el desarrollo de microservicios, cada servicio puede leer sus configuraciones de un archivo .env o de variables definidas en el sistema. Así, se facilita la escalabilidad y la capacidad de replicar servicios en distintos servidores con ajustes mínimos.

La importancia del orden en los archivos de configuración

Cuando tu entorno es muy complejo y tienes múltiples archivos de configuración (por ejemplo, .bashrc, .profile, .bash_profile, /etc/environment, etc.), podrías encontrarte con que se invoquen en un orden específico. Normalmente, en un inicio de sesión de Bash, el sistema verifica primero ciertos archivos globales como /etc/profile, luego salta a ~/.bash_profile o ~/.profile, y finalmente a ~/.bashrc. Dependiendo de cómo abras la terminal (login shell vs. shell interactiva no login), puede que ciertos archivos no se carguen como esperabas.

Esto significa que si, por ejemplo, añades export MI_VARIABLE="HolaMundo" en ~/.bash_profile, pero la terminal que abres no es una shell de login, esa variable no se definirá. Es un error más común de lo que parece, especialmente en distribuciones modernas que diferencian los archivos de inicio dependiendo del tipo de sesión. Por ello, revisa con cuidado qué archivo debes editar según tu necesidad.