Variables de entorno en Linux: Desde los conceptos básicos 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 en ejecución 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 cómo crear, ver, modificar y eliminar variables de entorno. También exploraremos cómo hacer estos cambios permanentes y entender algunas de las variables de entorno integradas más importantes en Linux. Ya seas un principiante o estés buscando consolidar tu comprensión, este laboratorio te proporcionará una valiosa experiencia práctica.

¡Comencemos!

Comprender las variables en Linux

Antes de profundizar en las variables de entorno, comencemos con las variables básicas de shell. Esto te ayudará a entender el concepto de variables en Linux.

Abre tu terminal. Debes estar en el directorio /home/labex/project. Si no lo estás, puedes cambiar a este directorio utilizando el siguiente comando:
```
cd /home/labex/project
```
Ahora, creemos una simple variable de shell. 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: Cuando se asignan variables en Bash (y Zsh, que estamos utilizando en este laboratorio), no debe haber espacios alrededor del signo igual (=). my_var = "Hello, Linux" o my_var= "Hello, Linux" causará un error.
Para ver el valor de la variable, usamos el comando echo con un $ antes del nombre de la variable. El $ le dice al shell que sustituya 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á la salida: 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 de shell actual. Si abres una nueva ventana o pestaña de terminal, esta variable no estará disponible allí. Aquí es donde las variables de entorno son ú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 del shell. Esto significa que pueden ser accedidas por scripts y programas ejecutados desde ese shell.

Para ver todas las variables de entorno actuales, utiliza el comando env:
```
env
```
Esto mostrará una larga lista de variables. No te preocupes si aún no entiendes todas ellas; cubriremos algunas de las más importantes más adelante.
Una de las variables de entorno más importantes es PATH. Echemos un vistazo a ella:
```
echo $PATH
```
La variable PATH enumera los directorios donde el sistema busca programas ejecutables. Cada directorio está separado por dos puntos (:).
Ahora, creemos 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, creemos un script de shell que intente acceder tanto a una variable de shell normal como a una variable de entorno:
```
echo '#!/bin/bash
echo "Shell variable: $my_var"
echo "Environment variable: $MY_ENV_VAR"' > test_vars.sh
```
Haz el script ejecutable:
```
chmod +x test_vars.sh
```
Ahora ejecuta el script:
```
./test_vars.sh
```
Deberías ver 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 se exportó, 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 comprobar directamente el valor de tu nueva variable de entorno:
```
echo $MY_ENV_VAR
```

¡Excelente! Ahora has creado tu primera variable de entorno y has visto cómo se diferencia de una variable de shell. La diferencia clave 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"), se vuelve disponible para cualquier subproceso iniciado desde ese shell (por ejemplo, un script de shell ejecutado por ese mismo shell). Sin embargo, si abres una sesión de shell completamente separada, no hereda las variables de tu shell actual a menos que las establezcas específicamente en un archivo de inicio (como .zshrc o .bashrc).

En otras palabras:

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

No puedes leer directamente las variables de otro usuario o de otro shell porque cada proceso mantiene su propio entorno. Si inicias un nuevo shell, obtiene una copia de las variables exportadas del padre, pero no las variables establecidas solo en el shell original sin export.

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

Modificar la variable de entorno PATH

La variable PATH es una de las variables de entorno más importantes en Linux. Le dice al sistema dónde buscar archivos ejecutables. Modifiquémosla para incluir un nuevo directorio.

