Crear y Ejecutar Scripts Bash en RHEL: Guía Paso a Paso

Introducción

En este laboratorio, aprenderá a crear y ejecutar scripts Bash para la administración de sistemas RHEL. Comenzará creando scripts simples, luego los mejorará con comandos del sistema y los hará ejecutables. El laboratorio progresa hacia el uso de bucles for para automatizar tareas como la recopilación de información del sistema y el filtrado de la salida de comandos con grep y expresiones regulares. Finalmente, construirá un script completo de información del sistema RHEL, adquiriendo habilidades prácticas en la automatización de tareas administrativas y aprovechando las potentes funciones del shell.

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 principiante con una tasa de finalización del 82%. Ha recibido una tasa de reseñas positivas del 99% por parte de los estudiantes.

Crear y Ejecutar un Script Bash Simple

En este paso, aprenderá a crear un script Bash básico y a ejecutarlo. Los scripts Bash son archivos de texto plano que contienen una serie de comandos que el shell Bash puede ejecutar. Son herramientas poderosas para automatizar tareas repetitivas y combinar múltiples comandos en una sola unidad ejecutable.

Primero, creará un nuevo directorio para almacenar sus scripts. Es una buena práctica organizar sus archivos, y colocar los scripts en un directorio dedicado ayuda a mantener su directorio de inicio ordenado.

Crear un directorio para sus scripts.
Use el comando mkdir para crear un directorio llamado scripts dentro de su directorio ~/project. Aquí es donde almacenará sus scripts Bash.
```
mkdir ~/project/scripts
```
No habrá salida directa de este comando si tiene éxito.
Crear su primer archivo de script Bash.
Navegue al directorio scripts recién creado y use el editor de texto nano para crear un archivo llamado firstscript.sh. La extensión .sh es una convención común para los scripts de shell, aunque no es estrictamente necesaria.
```
cd ~/project/scripts
nano firstscript.sh
```
Dentro del editor nano, verá una pantalla en blanco.
Agregar contenido a su script.
Cada script Bash debe comenzar con una línea "shebang", #!/usr/bin/bash. Esta línea le dice al sistema operativo qué intérprete usar para ejecutar el script (en este caso, Bash). Después del shebang, agregará un comando echo simple para imprimir un mensaje en la terminal.

Escriba las siguientes líneas en el editor nano:
```
#!/usr/bin/bash
echo "Hello, LabEx! This is my first Bash script."
```
Una vez que haya ingresado el contenido, guarde el archivo presionando Ctrl+O, luego Enter para confirmar el nombre del archivo, y Ctrl+X para salir de nano.

Su terminal debería regresar al indicador de comandos.
Ejecutar su script usando el intérprete bash.
Puede ejecutar un script Bash indicando explícitamente al intérprete bash que lo ejecute. Este método no requiere que el script tenga permisos de ejecución.
```
bash firstscript.sh
```
Debería ver la salida de su script:
```
Hello, LabEx! This is my first Bash script.
```
Esto confirma que su script se creó correctamente y se ejecutó con éxito.

Mejorar el Script Bash con Comandos del Sistema y Hacerlo Ejecutable

En este paso, mejorará su script Bash agregando más comandos del sistema y aprenderá a hacer que el script sea directamente ejecutable. Hacer que un script sea ejecutable le permite ejecutarlo como cualquier otro comando, sin llamar explícitamente al intérprete bash.

Navegar al directorio de sus scripts.
Asegúrese de estar en el directorio ~/project/scripts donde creó firstscript.sh en el paso anterior.
```
cd ~/project/scripts
```
Editar firstscript.sh para incluir más comandos del sistema.
Ahora agregará comandos a su script que muestren información del sistema, como dispositivos de bloques y espacio libre del sistema de archivos. Esto demuestra cómo los scripts pueden automatizar la recopilación de datos del sistema.

