Exportación de variables en Linux

Introducción

Las variables de entorno desempeñan un papel crucial en los sistemas operativos Linux. Son valores dinámicos que afectan a los procesos que se ejecutan en el sistema. En este laboratorio, exploraremos cómo utilizar el comando export en Linux para crear y gestionar variables de entorno.

Las variables de entorno se utilizan en muchos escenarios, como el almacenamiento de información de configuración, la comunicación entre procesos y la definición de ajustes a nivel de sistema. Comprender cómo trabajar con variables de entorno es una habilidad esencial para cualquier usuario o administrador de sistemas Linux.

Este laboratorio te guiará a través de los conceptos básicos de configuración de variables, su exportación para que estén disponibles para los procesos secundarios (hijos) y su uso en scripts de bash. Aprenderás cómo estas variables pueden utilizarse para crear aplicaciones más dinámicas y configurables.

Comprender las variables básicas en Linux

En este paso, aprenderás los conceptos básicos sobre la creación y el uso de variables en un entorno de shell de Linux.

En Linux, las variables se utilizan para almacenar datos que pueden ser referenciados y manipulados por comandos y scripts. Una variable es simplemente un nombre que representa un valor.

Comencemos creando una variable sencilla en tu shell:

name="LinuxLearner"

Este comando crea una variable llamada name y le asigna el valor "LinuxLearner". Ten en cuenta que no debe haber espacios alrededor del signo igual al asignar valores a las variables.

Para mostrar el valor de una variable, utiliza el comando echo seguido del nombre de la variable precedido por un signo de dólar ($):

echo $name

Deberías ver la siguiente salida:

LinuxLearner

También puedes utilizar variables dentro de cadenas de texto:

echo "Hello, $name!"

Salida:

Hello, LinuxLearner!

Ahora, crea otra variable para almacenar tu color favorito:

color="blue"

Y muestra un mensaje utilizando ambas variables:

echo "Hello $name, I see your favorite color is $color."

Salida:

Hello LinuxLearner, I see your favorite color is blue.

Estas variables que has creado se denominan "variables de shell" o "variables locales". Solo están disponibles en la sesión de shell actual. En el siguiente paso, aprenderemos cómo hacer que las variables estén disponibles para otros procesos utilizando el comando export.

Exportar variables como variables de entorno

En el paso anterior, creaste variables de shell que solo están disponibles en tu sesión actual. En este paso, aprenderás a utilizar el comando export para convertir una variable de shell en una variable de entorno que estará disponible para los procesos secundarios.

Primero, comprendamos la diferencia:

Variable de shell: Disponible solo en la shell actual.
Variable de entorno: Disponible en la shell actual y en todos sus procesos secundarios.

Para demostrar esto, creemos una nueva variable de shell:

greeting="Welcome to Linux"

Ahora, creemos un nuevo script de shell que intente acceder a esta variable. Abre un editor de texto y crea un archivo llamado test_var.sh en el directorio ~/project:

cd ~/project
nano test_var.sh

Añade el siguiente contenido al archivo:

#!/bin/bash
echo "The greeting is: $greeting"

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Haz que el script sea ejecutable:

chmod +x ~/project/test_var.sh

Ahora, ejecuta el script:

~/project/test_var.sh

Verás la siguiente salida:

The greeting is:

Observa que el valor de la variable no se muestra porque las variables de shell no se pasan a los procesos secundarios.

Para que esta variable esté disponible para el script, debes exportarla:

export greeting="Welcome to Linux"

Ahora ejecuta el script de nuevo:

~/project/test_var.sh

Esta vez, deberías ver:

The greeting is: Welcome to Linux

¡Felicidades! Has exportado correctamente una variable, convirtiéndola en una variable de entorno a la que pueden acceder otros procesos.

Puedes comprobar todas las variables de entorno actuales utilizando el comando env:

env

Esto mostrará una lista de todas las variables de entorno en tu sesión actual.

