Variables de Entorno en Linux: Desde lo Básico hasta el Uso Avanzado

Introducción

¡Bienvenido a este laboratorio práctico sobre variables de entorno en Linux! Las variables de entorno son valores dinámicos que pueden afectar el comportamiento de los procesos que se ejecutan en una computadora. Juegan un papel crucial en la configuración del sistema y la ejecución de programas. Al dominar las variables de entorno, adquirirás habilidades esenciales para la administración de sistemas Linux y el desarrollo de software.

En este laboratorio, aprenderás a crear, visualizar, modificar y eliminar variables de entorno. También exploraremos cómo hacer que estos cambios sean permanentes y comprenderemos algunas de las variables de entorno integradas más importantes en Linux. Ya seas un principiante o alguien que busca consolidar sus conocimientos, esta experiencia práctica te resultará muy valiosa.

¡Comencemos!

Entendiendo las Variables en Linux

Antes de sumergirnos en las variables de entorno, comencemos con las variables básicas de la shell. Esto te ayudará a comprender el concepto general de las variables en Linux.

Abre tu terminal. Deberías estar en el directorio /home/labex/project. Si no es así, puedes cambiar a este directorio usando el siguiente comando:
```
cd /home/labex/project
```
Ahora, vamos a crear una variable de shell simple. En Linux, puedes crear una variable simplemente asignando un valor a un nombre. Creemos una variable llamada my_var:
```
my_var="Hello, Linux"
```
Nota importante: Al asignar variables en Bash (y en Zsh, que es la que usamos en este laboratorio), no debe haber espacios alrededor del signo igual (=). Escribir my_var = "Hello, Linux" o my_var= "Hello, Linux" provocará un error.
Para ver el valor de la variable, utilizamos el comando echo con un símbolo $ antes del nombre de la variable. El $ le indica a la shell que debe sustituir el nombre por el valor de la variable:
```
echo $my_var
```
Deberías ver la salida:
```
Hello, Linux
```
También puedes usar variables dentro de otros comandos o asignaciones. Por ejemplo:
```
echo "The value of my_var is: $my_var"
```
Esto mostrará: The value of my_var is: Hello, Linux

¡Buen trabajo! Acabas de crear y usar tu primera variable de shell. Sin embargo, esta variable solo está disponible en la sesión actual de la shell. Si abres una nueva ventana o pestaña de la terminal, esta variable no estará allí. Aquí es donde las variables de entorno resultan útiles.

Introducción a las Variables de Entorno

Ahora que entendemos las variables básicas, exploremos las variables de entorno. Las variables de entorno son variables que están disponibles para cualquier proceso hijo de la shell. Esto significa que pueden ser accedidas por scripts y programas ejecutados desde esa shell.

Para ver todas las variables de entorno actuales, usa el comando env:
```
env
```
Esto mostrará una lista larga de variables. No te preocupes si no las entiendes todas todavía; cubriremos algunas de las más importantes más adelante.
Una de las variables de entorno más importantes es PATH. Echémosle un vistazo:
```
echo $PATH
```
La variable PATH enumera los directorios donde el sistema busca programas ejecutables. Cada directorio está separado por dos puntos (:).
Ahora, vamos a crear nuestra propia variable de entorno. Usamos el comando export para crear una variable de entorno:
```
export MY_ENV_VAR="This is an environment variable"
```
El comando export hace que la variable esté disponible para los procesos hijos. Esta es la diferencia clave entre las variables de shell y las variables de entorno.
Para ilustrar la diferencia, vamos a crear un script de shell que intente acceder tanto a una variable de shell normal como a una variable de entorno. Podemos hacer esto usando un heredoc con el comando cat, que es una forma común de escribir contenido multilínea en un archivo:
```
cat << 'EOF' > test_vars.sh
#!/bin/bash
echo "Shell variable: $my_var"
echo "Environment variable: $MY_ENV_VAR"
EOF
```
Dale permisos de ejecución al script:
```
chmod +x test_vars.sh
```
Ahora ejecuta el script:
```
./test_vars.sh
```
Verás que la variable de entorno (MY_ENV_VAR) es accesible, mientras que la variable de shell (my_var) no lo es. Esto se debe a que my_var no fue exportada, por lo que los procesos hijos (como el script) no la conocen.
Para verificar que MY_ENV_VAR es ahora una variable de entorno, podemos usar el comando env nuevamente, pero esta vez filtraremos la salida usando grep:
```
env | grep MY_ENV_VAR
```
Deberías ver tu nueva variable en la salida.
También puedes consultar el valor de tu nueva variable de entorno directamente:
```
echo $MY_ENV_VAR
```