Abra firstscript.sh usando nano:
```
nano firstscript.sh
```
Modifique el contenido del archivo para que coincida con lo siguiente. Este script ahora:
- Imprime un encabezado para la información del dispositivo de bloques.
- Ejecuta lsblk para listar los dispositivos de bloques.
- Imprime un encabezado para el espacio libre del sistema de archivos.
- Ejecuta df -h para mostrar el uso del espacio en disco en un formato legible por humanos.
```
#!/usr/bin/bash
echo "Hello, LabEx! This is my first Bash script."
echo "#####################################################"
echo "LIST BLOCK DEVICES"
echo "#####################################################"
lsblk
echo "#####################################################"
echo "FILESYSTEM FREE SPACE STATUS"
echo "#####################################################"
df -h
```
Guarde el archivo presionando Ctrl+O, luego Enter, y Ctrl+X para salir de nano.
Hacer que el script sea ejecutable.
Para ejecutar un script directamente (por ejemplo, ./firstscript.sh), necesita otorgarle permisos de ejecución. El comando chmod se utiliza para cambiar los permisos de los archivos. +x agrega el permiso de ejecución para todos los usuarios.
```
chmod +x firstscript.sh
```
No habrá salida directa de este comando si tiene éxito.

Ejecutar el script directamente.
Ahora que el script es ejecutable, puede ejecutarlo especificando su ruta. Dado que está en su directorio actual, usa ./ seguido del nombre del script.

./firstscript.sh

Debería ver una salida similar a esta, combinando su mensaje inicial con la salida de lsblk y df -h:

Hello, LabEx! This is my first Bash script.
#####################################################
LIST BLOCK DEVICES
#####################################################
NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop0         7:0    0 10.2G  1 loop /
loop1         7:1    0  200M  1 loop /usr/local/bin
loop2         7:2    0  200M  1 loop /usr/local/go
loop3         7:3    0  200M  1 loop /usr/local/java
loop4         7:4    0  200M  1 loop /usr/local/node
loop5         7:5    0  200M  1 loop /usr/local/python
#####################################################
FILESYSTEM FREE SPACE STATUS
#####################################################
Filesystem      Size  Used Avail Use% Mounted on
overlay          10G  4.0G  6.1G  40% /
tmpfs            64M     0   64M   0% /dev
tmpfs           7.8G     0  7.8G   0% /sys/fs/cgroup
shm              64M     0   64M   0% /dev/shm
/dev/loop0       10G  4.0G  6.1G  40% /
tmpfs           7.8G     0  7.8G   0% /proc/asound
tmpfs           7.8G     0  7.8G   0% /proc/acpi
tmpfs           7.8G     0  7.8G   0% /proc/scsi
tmpfs           7.8G     0  7.8G   0% /sys/firmware

La salida exacta para lsblk y df -h puede variar ligeramente según el entorno específico, pero la estructura y la presencia de la salida de los comandos deberían ser similares.

Usar Bucles For para Automatizar la Obtención del Nombre de Host en Servidores RHEL

En este paso, aprenderá sobre los bucles for en Bash y cómo usarlos para automatizar tareas en múltiples servidores. Los bucles for son declaraciones fundamentales de flujo de control que le permiten ejecutar un bloque de código repetidamente para cada elemento de una lista. Esto es particularmente útil para administrar múltiples sistemas de manera eficiente.

Para este ejercicio, demostraremos el concepto usando localhost con diferentes enfoques para simular el trabajo con múltiples servidores.

Recuperar el nombre de host usando comandos locales.
Antes de usar un bucle, veamos cómo obtendría típicamente el nombre de host del sistema local. Usaremos diferentes métodos para demostrar el concepto.
```
hostname
hostname -f
```
Debería ver una salida similar a esta:
```
684791f71c0e35fea6cc1243
684791f71c0e35fea6cc1243
```
Esto demuestra que puede recuperar con éxito la información del nombre de host utilizando diferentes opciones. Tenga en cuenta que en este entorno de contenedor, todas las opciones de nombre de host devuelven el mismo ID de contenedor.
Crear un bucle for para automatizar la recuperación del nombre de host con diferentes opciones.
Ahora, usemos un bucle for para ejecutar diferentes comandos de nombre de host de manera más eficiente. El bucle for iterará sobre una lista de opciones de nombre de host, ejecutando el comando hostname con cada opción.
```
for OPTION in "" "-f" "-s"; do
  echo "hostname ${OPTION}:"
  hostname ${OPTION}
  echo ""
done
```
Desglosemos este comando:
- for OPTION in "" "-f" "-s";: Esta parte inicializa el bucle. OPTION es una variable que tomará el valor de cada elemento de la lista (cadena vacía, -f, -s) durante cada iteración.
- do: Marca el comienzo de los comandos que se ejecutarán en el bucle.
- echo "hostname ${OPTION}:";: Esto muestra qué opción se está utilizando.
- hostname ${OPTION};: Este es el comando ejecutado en cada iteración. ${OPTION} se expande al valor actual de la variable OPTION.
- echo "";: Agrega una línea en blanco para una mejor legibilidad.
- done: Marca el final del bucle.
Debería ver una salida similar a esta:
```
hostname :
684791f71c0e35fea6cc1243

hostname -f:
684791f71c0e35fea6cc1243

hostname -s:
684791f71c0e35fea6cc1243
```
Esto demuestra el poder de los bucles for para automatizar tareas repetitivas con diferentes parámetros.

