Cómo configurar y enumerar variables de entorno en Linux

Cada proceso de Linux hereda un conjunto de variables de entorno de su proceso padre. Estos pares clave-valor controlan cómo se comportan los shells, dónde los programas buscan ejecutables y qué configuración utiliza una aplicación en ejecución. Si las configuras mal, tu despliegue se rompe a las 2:00. Si las configuras bien, tendrás una configuración del sistema limpia y portable que viaja contigo en tu perfil de usuario o en todo tu servidor.

Tanto si estás configurando un VPS nuevo, depurando un canal de CI que falla o desplegando una aplicación en Python que se niega a encontrar su base de datos, las variables de entorno están en el centro de todo. Son uno de esos conceptos fundamentales de Linux que usarás todos los días una vez que los entiendas.

Esta guía te explica los comandos que realmente usarás en tu día a día: listar, mostrar, configurar, hacer persistentes y eliminar variables de entorno en Linux. También veremos buenas prácticas y errores comunes que hacen tropezar incluso a administradores de sistemas con experiencia.

Qué son las variables de entorno en Linux

Las variables de entorno son pares dinámicos clave-valor que determinan cómo se comportan los shells y los procesos en un sistema Linux. Ejecuta printenv en una terminal y verás decenas de ellas: PATH le indica al shell dónde encontrar ejecutables, HOME apunta a tu directorio de usuario, SHELL identifica qué shell estás usando y LANG establece tu configuración regional.

Los administradores las usan para compartir configuración entre aplicaciones sin tener que incluir valores directamente en el código. Una sola variable PATH, por ejemplo, permite que todos los programas del sistema localicen binarios sin que cada uno tenga que mantener su propia lista de búsqueda. Piensa en las variables de entorno como un tablón compartido que todos los procesos del sistema pueden leer.

Linux establece una diferencia entre dos tipos de variables. Las variables de entorno tienen un alcance global. Son visibles para los procesos hijos, los subshells y cualquier programa que se inicie desde esa sesión. Las variables del shell, en cambio, existen solo en la sesión actual. Inicia un subshell con bash y desaparecerán.

Esa diferencia importa más de lo que parece. Es la razón por la que tu script funciona perfectamente cuando lo ejecutas de forma interactiva, pero falla cuando lo lanza cron, systemd u otro usuario. El proceso que lo invoca no arrastra tus variables del shell, y el script se encuentra con un valor vacío donde esperaba una ruta.

Cómo gestionar las variables de entorno en Linux

Gestionar las variables de entorno en un sistema Linux significa dominar cuatro operaciones: listarlas, mostrar una concreta, definir nuevas y eliminar las que no necesites. Todo lo que verás a continuación funciona en cualquier distribución Linux estándar, desde Ubuntu y Debian hasta CentOS y Arch. Conéctate por SSH o abre tu terminal local y estarás listo para empezar.

Cómo listar las variables de entorno en Linux

La forma más rápida de listar las variables de entorno en Linux es con el comando printenv:

printenv

Eso muestra cada variable y su valor en la salida estándar (stdout). La salida se hace larga rápidamente, así que pásala a less para poder desplazarte cómodamente:

printenv | less

El comando env funciona casi de forma idéntica a printenv. Donde se diferencian es que el comando set en Linux muestra tanto las variables de entorno como las variables del shell, ofreciéndote una visión completa. Si solo quieres ver las variables del shell, filtra con grep:

set | grep -i my_var

Algunas variables que verás constantemente en distintas distribuciones de Linux:

• PATH – los directorios que el shell busca para encontrar archivos ejecutables
• HOME – el directorio personal del usuario actual
• USER – el nombre de la cuenta de usuario que ha iniciado sesión
• SHELL – la ruta al shell del usuario actual
• PWD – el directorio de trabajo actual
• EDITOR – el editor de texto predeterminado del sistema

Estas vienen predefinidas en prácticamente cualquier distribución Linux. Puedes definir las tuyas para cualquier propósito: configuraciones personalizadas de aplicaciones, indicadores de despliegue, endpoints de servicios. Ahí es donde la cosa se pone interesante.

Cómo mostrar variables de entorno en Linux

Para mostrar una sola variable de entorno en Linux, usa el comando echo con el prefijo de signo de dólar:

echo $PATH

El comando de Linux echo lee el valor actual de la variable y lo muestra en la terminal. Distingue entre mayúsculas y minúsculas, así que $path y $PATH son cosas diferentes.