También puedes comprobar una variable de entorno específica con el comando echo:

echo $greeting

Ahora, creemos y exportemos otra variable de entorno:

export USER_LEVEL="beginner"

Ejecuta el siguiente comando para verificar que se ha configurado:

echo $USER_LEVEL

Salida:

beginner

Crear scripts que utilicen variables de entorno

En este paso, aprenderás a crear y ejecutar scripts que utilizan variables de entorno para la configuración. Esta es una práctica común en el desarrollo de software para hacer que las aplicaciones sean más flexibles y configurables sin necesidad de cambiar el código.

Primero, creemos un script que utilice variables de entorno para personalizar su salida. Crea un nuevo archivo llamado greet.sh en el directorio ~/project:

cd ~/project
nano greet.sh

Añade el siguiente contenido al archivo:

#!/bin/bash
## This script demonstrates using environment variables

## Default values if environment variables are not set
DEFAULT_NAME="Guest"
DEFAULT_LANGUAGE="English"

## Use environment variables or default values
USER_NAME=${USER_NAME:-$DEFAULT_NAME}
LANGUAGE=${LANGUAGE:-$DEFAULT_LANGUAGE}

## Greet based on language
if [ "$LANGUAGE" = "English" ]; then
  echo "Hello, $USER_NAME! Welcome to the Linux learning environment."
elif [ "$LANGUAGE" = "Spanish" ]; then
  echo "Hola, $USER_NAME! Bienvenido al entorno de aprendizaje de Linux."
elif [ "$LANGUAGE" = "French" ]; then
  echo "Bonjour, $USER_NAME! Bienvenue dans l'environnement d'apprentissage Linux."
else
  echo "Hello, $USER_NAME! Welcome to the Linux learning environment."
fi

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Haz que el script sea ejecutable:

chmod +x ~/project/greet.sh

Ahora, ejecuta el script sin configurar ninguna variable de entorno:

~/project/greet.sh

Salida:

Hello, Guest! Welcome to the Linux learning environment.

El script utilizó los valores predeterminados ya que no se configuró ninguna variable de entorno. Vamos a configurar algunas variables de entorno y ejecutar el script de nuevo:

export USER_NAME="LinuxExplorer"
export LANGUAGE="Spanish"

Ahora ejecuta el script de nuevo:

~/project/greet.sh

Salida:

Hola, LinuxExplorer! Bienvenido al entorno de aprendizaje de Linux.

Observa cómo la salida del script cambió según las variables de entorno que configuramos. Esto demuestra cómo se pueden utilizar las variables de entorno para configurar el comportamiento de la aplicación sin modificar el código.

Probemos con otro idioma:

export LANGUAGE="French"
~/project/greet.sh

Salida:

Bonjour, LinuxExplorer! Bienvenue dans l'environnement d'apprentissage Linux.

Este enfoque se utiliza ampliamente en la configuración de software para hacer que las aplicaciones sean más flexibles y adaptables a diferentes entornos.

Uso avanzado y variables de entorno temporales

En este paso, aprenderás a configurar variables de entorno para un solo comando sin cambiar el entorno global, y cómo implementar un uso más avanzado de las variables de entorno.

Configurar variables de entorno para un solo comando

A veces, solo deseas configurar una variable de entorno para un único comando. Puedes hacerlo anteponiendo al comando las asignaciones de variables de entorno:

LANGUAGE="Spanish" ~/project/greet.sh

Observa que el script se ejecuta con la configuración de idioma español, pero la variable de entorno global no ha cambiado:

echo $LANGUAGE

Salida:

French

Esto se debe a que la variable de entorno solo se configuró durante la ejecución del comando.

Variables de entorno en un escenario del mundo real

Creemos un ejemplo más práctico: un script de configuración para una aplicación hipotética. Crea un nuevo archivo llamado app_config.sh:

cd ~/project
nano app_config.sh