¡Excelente! Has creado tu primera variable de entorno y has visto en qué se diferencia de una variable de shell. La diferencia fundamental es que las variables de entorno, creadas con export, están disponibles para los procesos hijos, mientras que las variables de shell no lo están.

Las variables de entorno y las variables de shell tienen cada una su propio alcance. Cuando exportas una variable (por ejemplo, export MY_ENV_VAR="algo"), esta se vuelve disponible para cualquier subproceso iniciado desde esa shell (por ejemplo, un script de shell ejecutado por esa misma shell). Sin embargo, si abres una sesión de shell completamente separada, esta no heredará las variables de tu shell actual a menos que las definas específicamente en un archivo de inicio (como .zshrc o .bashrc).

En otras palabras:

Una variable de shell normal es visible solo dentro de la sesión actual.
Una variable exportada está disponible para los procesos hijos lanzados desde esa sesión.
Una variable configurada en un archivo de inicio de la shell (como .zshrc) se aplica a todas las nuevas sesiones de esa shell.

No puedes leer directamente las variables de otro usuario o de otra shell porque cada proceso mantiene su propio entorno. Si inicias una nueva shell, esta obtiene una copia de las variables exportadas del padre, pero no de las variables configuradas solo en la shell original sin export.

Aprenderemos cómo configurar variables de entorno de forma permanente en los siguientes pasos.

Niveles de Permanencia de las Variables

Para ayudar a visualizar las diferencias entre estos tipos de variables y sus niveles de permanencia, aquí tienes una visión general:

graph LR
    A["Tipos de Variables en Linux"] --> B["Variable de Shell"]
    A --> C["Variable de Entorno"]
    A --> D["Variable Permanente"]

    B --> B1["Solo Sesión"]
    B --> B2["No Heredada"]
    B --> B3["Se pierde al salir"]

    C --> C1["Alcance de Sesión"]
    C --> C2["Acceso para Hijos"]
    C --> C3["Se pierde al salir"]

    D --> D1["Todas las Sesiones"]
    D --> D2["Acceso para Hijos"]
    D --> D3["Persistente"]

    B1 --> E1["my_var='valor'"]
    C2 --> E2["export VAR='valor'"]
    D3 --> E3["archivo ~/.zshrc"]

    style B fill:#ffebee
    style C fill:#fff3e0
    style D fill:#e8f5e8

Este diagrama muestra los tres niveles de permanencia de las variables. Aquí tienes una tabla de resumen para referencia rápida:

Tipo de Variable	Alcance	Acceso Proceso Hijo	Persistencia	Ejemplo de Sintaxis
Variable de Shell	Solo sesión actual	No	Se pierde al salir	`my_var='valor'`
Variable de Entorno	Sesión actual	Sí	Se pierde al salir	`export VAR='valor'`
Variable Permanente	Todas las sesiones	Sí	Sobrevive al salir	En archivo `~/.zshrc`

Comprender estos tres niveles es crucial para una administración eficaz del sistema Linux y te ayudará a elegir el enfoque adecuado para diferentes escenarios.

Modificando la Variable de Entorno PATH

La variable PATH es una de las variables de entorno más importantes en Linux. Le indica al sistema dónde buscar archivos ejecutables. Vamos a modificarla para incluir un nuevo directorio.