También puedes usar printenv directamente con el nombre de la variable:

printenv HOME

¿Necesitas comprobar si una variable existe siquiera? Pasa printenv por grep:

printenv | grep USER

Para consultar varias variables a la vez:

printenv HOME PATH SHELL

Cada valor se muestra en su propia línea. Rápido, sin complicaciones. Esto es útil cuando estás escribiendo un script de configuración y necesitas confirmar que varios valores están definidos antes de continuar.

Definir una variable de entorno en Linux usando <code>export</code>

El comando export en Linux crea una variable de entorno global temporal. Aquí tienes la sintaxis básica:

export MY_VAR="some_value"

Esa variable ahora es visible para el shell actual y para cualquier proceso hijo que inicies desde él. Muéstrala para confirmarlo:

echo $MY_VAR

Puedes asignar varios valores separados por dos puntos, que es como funciona PATH:

export PATH="$PATH:/opt/myapp/bin"

Aquí está la clave: esto es temporal. Reinicia tu sistema, abre una nueva sesión de terminal y habrá desaparecido. El comando de Linux export solo afecta a la sesión en ejecución y a sus procesos hijos. Esto confunde con frecuencia a quienes están empezando. Definen una variable, funciona, reinician y ha desaparecido.

Para una variable local del shell (que no se propaga a los procesos hijos), omite la palabra clave export:

my_local_var="test"

Por convención, se usan minúsculas para variables locales y mayúsculas para variables globales. Respétalo. Tu yo del futuro agradecerá la claridad cuando estés solucionando problemas a medianoche.

Cómo hacer que las variables de entorno sean persistentes

Las variables temporales desaparecen al reiniciar. Para tener variables de entorno permanentes en Linux, necesitas escribirlas en archivos de configuración. El archivo depende de quién deba ver la variable.

Variables de entorno específicas del usuario

Edita el archivo bashrc para definir variables que persistan para un solo usuario. Ábrelo con cualquier editor de texto:

nano ~/.bashrc

Añade tu instrucción <code>export</code> al final:

export API_URL="https://api.example.com"

Guarda y sal. La variable no tendrá efecto en tu sesión actual hasta que recargues el archivo:

source ~/.bashrc

El comando source ~/.bashrc vuelve a leer el archivo sin que tengas que cerrar sesión y volver a iniciarla. Es el paso que más suele omitirse cuando añades una nueva variable y te preguntas por qué no aparece.

También puedes usar ~/.profile si necesitas que las variables estén disponibles en shells de inicio de sesión. La diferencia: .bashrc se ejecuta en cada shell interactivo, .profile se ejecuta una vez al iniciar sesión. Elige el que se ajuste a tu caso de uso. Si no estás seguro, .bashrc es la opción más segura por defecto en la mayoría de los escenarios.

Variables de entorno a nivel de sistema

Para variables que todos los usuarios del sistema necesitan, edita /etc/environment:

sudo nano /etc/environment

Añade pares clave-valor simples sin la palabra clave export:

JAVA_HOME="/usr/lib/jvm/java-17"

Guarda y luego reinicia o vuelve a iniciar sesión para que los cambios surtan efecto.

Un enfoque alternativo: crea un script de shell en /etc/profile.d/. Este directorio se carga al iniciar sesión para todos los usuarios:

sudo nano /etc/profile.d/custom_env.sh

Dentro del archivo, usa export como lo harías normalmente:

export LOG_LEVEL="info"

Dale un nombre de archivo descriptivo. Te lo agradecerás cuando el directorio tenga 15 scripts y necesites encontrar el que configura el proxy. Reinicia para aplicar los cambios y luego confirma con printenv. El enfoque de /etc/profile.d/ es más limpio para gestionar varios grupos de variables, porque cada aspecto tiene su propio archivo.

Eliminar variables de entorno en Linux

El comando unset elimina una variable de entorno de la sesión actual:

unset MY_VAR

Desaparece. Pero solo en esta sesión. Si esa variable está definida en ~/.bashrc o /etc/environment, volverá a aparecer después de reiniciar. El comando unset es temporal por diseño.

Para eliminar permanentemente una variable de entorno en Linux, abre el archivo de configuración donde está definida y elimina (o comenta) la línea. Comentarla es más seguro y te evita problemas en el futuro:

# export API_URL="https://api.example.com"