Añade el siguiente contenido:

#!/bin/bash
## Application configuration script

## Display the current configuration
echo "Current Application Configuration:"
echo "--------------------------------"
echo "App Name: ${APP_NAME:-Unknown}"
echo "App Version: ${APP_VERSION:-0.0.0}"
echo "Log Level: ${LOG_LEVEL:-INFO}"
echo "Database URL: ${DB_URL:-localhost:5432}"
echo "API Key: ${API_KEY:-not set}"
echo "--------------------------------"

## Check if required configurations are set
if [[ -z "$APP_NAME" ]]; then
  echo "WARNING: APP_NAME is not set. Some features may not work properly."
fi

if [[ -z "$API_KEY" ]]; then
  echo "WARNING: API_KEY is not set. API functionality will be limited."
fi

## Validate log level
valid_log_levels=("DEBUG" "INFO" "WARNING" "ERROR" "CRITICAL")
log_level=${LOG_LEVEL:-INFO}
valid=false

for level in "${valid_log_levels[@]}"; do
  if [[ "$level" == "$log_level" ]]; then
    valid=true
    break
  fi
done

if [[ "$valid" == false ]]; then
  echo "ERROR: Invalid LOG_LEVEL '$log_level'. Must be one of: ${valid_log_levels[*]}"
  exit 1
fi

echo "Configuration validation complete."

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Haz que el script sea ejecutable:

chmod +x ~/project/app_config.sh

Ahora, ejecuta el script sin configurar ninguna variable de entorno:

~/project/app_config.sh

Deberías ver advertencias sobre configuraciones faltantes.

Ahora, configura todas las variables de entorno requeridas y ejecuta el script de nuevo:

export APP_NAME="MyAwesomeApp"
export APP_VERSION="1.0.0"
export LOG_LEVEL="DEBUG"
export DB_URL="postgres://user:password@dbserver:5432/mydb"
export API_KEY="abc123xyz456"

~/project/app_config.sh

Deberías ver todos los valores de configuración mostrados correctamente sin ninguna advertencia.

Intenta configurar un nivel de registro (log level) no válido:

export LOG_LEVEL="VERBOSE"
~/project/app_config.sh

El script debería mostrar un mensaje de error por el nivel de registro no válido.

Este ejemplo demuestra cómo se pueden utilizar las variables de entorno para la configuración de aplicaciones, incluyendo validación y valores predeterminados.

Hacer que las variables de entorno sean persistentes

Hasta ahora, hemos configurado variables de entorno que solo duran durante la sesión de terminal actual. Una vez que cierras la terminal o cierras sesión, estas variables se pierden. En este paso, aprenderás a hacer que las variables de entorno sean persistentes entre sesiones.

Almacenar variables de entorno en archivos de configuración

Existen varios archivos donde puedes configurar variables de entorno para hacerlas persistentes:

~/.bashrc o ~/.zshrc: Para variables específicas de un usuario.
/etc/environment: Para variables a nivel de sistema.
/etc/profile o archivos en /etc/profile.d/: Para variables a nivel de sistema cargadas al iniciar sesión.

Añadamos algunas variables de entorno al archivo de configuración de shell de tu usuario. Dado que este entorno de laboratorio utiliza ZSH, editaremos el archivo ~/.zshrc:

nano ~/.zshrc

Desplázate hasta el final del archivo y añade las siguientes líneas:

## Custom environment variables
export EDITOR="nano"
export CUSTOM_PATH="$HOME/bin"
export GREETING="Hello from .zshrc!"

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Para aplicar estos cambios a tu sesión actual, debes cargar el archivo (source):

source ~/.zshrc

Ahora, comprueba si las variables están configuradas:

echo $EDITOR
echo $CUSTOM_PATH
echo $GREETING

Deberías ver los valores que configuraste en el archivo .zshrc.

Estas variables de entorno estarán disponibles cada vez que inicies una nueva sesión de shell.