Primero, vamos a crear un nuevo directorio donde podríamos guardar scripts personalizados:
```
mkdir ~/my_scripts
```
Esto crea un directorio llamado my_scripts en tu carpeta personal (home). El símbolo ~ es un atajo para la ruta de tu directorio personal, que en este laboratorio es /home/labex.
Ahora, vamos a añadir este nuevo directorio a tu PATH. Usaremos el comando export, pero esta vez modificaremos una variable existente:
```
export PATH="$PATH:$HOME/my_scripts"
```
Analicemos esto:
- $PATH es el valor actual de la variable de entorno PATH. Estamos usando el valor existente y añadiéndole algo.
- : se utiliza para separar los directorios en el PATH. Si omites los dos puntos, la shell no podrá encontrar los ejecutables en el directorio que añadiste.
- $HOME es una variable de entorno que apunta a tu directorio personal (nuevamente, /home/labex en nuestro caso).
- Por lo tanto, estamos añadiendo :$HOME/my_scripts al PATH existente. Esto le indica al sistema que busque ejecutables en my_scripts después de buscar en los directorios del PATH original.
Verifica que el nuevo directorio ha sido añadido:
```
echo $PATH
```
Deberías ver /home/labex/my_scripts al final de la salida. Si no está al final, es posible que lo hayas modificado de otra manera, lo cual está bien, siempre y cuando la ruta /home/labex/my_scripts figure en tu PATH.
Para probar esto, vamos a crear un script simple en nuestro nuevo directorio:
```
cat << 'EOF' > ~/my_scripts/hello.sh
#!/bin/zsh
echo "Hello from my custom script!"
EOF
```
Esto crea un script de shell llamado hello.sh en el directorio ~/my_scripts. La primera línea, #!/bin/zsh, le indica al sistema que este es un script de zsh, permitiendo que se ejecute como un programa.
Haz que el script sea ejecutable:
```
chmod +x ~/my_scripts/hello.sh
```
El comando chmod +x añade permisos de ejecución al script, permitiendo que se ejecute como un programa. Si no realizas este paso, obtendrás un error de "permiso denegado" al intentar ejecutarlo.
Ahora, deberías poder ejecutar este script desde cualquier lugar simplemente escribiendo su nombre:
```
hello.sh
```
Si todo funcionó correctamente, deberías ver: Hello from my custom script!

Esto funciona porque añadimos el directorio my_scripts al PATH. Cuando escribes un comando, la shell busca un archivo ejecutable con ese nombre en cada uno de los directorios enumerados en el PATH, en orden. Al añadir my_scripts al PATH, le hemos dicho a la shell que también busque ejecutables allí.

Para demostrar esto, intenta cambiar a un directorio diferente y ejecuta el script de nuevo:

cd /tmp
hello.sh

Verás que el script sigue funcionando, aunque no estés en el directorio donde se encuentra. Este es el poder de la variable PATH: te permite ejecutar programas desde cualquier lugar del sistema, siempre que estén en un directorio incluido en el PATH.

¡Excelente trabajo! Has modificado con éxito la variable de entorno PATH y has creado un script personalizado que se puede ejecutar desde cualquier lugar.

Haciendo que las Variables de Entorno sean Permanentes

Las variables de entorno que hemos configurado se perderán al cerrar la terminal. Para que sean permanentes, necesitamos añadirlas a un archivo de configuración de la shell. El archivo exacto depende de la shell que estés utilizando.

En este entorno de laboratorio, estamos usando Z shell (zsh), que es una versión extendida de la Bourne Shell (sh), con muchas mejoras, incluyendo algunas características de Bash, ksh y tcsh. Zsh se ha vuelto cada vez más popular y ahora es la shell por defecto en macOS.

Si estuvieras usando Bash (que sigue siendo el estándar en muchas distribuciones de Linux), modificarías .bashrc. Sin embargo, como estamos usando Zsh, modificaremos .zshrc. Es muy importante usar el archivo correcto. Si modificas .bashrc mientras usas zsh, las variables no se configurarán.

Abre el archivo .zshrc en tu directorio personal con un editor de texto. Usaremos nano, que es un editor de texto sencillo basado en terminal:
```
nano ~/.zshrc
```
Este comando abre el archivo ~/.zshrc, donde ~ es de nuevo el atajo para tu directorio personal /home/labex. Si el archivo .zshrc no existe, nano creará uno nuevo. Este archivo se ejecuta cada vez que inicias una nueva sesión de terminal.
Desplázate hasta el final del archivo (puedes usar las teclas de flecha) y añade las siguientes líneas:
```
export MY_ENV_VAR="This is an environment variable"
export PATH="$PATH:$HOME/my_scripts"
```
Asegúrate de añadir estas líneas al final del archivo. Verifica que la ortografía y la sintaxis sean correctas, especialmente que no haya espacios alrededor del signo =.
Guarda el archivo y sal del editor. En nano, esto se hace presionando Ctrl+X, luego Y (para guardar) y después Enter.
Para aplicar estos cambios sin reiniciar tu terminal, usa el comando source:
```
source ~/.zshrc
```
El comando source lee y ejecuta los comandos del archivo especificado como argumento en el entorno de la shell actual. Esto es diferente a simplemente ejecutar el archivo usando bash ~/.zshrc, lo cual ejecutaría el script en una nueva shell y no afectaría a la actual. source lo ejecuta en la shell actual para que tus cambios surtan efecto de inmediato. Si te saltas este paso, tus cambios no se verán reflejados en tu terminal actual y tendrás que cerrarla y volverla a abrir para ver los cambios.