Un símbolo de almohadilla al inicio la desactiva sin eliminarla. Cuando surja la inevitable pregunta «¿por qué quitamos eso?» tres semanas después, podrás descomentarlo en segundos en lugar de tener que reconstruir el valor de memoria.

Uso de variables de entorno en desarrollo

Aquí es donde las variables de entorno realmente demuestran su valor. Guardar credenciales de base de datos, claves API y URLs de servicios como variables de entorno las mantiene fuera de tu base de código. Sin secretos en el control de versiones. Sin subir accidentalmente la contraseña de la base de datos de producción a un repositorio público de GitHub. Si alguna vez has visto a una empresa en las noticias por credenciales filtradas, es muy probable que alguien se haya saltado este paso.

El patrón funciona así. Defines variables diferentes para cada entorno:

export APP_ENV="staging"

export DB_HOST="staging-db.internal"

Cuando despliegas en producción, cambias los valores. El código de la aplicación lee $APP_ENV y $DB_HOST y se comporta en consecuencia. Sin cambios de código entre entornos. La misma imagen de Docker, el mismo binario, el mismo script se ejecuta en todos lados con un comportamiento diferente basado únicamente en las variables que hereda.

Este enfoque también simplifica la automatización. Un script de despliegue puede definir variables de entorno antes de iniciar una aplicación, y todos los valores de configuración fluyen desde un único lugar. Compáralo con mantener archivos de configuración separados por entorno, cada uno una posible fuente de desviaciones y errores. Tres entornos con cinco archivos de configuración cada uno son quince archivos que debes mantener sincronizados. Las variables de entorno reducen eso a un solo mecanismo.

Buenas prácticas para variables de entorno

Conocer los comandos es solo la mitad de la batalla. Usarlas bien es lo que separa un sistema limpio de uno que se rompe de formas misteriosas.

Usa nombres de variables descriptivos

VAR1 no te dice nada. POSTGRES_CONNECTION_STRING te lo dice todo. Los nombres descriptivos evitan la situación en la que estás mirando 40 variables exportadas y no puedes saber cuál controla el directorio de salida de registros.

Sigue una convención de nomenclatura coherente. Prefija las variables relacionadas con el nombre de la aplicación o del servicio: MYAPP_DB_HOST, MYAPP_DB_PORT, MYAPP_LOG_PATH. Cuando otro miembro del equipo herede tu servidor, podrá entender el sistema en minutos en lugar de horas. Los nombres vagos crean conocimiento tribal. Los nombres descriptivos crean documentación que vive justo donde realmente se usa.

Gestiona correctamente el alcance de las variables

Un error frecuente: creas una variable de shell con el mismo nombre que una variable de entorno global. El shell no sabe a cuál te refieres y, de repente, tu aplicación lee el valor equivocado. He visto que esto arruinó un despliegue en producción porque alguien tenía una sobreescritura local de PATH que había olvidado.

Usa variables locales (del shell) para trabajos temporales: un contador en un script, la ruta de un archivo temporal, un valor de prueba puntual. Usa variables de entorno globales para todo lo que se comparte entre procesos: URLs de bases de datos, niveles de registros, indicadores de funcionalidades.

Sigue la convención. Minúsculas para variables locales del shell, mayúsculas para las globales. PATH es a nivel del sistema. path_to_tmp es solo para la sesión. Esa distinción visual te mantiene alerta.

Audita las variables de entorno regularmente

Las variables se acumulan. Las claves API antiguas permanecen. Las URLs de servicios obsoletas permanecen. Alguien activó un indicador de depuración hace seis meses y se olvidó de él, y ahora tu servidor de producción está escribiendo registros detallados en un disco que está al 94 % de su capacidad. Esto sucede más a menudo de lo que cualquiera quiere admitir.

Vuelca tus variables actuales a un archivo de forma periódica:

set > env_audit_$(date +%Y%m%d).txt

Compáralas con los volcados anteriores. Elimina lo que ya no se usa. Rota las credenciales que aparezcan en la lista de variables exportadas. Verifica que nada sensible se haya filtrado en un archivo a nivel de sistema que todos los usuarios puedan leer. No es un trabajo glamoroso, pero es el tipo de mantenimiento que previene incidentes de seguridad y fallos misteriosos en producción. Trátalo como cambiar el aceite: aburrido, necesario y catastrófico si se descuida.

Preguntas frecuentes sobre variables de entorno en Linux