Crear un archivo de variables de entorno personalizado

Una buena práctica para gestionar variables de entorno es crear un archivo separado solo para ellas, especialmente para variables específicas de un proyecto. Esto facilita la gestión y el intercambio de configuraciones.

Creemos un archivo llamado .env en tu directorio de proyecto:

cd ~/project
nano .env

Añade el siguiente contenido:

## Project environment variables
export PROJECT_NAME="Linux Environment Lab"
export PROJECT_VERSION="1.0.0"
export DEBUG_MODE="true"

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Para cargar estas variables en tu sesión actual, carga el archivo:

source ~/project/.env

Ahora comprueba si las variables están configuradas:

echo $PROJECT_NAME
echo $PROJECT_VERSION
echo $DEBUG_MODE

Deberías ver los valores del archivo .env.

Crear un script para cargar variables de entorno

Finalmente, creemos un script que cargue variables de entorno desde un archivo. Este es un patrón común en entornos de desarrollo:

cd ~/project
nano load_env.sh

Añade el siguiente contenido:

#!/bin/bash
## Script to load environment variables from a .env file

ENV_FILE=".env"

if [[ -f "$ENV_FILE" ]]; then
  echo "Loading environment variables from $ENV_FILE"

  ## Read each line from the .env file
  while IFS= read -r line || [[ -n "$line" ]]; do
    ## Skip comments and empty lines
    if [[ $line =~ ^## ]] || [[ -z $line ]]; then
      continue
    fi

    ## Export the variable if it starts with "export "
    if [[ $line == export* ]]; then
      ## Remove the "export " prefix and export the variable
      eval "${line}"
      echo "Exported: ${line#export }"
    fi
  done < "$ENV_FILE"

  echo "Environment variables loaded successfully"
else
  echo "Error: $ENV_FILE file not found"
  exit 1
fi

Guarda el archivo (presiona Ctrl+O, luego Enter) y sal de nano (presiona Ctrl+X).

Haz que el script sea ejecutable:

chmod +x ~/project/load_env.sh

Ahora, elimina las variables que configuramos anteriormente y luego ejecuta el script para cargarlas de nuevo:

unset PROJECT_NAME PROJECT_VERSION DEBUG_MODE
echo "PROJECT_NAME: $PROJECT_NAME"

## Now load the variables using the script
~/project/load_env.sh

## Check if the variables are now set
echo "PROJECT_NAME: $PROJECT_NAME"

El script lee el archivo .env y exporta cada variable definida con la palabra clave export.

Este enfoque se utiliza comúnmente en entornos de desarrollo para gestionar variables de entorno específicas del proyecto.

Resumen

En este laboratorio, has aprendido los conceptos esenciales para trabajar con variables de entorno en Linux:

Variables básicas: Aprendiste a crear y utilizar variables de shell en la sesión actual.
Variables de entorno: Descubriste cómo utilizar el comando export para convertir variables de shell en variables de entorno a las que pueden acceder los procesos secundarios.
Uso de variables en scripts: Creaste scripts que leen y utilizan variables de entorno para personalizar su comportamiento sin cambiar el código.
Uso avanzado: Exploraste técnicas avanzadas como la configuración de variables para un solo comando y la validación de valores de variables en scripts.
Variables persistentes: Aprendiste a hacer que las variables de entorno sean persistentes añadiéndolas a archivos de configuración y creando scripts de utilidad para cargarlas.

Las variables de entorno son una característica poderosa en Linux que te permite configurar aplicaciones, compartir datos entre procesos y personalizar tu entorno. Se utilizan ampliamente en el desarrollo de software, la administración de sistemas y el despliegue de aplicaciones.

Al dominar las variables de entorno, has adquirido una habilidad importante que te será de gran utilidad en tu trayectoria en Linux, desde proyectos personales hasta la administración de sistemas a nivel empresarial.