Ejecución de scripts en Linux

Introducción

Este laboratorio se centra en comprender y utilizar el comando source en Linux, que es una herramienta poderosa para ejecutar scripts en la shell actual. A diferencia de la ejecución regular de scripts que se ejecuta en un subproceso separado, el comando source ejecuta comandos de un archivo en el entorno de la shell actual. Esto permite que las variables y funciones definidas en el script persistan en su sesión actual.

A lo largo de este laboratorio, aprenderá:

• Cómo crear y ejecutar scripts utilizando el comando source
• Cómo pasar parámetros a los scripts cuando se utiliza source
• En qué se diferencia el comando source de la ejecución regular de scripts
• Cómo utilizar el comando source para configurar variables de entorno

Al final de este laboratorio, se sentirá cómodo utilizando el comando source para la programación eficiente de shells de Linux y la gestión de entornos.

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

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

Cuando se ejecuta un script normalmente (utilizando ./script.sh), la shell crea un nuevo subproceso para ejecutar el script. Cualquier variable o función definida en ese script solo existe dentro de ese subproceso y desaparece cuando el script finaliza. Sin embargo, cuando se utiliza el comando source (o su forma abreviada .), los comandos del script se ejecutan en el entorno de la shell actual, lo que permite que las variables y funciones persistan después de que el script se complete.

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

1. Navegar al directorio del proyecto

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

cd ~/project

2. Crear un archivo de script simple

Cree un nuevo archivo llamado variables.sh utilizando el editor nano:

nano variables.sh

Agregue el siguiente contenido al archivo:

#!/bin/bash
## Este script establece una variable de entorno
export WEATHER="Sunny"
echo "The weather is now set to: $WEATHER"

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

3. Hacer el script ejecutable

Antes de poder ejecutar el script, debemos hacer que sea ejecutable:

chmod +x variables.sh

4. Ejecutar el script normalmente

Primero, ejecutemos el script de la manera tradicional:

./variables.sh

Debería ver una salida similar a:

The weather is now set to: Sunny

Ahora, verifique si la variable WEATHER existe en su shell actual:

echo $WEATHER

Es probable que no vea nada o una línea en blanco. Esto se debe a que la variable solo se estableció en el subproceso que ejecutó el script, no en su shell actual.

5. Ejecutar el script con source

Ahora, usemos el comando source para ejecutar el script:

source variables.sh

Verá la misma salida:

The weather is now set to: Sunny

Verifique la variable WEATHER nuevamente:

echo $WEATHER

Esta vez, debería ver:

Sunny

La variable WEATHER ahora existe en su shell actual porque utilizó el comando source para ejecutar el script.

6. Usar la notación abreviada

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

. variables.sh

Esto producirá el mismo resultado que usar source variables.sh.

Uso de 'source' con parámetros

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

Al igual que en la ejecución regular 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 cuando se ejecuta 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

Agrega el siguiente contenido al archivo:

#!/bin/bash
## Este script acepta un parámetro de nombre y establece una variable de saludo

## Verificar si se proporcionó un parámetro
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Establecer la variable de entorno de saludo
export GREETING="Hello, $NAME!"
echo "$GREETING"

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

2. Hacer el script ejecutable

chmod +x greeting.sh

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

Vamos a ejecutar el script con source y pasar un parámetro de nombre:

source greeting.sh "Alice"

Deberías ver la salida:

Hello, Alice!

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

echo $GREETING

Deberías ver:

Hello, Alice!

4. Ejecutar el script con source y un parámetro diferente

Intenta ejecutar el script nuevamente con source y un nombre diferente:

source greeting.sh "Bob"

Salida:

Hello, Bob!

Verifica la variable GREETING nuevamente:

echo $GREETING

Salida:

Hello, Bob!

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

5. Ejecutar el script 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 para el 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. Creación del script del entorno de desarrollo

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

cd ~/project
nano dev_env.sh

Agrega el siguiente contenido al archivo:

#!/bin/bash
## Script de configuración del entorno de desarrollo

## Configuración de la conexión a la base de datos
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## Configuración de la API
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Rutas de la aplicación
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Crear directorios si no existen
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Mostrar mensaje de confirmación
echo "Entorno de desarrollo configurado con las siguientes opciones:"
echo "-----------------------------------------------------------"
echo "Base de datos: $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "URL de la API: $API_URL"
echo "Raíz de la aplicación: $APP_ROOT"
echo "Directorio de registros: $LOG_DIR"
echo "-----------------------------------------------------------"
echo "El entorno está listo para el desarrollo!"

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

2. Hacer el script ejecutable

chmod +x dev_env.sh

3. Ejecutar el script del 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:

Entorno de desarrollo configurado con las siguientes opciones:
-----------------------------------------------------------
Base de datos: dev_user@localhost:5432/dev_database
URL de la API: http://localhost:3000/api
Raíz de la aplicación: /home/labex/project/app
Directorio de registros: /home/labex/project/logs
-----------------------------------------------------------
El entorno está listo para el desarrollo!

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

Veamos algunas de las variables de entorno que se configuraron con el script:

echo "Cadena de conexión a la base de datos: $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Salida:

Cadena de conexión a la base de datos: dev_user:dev_password@localhost:5432/dev_database

Verifica la configuración de la API:

echo "Configuración de la API: $API_URL con la clave $API_KEY"

Salida:

Configuración de la API: http://localhost:3000/api con la clave dev_api_key_123

5. Verificar que se hayan creado los directorios

Comprueba si se crearon los directorios especificados en el script:

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

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

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

Resumen

En este laboratorio, has aprendido cómo usar el comando source en Linux para ejecutar scripts en el entorno de shell actual. Aquí está un resumen de lo que has logrado:

1. Creación y ejecución de scripts básicos con source: Aprendiste cómo la ejecución de un script con source difiere de la ejecución regular de un script, ya que permite que las variables y funciones definidas en el script persistan en tu sesión de shell actual.

2. Paso de parámetros a scripts ejecutados con source: Exploraste cómo hacer que los scripts sean más flexibles al pasarles parámetros cuando se utiliza el comando source, y cómo procesar esos parámetros dentro del script.

3. 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, que es un caso de uso común del mundo real para el comando source.

El comando source es una herramienta poderosa en la programación de scripts de Linux que te permite:

• Establecer variables de entorno que persistan a lo largo de tu sesión de shell.
• Definir funciones que se pueden utilizar más adelante en tu sesión.
• Crear configuraciones modulares que se pueden reutilizar.
• Configurar entornos complejos de manera rápida y consistente.

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