Crear y Ejecutar un Script Bash con un Bucle For para Servidores RHEL

En este paso, encapsulará el bucle for que aprendió en el paso anterior en un script Bash. Esto le permite guardar la lógica de automatización y reutilizarla fácilmente. También aprenderá sobre la variable de entorno PATH y cómo hacer que sus scripts sean accesibles desde cualquier directorio.

Navegar al directorio de sus scripts.
Asegúrese de estar en el directorio ~/project/scripts.
```
cd ~/project/scripts
```
Crear un nuevo script para la recuperación del nombre de host.
Creará un script llamado get_hostnames.sh que contiene el bucle for para recuperar información del nombre de host utilizando diferentes opciones.

Abra get_hostnames.sh usando nano:
```
nano get_hostnames.sh
```
Agregue el siguiente contenido al archivo:
```
#!/usr/bin/bash
## This script retrieves hostname information using different options.

for OPTION in "" "-f" "-s"; do
  echo "Getting hostname with option: ${OPTION}"
  hostname ${OPTION}
  echo "------------------------"
done

exit 0
```
Guarde el archivo presionando Ctrl+O, luego Enter, y Ctrl+X para salir de nano.

Desglosemos los nuevos elementos:
- ## This script...: Las líneas que comienzan con # son comentarios. Son ignorados por el shell, pero son útiles para documentar su script.
- echo "Getting hostname with option: ${OPTION}": Esta línea proporciona retroalimentación durante la ejecución del script, indicando qué opción se está utilizando actualmente.
- exit 0: Este comando sale explícitamente del script con un código de estado de 0, que convencionalmente indica éxito.
Hacer que el script sea ejecutable.
Al igual que en el paso anterior, necesita dar a su nuevo script permisos de ejecución.
```
chmod +x get_hostnames.sh
```
No habrá salida directa de este comando si tiene éxito.

Ejecutar el script desde su directorio actual.
Ejecute el script para verificar su funcionalidad.

./get_hostnames.sh

Debería ver una salida similar a esta:

Getting hostname with option:
684791f71c0e35fea6cc1243
------------------------
Getting hostname with option: -f
684791f71c0e35fea6cc1243
------------------------
Getting hostname with option: -s
684791f71c0e35fea6cc1243
------------------------

Comprender la variable de entorno PATH.
La variable de entorno PATH es una lista de directorios que el shell busca para comandos ejecutables. Cuando escribe un comando como ls o grep, el shell busca en los directorios enumerados en PATH para encontrar el archivo ejecutable correspondiente.

Muestre su variable PATH actual:
```
echo $PATH
```
Verá una lista de directorios separados por dos puntos. Por ejemplo:
```
/home/labex/.local/bin:/home/labex/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin
```
Observe que ~/project/scripts (o /home/labex/project/scripts) no se incluye típicamente en el PATH predeterminado. Esta es la razón por la que tuvo que usar ./get_hostnames.sh para ejecutar su script.
Agregar su directorio de scripts al PATH (Opcional, para referencia futura).
Si bien no es estrictamente necesario para este paso del laboratorio, es una práctica común agregar un directorio personal bin o scripts a su PATH para que pueda ejecutar sus scripts personalizados desde cualquier ubicación. Puede hacer esto agregando una línea como export PATH=$PATH:~/project/scripts a su archivo ~/.bashrc o ~/.zshrc. Para este laboratorio, continuaremos ejecutando scripts especificando su ruta.

Filtrar la Salida de Comandos con Grep y Expresiones Regulares en RHEL

En este paso, aprenderá a usar el comando grep con expresiones regulares para filtrar y extraer eficientemente información específica de la salida de comandos y archivos. grep es una utilidad poderosa para buscar en conjuntos de datos de texto sin formato líneas que coincidan con una expresión regular. Las expresiones regulares (regex) son secuencias de caracteres que definen un patrón de búsqueda.