Ahora, estas variables de entorno se configurarán cada vez que abras una nueva terminal. Esto es increíblemente útil para configurar tu entorno de desarrollo de manera consistente.

Entendiendo Variables de Entorno Importantes

Linux tiene varias variables de entorno integradas que son cruciales para el funcionamiento del sistema. Exploremos algunas de ellas:

HOME: Apunta al directorio personal del usuario actual.
```
echo $HOME
```
USER: Contiene el nombre de usuario del usuario actual.
```
echo $USER
```
SHELL: Especifica la shell por defecto del usuario.
```
echo $SHELL
```
PWD: Significa "Print Working Directory" (Imprimir Directorio de Trabajo). Contiene la ruta del directorio actual.
```
echo $PWD
```
TERM: Especifica el tipo de terminal a emular al ejecutar la shell.
```
echo $TERM
```

Comprender estas variables puede ayudarte a navegar y controlar mejor tu entorno Linux.

Eliminando Variables de Entorno

A veces, es posible que necesites eliminar una variable de entorno. Esto se hace mediante el comando unset.

Primero, verifiquemos si nuestra variable MY_ENV_VAR todavía está configurada:
```
echo $MY_ENV_VAR
```
Deberías ver el valor que configuramos anteriormente.
Para eliminar (desconfigurar) esta variable, usa el comando unset:
```
unset MY_ENV_VAR
```
Verifica que la variable haya sido eliminada:
```
echo $MY_ENV_VAR
```
No deberías ver ninguna salida, lo que indica que la variable ya no existe.
También puedes usar la opción -v con unset para asegurarte de que estás eliminando una variable y no una función de la shell:
```
unset -v MY_ENV_VAR
```
Esto tendrá el mismo resultado que ejecutar simplemente unset MY_ENV_VAR.

Recuerda que si has añadido la variable a tu archivo .zshrc, se volverá a crear la próxima vez que abras una terminal o ejecutes source sobre el archivo .zshrc.

Resumen

¡Felicidades! Has completado este laboratorio integral sobre las variables de entorno de Linux. Repasemos lo que has aprendido:

Creaste y accediste a variables de shell simples, comprendiendo su alcance.
Aprendiste sobre las variables de entorno y en qué se diferencian de las variables de shell, particularmente en su accesibilidad para los procesos hijos, y cómo el comando export es clave para esto.
Modificaste la importante variable PATH para incluir un directorio personalizado, lo que te permite ejecutar scripts desde cualquier lugar del sistema, y aprendiste la importancia de usar los dos puntos : para separar las entradas.
Hiciste que las variables de entorno fueran permanentes añadiéndolas a .zshrc, comprendiendo la diferencia entre las configuraciones de shell Bash y Zsh, y la importancia de usar source para aplicar los cambios.
Exploraste algunas de las variables de entorno integradas más importantes en Linux.
Finalmente, aprendiste cómo eliminar variables de entorno usando el comando unset.

Estas habilidades son fundamentales para la administración de sistemas Linux y el desarrollo de software. Las variables de entorno te permiten configurar tu sistema y aplicaciones de manera flexible. A medida que continúes trabajando con Linux, encontrarás innumerables usos para las variables de entorno en scripting, desarrollo y configuración del sistema.

Recuerda, la práctica hace al maestro. Intenta crear tus propias variables de entorno para diferentes propósitos y explora cómo diversas aplicaciones y scripts las utilizan para controlar su comportamiento. ¡Feliz aprendizaje!