Primero, creemos un nuevo directorio donde podamos almacenar scripts personalizados:
```
mkdir ~/my_scripts
```
Esto crea un directorio llamado my_scripts en tu directorio de usuario. El símbolo ~ es un atajo para la ruta de tu directorio de usuario, que es /home/labex en este laboratorio.
Ahora, agreguemos este nuevo directorio a tu PATH. Usaremos el comando export, pero esta vez estamos modificando una variable existente:
```
export PATH="$PATH:$HOME/my_scripts"
```
Desglosemos esto:
- $PATH es el valor actual de la variable de entorno PATH. Estamos utilizando el valor existente y agregando a él.
- : se utiliza para separar directorios en el PATH. Si omites los dos puntos, el shell no podrá encontrar ejecutables en el directorio que agregaste.
- $HOME es una variable de entorno que apunta a tu directorio de usuario (nuevamente, /home/labex en nuestro caso).
- Entonces, estamos anexando :$HOME/my_scripts al PATH existente. Esto le dice al sistema que busque ejecutables en my_scripts después de buscar en los directorios del PATH original.
Verifica que se haya agregado el nuevo directorio:
```
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, pero aún debes tener la ruta /home/labex/my_scripts en tu PATH.
Para probar esto, creemos un simple script en nuestro nuevo directorio:
```
echo '#!/bin/bash
echo "Hello from my custom script!"' > ~/my_scripts/hello.sh
```
Esto crea un script de shell llamado hello.sh en el directorio ~/my_scripts. La primera línea, #!/bin/bash le dice al sistema que este es un script de bash, lo que permite que se ejecute como un programa.
Haz el script ejecutable:
```
chmod +x ~/my_scripts/hello.sh
```
El comando chmod +x agrega permisos de ejecución al script, lo que permite que se ejecute como un programa. Si no realizas este paso, obtendrás un error de "permiso denegado" cuando intentes 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 agregamos el directorio my_scripts al PATH. Cuando escribes un comando, el shell busca un archivo ejecutable con ese nombre en cada uno de los directorios enumerados en el PATH, en orden. Al agregar my_scripts al PATH, le hemos dicho al shell que busque allí también para encontrar ejecutables.

Para demostrar esto, intenta cambiar a un directorio diferente y ejecutar el script nuevamente:

cd /tmp
hello.sh

Verás que el script sigue ejecutándose, incluso aunque no estés en el directorio donde se encuentra. Este es el poder de la variable PATH: te permite ejecutar ejecutables desde cualquier lugar del sistema, siempre y cuando estén en un directorio enumerado en el PATH.

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

Hacer que las variables de entorno sean permanentes

Las variables de entorno que hemos establecido se perderán cuando cierres la terminal. Para hacerlas permanentes, debemos agregarlas a un archivo de configuración de shell. El archivo exacto depende del shell que estés utilizando.

En este entorno de laboratorio, estamos utilizando el Z shell (zsh), que es una versión extendida del 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 el shell predeterminado en macOS.

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

Abre el archivo .zshrc en tu directorio de usuario con un editor de texto. Utilizaremos nano, que es un simple editor de texto basado en terminal:
```
nano ~/.zshrc
```
Este comando abre el archivo ~/.zshrc, donde ~ es nuevamente un atajo para tu directorio de usuario /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 agrega las siguientes líneas:
```
export MY_ENV_VAR="This is an environment variable"
export PATH="$PATH:$HOME/my_scripts"
```
Asegúrate de agregar estas líneas al final del archivo. Asegúrate de que la ortografía y la sintaxis sean correctas, especialmente de que no haya espacios alrededor del signo =.
Guarda el archivo y cierra el editor. En nano, lo haces presionando Ctrl+X, luego Y (para guardar) y luego Enter.
Para aplicar estos cambios sin reiniciar tu terminal, utiliza el comando source:
```
source ~/.zshrc
```
El comando source lee y ejecuta comandos del archivo especificado como argumento en el entorno de shell actual. Esto es diferente a simplemente ejecutar el archivo utilizando bash ~/.zshrc, que ejecutaría el script en un nuevo shell y no afectaría al actual. source lo ejecuta en el shell actual para que tus cambios surtan efecto inmediatamente. Si omites este paso, tus cambios no surtirán efecto en tu terminal actual y tendrás que cerrarla y abrirla nuevamente para ver los cambios.

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

Comprender las 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 de usuario del usuario actual.
```
echo $HOME
```
USER: Contiene el nombre de usuario del usuario actual.
```
echo $USER
```
SHELL: Especifica el shell predeterminado 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 cuando se ejecuta el shell.
```
echo $TERM
```

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

Eliminar variables de entorno

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

Primero, comprobemos si nuestra variable MY_ENV_VAR sigue establecida:
```
echo $MY_ENV_VAR
```
Deberías ver el valor que establecimos anteriormente.
Para eliminar esta variable, utiliza el comando unset:
```
unset MY_ENV_VAR
```
Verifica que la variable se haya eliminado:
```
echo $MY_ENV_VAR
```
No deberías ver ninguna salida, lo que indica que la variable ya no existe.
También puedes utilizar la opción -v con unset para asegurarte de que estás eliminando una variable y no una función de shell:
```
unset -v MY_ENV_VAR
```
Esto tendrá el mismo resultado que simplemente ejecutar unset MY_ENV_VAR.

Recuerda, si has agregado la variable a tu archivo .zshrc, se recreará la próxima vez que abras una terminal o ejecutes el comando source en el archivo .zshrc.

Resumen

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

Has creado y accedido a variables simples de shell, comprendiendo su alcance.
Has aprendido sobre las variables de entorno y cómo se diferencian de las variables de shell, especialmente en su accesibilidad para los procesos hijos, y cómo el comando export es fundamental para esto.
Has modificado la importante variable PATH para incluir un directorio personalizado, lo que te permite ejecutar scripts desde cualquier lugar del sistema, y la importancia de usar los dos puntos : para separar las entradas.
Has hecho que las variables de entorno sean permanentes agregándolas al archivo .zshrc, comprendiendo la diferencia entre las configuraciones de los shells Bash y Zsh, y la importancia de usar el comando source para aplicar los cambios.
Has explorado algunas de las variables de entorno integradas más importantes en Linux.
Finalmente, has aprendido cómo eliminar variables de entorno utilizando 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 sigas trabajando con Linux, encontrarás innumerables usos para las variables de entorno en la escritura de scripts, el desarrollo y la configuración del sistema.

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