Buscar información específica de usuarios y grupos en archivos del sistema.
Usará grep para encontrar información sobre el usuario y el grupo labex de los archivos /etc/passwd y /etc/group. Estos archivos almacenan información de cuentas de usuario y grupo, respectivamente.

Primero, busquemos la entrada del usuario labex en /etc/passwd:
```
grep "labex" /etc/passwd
```
Salida esperada:
```
labex:x:1000:1000::/home/labex:/bin/bash
```
A continuación, encuentre la entrada del grupo labex en /etc/group:
```
grep "labex" /etc/group
```
Salida esperada:
```
labex:x:1000:
```
Estos comandos demuestran el uso básico de grep para encontrar coincidencias exactas de cadenas.
Filtrar la salida de lscpu usando grep y expresiones regulares.
El comando lscpu muestra información sobre la arquitectura de la CPU. A menudo, solo necesita líneas específicas de su extensa salida. Puede usar grep con una expresión regular para filtrar las líneas que comienzan con "CPU".
```
lscpu | grep '^CPU'
```
Desglosemos este comando:
- lscpu: Genera la información de la CPU.
- |: Esto es una tubería (pipe), que toma la salida estándar de lscpu y la alimenta como entrada estándar al comando grep.
- grep '^CPU': Busca líneas que comienzan con la cadena literal "CPU". El ^ (acento circunflejo) es un ancla de expresión regular que coincide con el principio de una línea.
Salida esperada (puede variar ligeramente según el entorno):
```
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6
```
Filtrar archivos de configuración, ignorando comentarios y líneas vacías.
Los archivos de configuración a menudo contienen comentarios (líneas que comienzan con #) y líneas vacías que no son relevantes para la configuración real. Puede usar grep con múltiples patrones para excluir estas líneas. Demostremos esto con el archivo /etc/passwd.
```
grep -v '^#' /etc/passwd | head -5
```
Desglosemos este comando:
- grep -v '^#' /etc/passwd: La opción -v invierte la coincidencia, lo que significa que selecciona las líneas que no coinciden con el patrón. ^# coincide con las líneas que comienzan con #. Por lo tanto, esta parte filtra las líneas de comentarios.
- |: Canaliza la salida del primer comando grep al siguiente comando.
- head -5: Muestra solo las primeras 5 líneas de la salida.
Salida esperada (mostrando entradas de cuentas de usuario sin comentarios):
```
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
```
Buscar patrones específicos en archivos del sistema.
Puede usar grep para buscar patrones específicos en varios archivos del sistema. Busquemos entradas relacionadas con el shell en el archivo /etc/passwd.
```
grep "bash" /etc/passwd
```
Salida esperada (mostrando usuarios con el shell bash):
```
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash
```
Este comando le ayuda a identificar a los usuarios que tienen bash como su shell predeterminado.

Construir un Script Completo de Información del Sistema RHEL

En este paso final, combinará todos los conceptos aprendidos hasta ahora: scripts Bash, bucles for, ssh para la ejecución remota y grep con expresiones regulares para filtrar, para construir un script completo que recopila información del sistema de múltiples servidores RHEL. El script guardará los datos recopilados en archivos de salida separados para cada servidor.

Navegar al directorio de sus scripts.
Asegúrese de estar en el directorio ~/project/scripts.
```
cd ~/project/scripts
```

Crear un nuevo script llamado system_info.sh.
Este script recopilará información del sistema utilizando diferentes enfoques para demostrar los conceptos y redirigirá la salida a archivos distintos en su directorio ~/project.

Abra system_info.sh usando nano:

nano system_info.sh

Agregue el siguiente contenido al archivo:

#!/usr/bin/bash

## Define variables for output directory
OUT_DIR='/home/labex/project'

## Loop through different information gathering approaches
for APPROACH in "basic" "detailed"; do
  OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt"

  echo "Gathering ${APPROACH} system information..."
  ## Clear previous output file or create a new one
  > "${OUTPUT_FILE}"

  ## Get hostname information
  echo "#### Hostname Information ###" >> "${OUTPUT_FILE}"
  if [ "${APPROACH}" = "basic" ]; then
    hostname >> "${OUTPUT_FILE}"
  else
    hostname -f >> "${OUTPUT_FILE}"
  fi
  echo "" >> "${OUTPUT_FILE}" ## Add a blank line for readability

  ## Get CPU information (only lines starting with CPU)
  echo "#### CPU Information ###" >> "${OUTPUT_FILE}"
  lscpu | grep '^CPU' >> "${OUTPUT_FILE}"
  echo "" >> "${OUTPUT_FILE}"

  ## Get system users with bash shell
  echo "#### Users with Bash Shell ###" >> "${OUTPUT_FILE}"
  grep "bash" /etc/passwd >> "${OUTPUT_FILE}"
  echo "" >> "${OUTPUT_FILE}"

  ## Get system information based on approach
  if [ "${APPROACH}" = "basic" ]; then
    echo "#### Basic System Info ###" >> "${OUTPUT_FILE}"
    uname -r >> "${OUTPUT_FILE}"
  else
    echo "#### Detailed System Info ###" >> "${OUTPUT_FILE}"
    uname -a >> "${OUTPUT_FILE}"
  fi
  echo "" >> "${OUTPUT_FILE}"

  echo "Information saved to ${OUTPUT_FILE}"
  echo "-----------------------------------------------------"
done

echo "Script execution complete."

Guarde el archivo presionando Ctrl+O, luego Enter, y Ctrl+X para salir de nano.

Elementos clave de este script:

OUT_DIR='/home/labex/project': La variable se utiliza para hacer que el script sea más flexible y legible.
OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt": Construye dinámicamente el nombre del archivo de salida para cada enfoque.
> "${OUTPUT_FILE}": Esto redirige la salida de un comando vacío al archivo, borrando efectivamente su contenido si existe o creándolo si no existe. Esto asegura un archivo nuevo para cada ejecución.
>> "${OUTPUT_FILE}": Esto anexa la salida del comando al archivo especificado.
if [ "${APPROACH}" = "basic" ]; then ... else ... fi: Sentencias condicionales que ejecutan diferentes comandos según el enfoque que se esté utilizando.
echo "#### Section Header ###": Agrega encabezados claros al archivo de salida para una mejor organización.

Hacer que el script sea ejecutable.
```
chmod +x system_info.sh
```
No habrá salida directa de este comando si tiene éxito.

Ejecutar el script system_info.sh.
Ejecute su script completo. Recopilará información del sistema utilizando diferentes enfoques y guardará los resultados en archivos separados.

./system_info.sh

Debería ver la salida en su terminal que indica el progreso del script:

Gathering basic system information...
Information saved to /home/labex/project/output-basic.txt
-----------------------------------------------------
Gathering detailed system information...
Information saved to /home/labex/project/output-detailed.txt
-----------------------------------------------------
Script execution complete.

Revisar los archivos de salida generados.
Verifique el contenido de los archivos output-basic.txt y output-detailed.txt en su directorio ~/project para verificar que el script recopiló la información como se esperaba.

cat ~/project/output-basic.txt
cat ~/project/output-detailed.txt

El contenido de cada archivo debe ser similar a este (los valores reales variarán):

output-basic.txt:

#### Hostname Information ###
684791f71c0e35fea6cc1243

#### CPU Information ###
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6

#### Users with Bash Shell ###
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash

#### Basic System Info ###
5.4.0-162-generic

output-detailed.txt:

#### Hostname Information ###
684791f71c0e35fea6cc1243

#### CPU Information ###
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6

#### Users with Bash Shell ###
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash

#### Detailed System Info ###
Linux 684791f71c0e35fea6cc1243 5.4.0-162-generic #179-Ubuntu SMP Mon Aug 14 08:51:31 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux

Este script final demuestra cómo puede combinar varias funciones de Bash y comandos de Linux para crear herramientas de automatización potentes para tareas de administración del sistema.

Resumen

En este laboratorio, aprendió los pasos fundamentales para crear y ejecutar scripts Bash para la administración del sistema RHEL. Comenzó configurando un directorio dedicado para scripts y luego creó un script Bash simple, comprendiendo la importancia de la línea shebang y usando el comando echo. Exploró diferentes métodos para ejecutar scripts, incluyendo directamente con el intérprete bash y haciéndolos ejecutables.

Además, mejoró sus habilidades de scripting incorporando comandos del sistema y automatizando tareas usando bucles for para recopilar información del sistema con diferentes enfoques. También aprendió a filtrar la salida de comandos de manera efectiva usando grep y expresiones regulares, una habilidad crucial para analizar la información del sistema. Finalmente, aplicó estos conceptos para construir un script completo de información del sistema RHEL, demostrando cómo combinar varios comandos y construcciones de scripting para recopilar y presentar datos valiosos del sistema.