Exportación de variables en Linux

LinuxBeginner
Practicar Ahora

Introducción

Las variables de entorno juegan 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 (lab), 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 configuraciones a nivel de sistema. Comprender cómo trabajar con variables de entorno es una habilidad esencial para cualquier usuario de Linux o administrador de sistemas.

Este laboratorio (lab) lo guiará a través de los conceptos básicos de configuración de variables, de exportarlas para que estén disponibles para los procesos hijos y de utilizarlas en scripts de bash. Aprenderá cómo se pueden utilizar estas variables para crear aplicaciones más dinámicas y configurables.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel intermedio con una tasa de finalización del 72%. Ha recibido una tasa de reseñas positivas del 89% por parte de los estudiantes.

Comprendiendo las variables básicas en Linux

En este paso, aprenderá los conceptos básicos de creación y 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 simple en su shell:

name="LinuxLearner"

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

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

echo $name

Debería ver la salida:

LinuxLearner

También puede usar variables dentro de cadenas:

echo "Hello, $name!"

Salida:

Hello, LinuxLearner!

Ahora, cree otra variable para almacenar su color favorito:

color="blue"

Y muestre 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 ha creado se llaman "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 de shell actual. En este paso, aprenderás cómo utilizar el comando export para convertir una variable de shell en una variable de entorno que estará disponible para los procesos hijos.

Comencemos por entender la diferencia:

  • Variable de shell: Solo está disponible en la shell actual.
  • Variable de entorno: Está disponible para la shell actual y todos sus procesos hijos.

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

Agrega 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 el script 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 hijos.

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

export greeting="Welcome to Linux"

Ahora ejecuta el script nuevamente:

~/project/test_var.sh

Esta vez, deberías ver:

The greeting is: Welcome to Linux

¡Felicidades! Has exportado con éxito una variable, convirtiéndola en una variable de entorno que puede ser accedida por otros procesos.

Puedes verificar 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 verificar 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 haya establecido:

echo $USER_LEVEL

Salida:

beginner

Crear scripts que usen variables de entorno

En este paso, aprenderás cómo 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 cambiar el código.

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

cd ~/project
nano greet.sh

Agrega el siguiente contenido al archivo:

#!/bin/bash
## Este script demuestra el uso de variables de entorno

## Valores predeterminados si las variables de entorno no están establecidas
DEFAULT_NAME="Guest"
DEFAULT_LANGUAGE="English"

## Utilizar variables de entorno o valores predeterminados
USER_NAME=${USER_NAME:-$DEFAULT_NAME}
LANGUAGE=${LANGUAGE:-$DEFAULT_LANGUAGE}

## Saludar según el idioma
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 el script ejecutable:

chmod +x ~/project/greet.sh

Ahora, ejecuta el script sin establecer 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 establecieron variables de entorno. Establezcamos algunas variables de entorno y ejecutemos el script nuevamente:

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

Ahora ejecuta el script nuevamente:

~/project/greet.sh

Salida:

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

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

Intentemos 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 cómo establecer 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.

Establecer variables de entorno para un solo comando

A veces, solo quieres establecer una variable de entorno para un solo comando. Puedes hacer esto prefijando el comando con 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 estableció durante la duració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

Agrega el siguiente contenido:

#!/bin/bash
## Script de configuración de la aplicación

## Mostrar la configuración actual
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 "--------------------------------"

## Verificar si se han establecido las configuraciones requeridas
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

## Validar el nivel de registro
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 el script ejecutable:

chmod +x ~/project/app_config.sh

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

~/project/app_config.sh

Deberías ver advertencias sobre configuraciones faltantes.

Ahora, establece todas las variables de entorno requeridas y ejecuta el script nuevamente:

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 correctamente mostrados sin ninguna advertencia.

Intenta establecer un nivel de registro no válido:

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

El script debe 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 una aplicación, con validación y valores predeterminados.

Hacer que las variables de entorno sean persistentes

Hasta ahora, hemos estado estableciendo variables de entorno que solo duran durante la sesión actual de la terminal. Una vez que cierras la terminal o te desconectas, estas variables se pierden. En este paso, aprenderás cómo hacer que las variables de entorno sean persistentes a través de sesiones.

Almacenar variables de entorno en archivos de configuración

Hay varios archivos donde puedes establecer variables de entorno para que sean persistentes:

  1. ~/.bashrc o ~/.zshrc: Para variables específicas de un usuario
  2. /etc/environment: Para variables de todo el sistema
  3. /etc/profile o archivos en /etc/profile.d/: Para variables de todo el sistema que se cargan al iniciar sesión

Vamos a agregar algunas variables de entorno al archivo de configuración de la shell del usuario. Dado que este entorno de laboratorio utiliza ZSH, editaremos el archivo ~/.zshrc:

nano ~/.zshrc

Desplázate hasta el final del archivo y agrega 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 "sourcear" (cargar) el archivo:

source ~/.zshrc

Ahora, verifica si las variables están establecidas:

echo $EDITOR
echo $CUSTOM_PATH
echo $GREETING

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

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

Crear un archivo personalizado para variables de entorno

Una buena práctica para gestionar las 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.

Vamos a crear un archivo llamado .env en tu directorio de proyecto:

cd ~/project
nano .env

Agrega 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, "sourcea" el archivo:

source ~/project/.env

Ahora verifica si las variables están establecidas:

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, vamos a crear 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

Agrega 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 el script ejecutable:

chmod +x ~/project/load_env.sh

Ahora, desestablece las variables que establecimos previamente y luego ejecuta el script para cargarlas nuevamente:

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 de un proyecto.

Resumen

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

  1. Variables básicas: Aprendiste cómo crear y usar variables de shell en la sesión actual.

  2. Variables de entorno: Descubriste cómo usar el comando export para convertir variables de shell en variables de entorno que pueden ser accedidas por procesos hijos.

  3. Uso de variables en scripts: Creaste scripts que leen y usan variables de entorno para personalizar su comportamiento sin cambiar el código.

  4. Uso avanzado: Exploraste técnicas avanzadas como establecer variables para un solo comando y validar valores de variables en scripts.

  5. Variables persistentes: Aprendiste cómo hacer que las variables de entorno sean persistentes agregá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. Son ampliamente utilizadas en el desarrollo de software, la administración de sistemas y la implementación de aplicaciones.

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