Ejecución de scripts en Linux

Introducción

Este laboratorio se centra en comprender y utilizar el comando source en Linux, una herramienta potente para ejecutar scripts directamente en la shell actual. A diferencia de la ejecución normal de scripts, que se realiza en un subproceso independiente, el comando source ejecuta los comandos de un archivo dentro del entorno de la shell actual. Esto permite que las variables y funciones definidas en el script persistan en tu sesión actual.

A lo largo de este laboratorio, aprenderás:

Cómo crear y ejecutar scripts utilizando el comando source.
Cómo pasar parámetros a los scripts al usar source.
En qué se diferencia el comando source de la ejecución normal de scripts.
Cómo utilizar el comando source para configurar variables de entorno.

Al finalizar este laboratorio, te sentirás cómodo utilizando el comando source para una gestión eficiente de scripts y entornos en la shell de Linux.

Creación y ejecución de un script básico

En este paso, crearemos un archivo de script sencillo y utilizaremos el comando source para ejecutarlo en nuestro entorno de shell actual. Esto nos ayudará a entender cómo difiere source de la ejecución convencional de scripts.

Cuando ejecutas un script de forma normal (usando ./script.sh), la shell crea un nuevo subproceso para ejecutarlo. Cualquier variable o función definida en ese script solo existe dentro de ese subproceso y desaparece cuando el script finaliza. Sin embargo, cuando utilizas el comando source (o su abreviatura .), los comandos del script se ejecutan en tu entorno de shell actual, permitiendo que las variables y funciones persistan después de que el script termine.

Vamos a crear un script básico para demostrar este concepto:

1. Navegar al directorio del proyecto

Primero, asegúrate de estar en el directorio correcto:

cd ~/project

2. Crear un archivo de script sencillo

Crea un nuevo archivo llamado variables.sh usando el editor nano:

nano variables.sh

Añade el siguiente contenido al archivo:

#!/bin/bash
## This script sets an environment variable
export WEATHER="Sunny"
echo "The weather is now set to: $WEATHER"

Presiona Ctrl+O para guardar el archivo, luego Enter para confirmar el nombre y finalmente Ctrl+X para salir de nano.

3. Hacer que el script sea ejecutable

Antes de poder ejecutar el script, debemos darle permisos de ejecución:

chmod +x variables.sh

4. Ejecutar el script de forma normal

Primero, ejecutemos el script de la manera tradicional:

./variables.sh

Deberías ver una salida similar a esta:

The weather is now set to: Sunny

Ahora, verifica si la variable WEATHER existe en tu shell actual:

echo $WEATHER

Probablemente no verás ninguna salida o verás una línea vacía. Esto sucede porque la variable solo se definió en el subproceso que ejecutó el script, no en tu shell actual.

5. Ejecutar el script con source

Ahora, utilicemos el comando source para ejecutar el script:

source variables.sh

Verás la misma salida:

The weather is now set to: Sunny

Verifica la variable WEATHER nuevamente:

echo $WEATHER

Esta vez, deberías ver:

Sunny

La variable WEATHER ahora existe en tu shell actual porque utilizaste el comando source para ejecutar el script.

6. Uso de la notación abreviada

También puedes usar la notación abreviada de punto (.) para el comando source:

. ./variables.sh

Esto producirá el mismo resultado que usar source variables.sh. El prefijo ./ le indica a la shell que debe tomar el script desde el directorio actual.

Uso de source con parámetros

En este paso, aprenderemos cómo pasar parámetros a un script cuando usamos el comando source. Esto es útil cuando necesitas que tus scripts sean más flexibles y reutilizables.

Al igual que en la ejecución normal de scripts, puedes pasar argumentos a un script cuando usas el comando source. Dentro del script, estos argumentos son accesibles a través de los parámetros posicionales estándar ($1, $2, etc.), tal como lo serían al ejecutar el script directamente.

1. Crear un script que acepte parámetros

Crea un nuevo archivo llamado greeting.sh en el directorio ~/project:

cd ~/project
nano greeting.sh

Añade el siguiente contenido al archivo:

#!/bin/bash
## This script accepts a name parameter and sets a greeting variable

## Check if a parameter was provided
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Set the greeting environment variable
export GREETING="Hello, $NAME!"
echo "$GREETING"

Guarda y sal de nano presionando Ctrl+O, Enter y luego Ctrl+X.

2. Hacer que el script sea ejecutable

chmod +x greeting.sh

3. Ejecutar el script con source y un parámetro

Vamos a ejecutar el script con source y pasarle un nombre como parámetro:

source greeting.sh "Alice"

Deberías ver la salida:

Hello, Alice!

Ahora verifica si la variable GREETING está definida en tu shell actual:

echo $GREETING

Deberías ver:

Hello, Alice!

4. Ejecutar con source usando un parámetro diferente

Intenta ejecutar el script nuevamente con un nombre distinto:

source greeting.sh "Bob"

Salida:

Hello, Bob!

Verifica la variable GREETING de nuevo:

echo $GREETING

Salida:

Hello, Bob!

Observa cómo la variable GREETING se ha actualizado con el nuevo valor.

5. Ejecutar con source sin parámetros

También puedes ejecutar el script con source sin ningún parámetro:

source greeting.sh

Salida:

Hello, Guest!

El script utiliza un valor predeterminado ("Guest") cuando no se proporciona ningún parámetro.

Verifica la variable GREETING una vez más:

echo $GREETING

Salida:

Hello, Guest!

Esto demuestra cómo puedes hacer que tus scripts sean adaptables procesando diferentes parámetros de entrada.

Creación de un script de entorno de desarrollo

En este paso, crearemos un ejemplo más práctico: un script que configura un entorno de desarrollo con múltiples variables. Este es un caso de uso común para el comando source en escenarios del mundo real.

1. Crear el script de entorno de desarrollo

Crea un nuevo archivo llamado dev_env.sh en el directorio ~/project:

cd ~/project
nano dev_env.sh

Añade el siguiente contenido al archivo:

#!/bin/bash
## Development environment setup script

## Database connection settings
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## API settings
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Application paths
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Create directories if they don't exist
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Display confirmation message
echo "Development environment configured with the following settings:"
echo "-----------------------------------------------------------"
echo "Database: $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "API URL: $API_URL"
echo "App Root: $APP_ROOT"
echo "Log Directory: $LOG_DIR"
echo "-----------------------------------------------------------"
echo "Environment is ready for development!"

Guarda y sal de nano presionando Ctrl+O, Enter y luego Ctrl+X.

2. Hacer que el script sea ejecutable

chmod +x dev_env.sh

3. Ejecutar el script de entorno de desarrollo con source

Ahora, ejecutemos el script con source para configurar nuestro entorno de desarrollo:

source dev_env.sh

Deberías ver una salida similar a esta:

Development environment configured with the following settings:
-----------------------------------------------------------
Database: dev_user@localhost:5432/dev_database
API URL: http://localhost:3000/api
App Root: /home/labex/project/app
Log Directory: /home/labex/project/logs
-----------------------------------------------------------
Environment is ready for development!

4. Verificar que las variables de entorno estén configuradas

Comprobemos algunas de las variables de entorno que fueron configuradas por el script:

echo "Database connection string: $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Salida:

Database connection string: dev_user:dev_password@localhost:5432/dev_database

Verifica la configuración de la API:

echo "API settings: $API_URL with key $API_KEY"

Salida:

API settings: http://localhost:3000/api with key dev_api_key_123

5. Verificar que los directorios fueron creados

Comprueba si los directorios especificados en el script fueron creados:

ls -la ~/project/app ~/project/logs

Deberías ver una salida que confirma que ambos directorios existen.

Este ejemplo demuestra cómo puedes usar el comando source para configurar un entorno de desarrollo completo con múltiples variables de entorno y configuraciones. Este enfoque se utiliza habitualmente en flujos de trabajo de desarrollo para alternar entre diferentes entornos (desarrollo, pruebas, producción, etc.).

Resumen

En este laboratorio, has aprendido a utilizar el comando source en Linux para ejecutar scripts en el entorno de la shell actual. Aquí tienes un resumen de lo que has logrado:

Creación y ejecución de scripts básicos: Aprendiste cómo difiere el uso de source de la ejecución normal de scripts, ya que permite que las variables y funciones definidas en el script persistan en tu sesión de shell actual.
Paso de parámetros a scripts con source: Exploraste cómo hacer que los scripts sean más flexibles pasando parámetros al usar el comando source, y cómo procesar esos parámetros dentro del script.
Configuración de entornos de desarrollo: Creaste un script práctico que configura un entorno de desarrollo con múltiples variables de entorno y configuraciones, un caso de uso real muy común para el comando source.

El comando source es una herramienta poderosa en el scripting de Linux que te permite:

Establecer variables de entorno que persisten durante toda tu sesión de shell.
Definir funciones que pueden utilizarse más adelante en tu sesión.
Crear configuraciones modulares que pueden reutilizarse.
Configurar entornos complejos de forma rápida y consistente.

Estas habilidades son fundamentales para cualquier persona que trabaje con sistemas Linux, especialmente para desarrolladores, administradores de sistemas e ingenieros DevOps. Al dominar el comando source, podrás crear scripts más eficientes y organizados para gestionar tu entorno Linux.