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.
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
mkdirpara crear un directorio llamadoscriptsdentro de su directorio~/project. Aquí es donde almacenará sus scripts Bash.mkdir ~/project/scriptsNo habrá salida directa de este comando si tiene éxito.
Crear su primer archivo de script Bash. Navegue al directorio
scriptsrecién creado y use el editor de textonanopara crear un archivo llamadofirstscript.sh. La extensión.shes una convención común para los scripts de shell, aunque no es estrictamente necesaria.cd ~/project/scripts nano firstscript.shDentro 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 comandoechosimple 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, luegoEnterpara confirmar el nombre del archivo, yCtrl+Xpara salir denano.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érpretebashque lo ejecute. Este método no requiere que el script tenga permisos de ejecución.bash firstscript.shDeberí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/scriptsdonde creófirstscript.shen el paso anterior.cd ~/project/scriptsEditar
firstscript.shpara 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.shusandonano:nano firstscript.shModifique 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
lsblkpara listar los dispositivos de bloques. - Imprime un encabezado para el espacio libre del sistema de archivos.
- Ejecuta
df -hpara 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 -hGuarde el archivo presionando
Ctrl+O, luegoEnter, yCtrl+Xpara salir denano.Hacer que el script sea ejecutable. Para ejecutar un script directamente (por ejemplo,
./firstscript.sh), necesita otorgarle permisos de ejecución. El comandochmodse utiliza para cambiar los permisos de los archivos.+xagrega el permiso de ejecución para todos los usuarios.chmod +x firstscript.shNo 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.shDebería ver una salida similar a esta, combinando su mensaje inicial con la salida de
lsblkydf -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/firmwareLa salida exacta para
lsblkydf -hpuede 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 -fDebería ver una salida similar a esta:
684791f71c0e35fea6cc1243 684791f71c0e35fea6cc1243Esto 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
forpara automatizar la recuperación del nombre de host con diferentes opciones. Ahora, usemos un bucleforpara ejecutar diferentes comandos de nombre de host de manera más eficiente. El bucleforiterará sobre una lista de opciones de nombre de host, ejecutando el comandohostnamecon cada opción.for OPTION in "" "-f" "-s"; do echo "hostname ${OPTION}:" hostname ${OPTION} echo "" doneDesglosemos este comando:
for OPTION in "" "-f" "-s";: Esta parte inicializa el bucle.OPTIONes 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 variableOPTION.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: 684791f71c0e35fea6cc1243Esto demuestra el poder de los bucles
forpara 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/scriptsCrear un nuevo script para la recuperación del nombre de host. Creará un script llamado
get_hostnames.shque contiene el bucleforpara recuperar información del nombre de host utilizando diferentes opciones.Abra
get_hostnames.shusandonano:nano get_hostnames.shAgregue 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 0Guarde el archivo presionando
Ctrl+O, luegoEnter, yCtrl+Xpara salir denano.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 de0, 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.shNo 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.shDeberí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 entornoPATHes una lista de directorios que el shell busca para comandos ejecutables. Cuando escribe un comando comolsogrep, el shell busca en los directorios enumerados enPATHpara encontrar el archivo ejecutable correspondiente.Muestre su variable
PATHactual:echo $PATHVerá 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/sbinObserve que
~/project/scripts(o/home/labex/project/scripts) no se incluye típicamente en elPATHpredeterminado. Esta es la razón por la que tuvo que usar./get_hostnames.shpara 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 personalbinoscriptsa suPATHpara que pueda ejecutar sus scripts personalizados desde cualquier ubicación. Puede hacer esto agregando una línea comoexport PATH=$PATH:~/project/scriptsa su archivo~/.bashrco~/.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á
greppara encontrar información sobre el usuario y el grupolabexde los archivos/etc/passwdy/etc/group. Estos archivos almacenan información de cuentas de usuario y grupo, respectivamente.Primero, busquemos la entrada del usuario
labexen/etc/passwd:grep "labex" /etc/passwdSalida esperada:
labex:x:1000:1000::/home/labex:/bin/bashA continuación, encuentre la entrada del grupo
labexen/etc/group:grep "labex" /etc/groupSalida esperada:
labex:x:1000:Estos comandos demuestran el uso básico de
greppara encontrar coincidencias exactas de cadenas.Filtrar la salida de
lscpuusandogrepy expresiones regulares. El comandolscpumuestra información sobre la arquitectura de la CPU. A menudo, solo necesita líneas específicas de su extensa salida. Puede usargrepcon 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 delscpuy la alimenta como entrada estándar al comandogrep.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: 6Filtrar 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 usargrepcon múltiples patrones para excluir estas líneas. Demostremos esto con el archivo/etc/passwd.grep -v '^#' /etc/passwd | head -5Desglosemos este comando:
grep -v '^#' /etc/passwd: La opción-vinvierte 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 comandogrepal 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/nologinBuscar patrones específicos en archivos del sistema. Puede usar
greppara buscar patrones específicos en varios archivos del sistema. Busquemos entradas relacionadas con el shell en el archivo/etc/passwd.grep "bash" /etc/passwdSalida esperada (mostrando usuarios con el shell bash):
root:x:0:0:root:/root:/bin/bash labex:x:1000:1000::/home/labex:/bin/bashEste 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/scriptsCrear 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.shusandonano:nano system_info.shAgregue 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, luegoEnter, yCtrl+Xpara salir denano.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.shNo 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.shDeberí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.txtyoutput-detailed.txten su directorio~/projectpara verificar que el script recopiló la información como se esperaba.cat ~/project/output-basic.txt cat ~/project/output-detailed.txtEl 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-genericoutput-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/LinuxEste 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.
