¿cuanta gente a visto el blog?

Introducción a los scripts de Bash

¡Bienvenidos a esta guía de formación sobre los conceptos básicos de Bash! 

En este curso intensivo sobre Bash, aprenderá los conceptos básicos de Bash para que pueda comenzar a escribir sus propios scripts de Bash y automatizar sus tareas diarias. 

Bash es un shell y lenguaje de comandos de Unix. Está ampliamente disponible en varios sistemas operativos y también es el intérprete de comandos predeterminado en la mayoría de los sistemas Linux. Bash significa Bourne-Again SHell. Al igual que con otros shells, puede usar Bash de forma interactiva directamente en su terminal y también puede usar Bash como cualquier otro lenguaje de programación para escribir scripts. 

Este libro lo ayudará a aprender los conceptos básicos de los scripts de Bash, incluidas las variables de Bash, la entrada del usuario, los comentarios, los argumentos, las matrices, las expresiones condicionales, los condicionales, los bucles, las funciones, la depuración y las pruebas. Para escribir scripts de Bash, solo necesita un terminal de UNIX y un editor de texto como Sublime Text, VS Code o un editor basado en terminal como vim o nano. 


Tabla de Contenidos
Acerca del libro .................................................................................. 7
Acerca del autor ........................................................................... 8
Patrocinadores ................................................................................ 9
Herramienta de generación de Ebook en PDF ............................. 11
Portada del libro ............................................................................ 12
Licencia ........................................................................................ 13
Introducción a la programación en Bash ...................................... 14
Estructura de Bash ......................................................................... 15
Hola Mundo en Bash ...................................................................... 16
Variables en Bash .......................................................................... 18
Entrada de usuario en Bash .......................................................... 21
Comentarios en Bash .................................................................... 23
Argumentos en Bash ..................................................................... 24
Arreglos en Bash .......................................................................... 27
Expresiones condicionales en Bash .............................................. 29
Expresiones de archivos ............................................................. 30
Expresiones de cadenas .............................................................. 32
Operadores aritméticos ............................................................... 34
Condicionales en Bash ................................................................ 36
Sentencia If ................................................................................... 37
Sentencia If Else .......................................................................... 38
Sentencias Switch case ............................................................... 40
Conclusión ................................................................................... 42
Bucles en Bash .............................................................................. 43
Bucles For .................................................................................... 44
Bucles While ................................................................................ 46
Bucles Until ................................................................................. 48
Continue y Break ........................................................................ 49
Funciones en Bash ....................................................................... 50
Depuración, pruebas y atajos ..................................................... 52
Creando comandos personalizados en Bash ............................. 55
Ejemplo ...................................................................................... 56
Haciendo el cambio persistente ................................................. 58
Listando todos los alias disponibles ........................................... 59
Conclusión ................................................................................... 60
Escribe tu primer script en Bash .................................................. 61
Planificando el script ................................................................... 62
Escribiendo el script .................................................................... 63
Añadiendo comentarios ................................................................ 64
Añadiendo tu primera variable .................................................... 65
Añadiendo tu primera función ..................................................... 66
Desafío: añadiendo más funciones ............................................. 68
El script de ejemplo .................................................................... 69
Conclusión ................................................................................... 71
Creando un menú interactivo en Bash ......................................... 72
Planificando la funcionalidad ..................................................... 73
Añadiendo algunos colores ....................................................... 75
Añadiendo el menú ...................................................................... 76
Probando el script ....................................................................... 78
Conclusión ................................................................................... 82
Ejecutando scripts de Bash en múltiples servidores remotos ...... 83
Requisitos previos ..................................................................... 84
El script de Bash ........................................................................ 87
Ejecutando el script en todos los servidores ............................. 89
Conclusión ................................................................................... 91
Trabajando con JSON en Bash usando jq .................................. 92
Planificando el script ................................................................... 93
Instalando jq ............................................................................... 94
Analizando JSON con jq ............................................................ 96
Obteniendo el primer elemento con jq ...................................... 98
Obteniendo un valor solo para una clave específica .................. 99
Usando jq en un script de Bash ................................................ 100
Conclusión ................................................................................. 103
Trabajando con la API de Cloudflare con Bash ......................... 104
Requisitos previos ..................................................................... 105
Desafío - Requisitos del script ................................................. 106
Script de ejemplo ....................................................................... 107
Conclusión ................................................................................. 109
Analizador de scripts de Bash para resumir tus registros de acceso de NGINX y Apache .................................................... 110
Requisitos del script ................................................................... 111
Script de ejemplo ....................................................................... 112
Ejecutando el script .................................................................... 113
Entendiendo la salida ............................................................... 114
Conclusión ................................................................................. 116
Enviando correos electrónicos con Bash y SSMTP ..................... 117
Requisitos previos ..................................................................... 118
Instalando SSMTP ...................................................................... 119
Configurando SSMTP .................................................................. 120
Enviando correos con SSMTP .................................................... 121
Enviando un archivo con SSMTP (opcional) ............................... 122
Conclusión ................................................................................. 123
Generador de contraseñas con script Bash ................................ 124
:warning: Seguridad ................................................................... 125
Resumen del script .................................................................... 126
Requisitos previos ..................................................................... 127
Generando una contraseña aleatoria ...................................... 128
El script ...................................................................................... 130
El script completo: .................................................................... 131
Conclusión ................................................................................. 132
Contribuciones de ...................................................................... 133
Resumen ..................................................................................... 134

Acerca del libro
Esta versión fue publicada el 1 de febrero de 2021.
Este es un manual de código abierto para la introducción a la programación en Bash, que te ayudará a aprender los fundamentos de los scripts en Bash y comenzar a escribir increíbles scripts que te ayudarán a automatizar tus tareas diarias de SysOps, DevOps y desarrollo. No importa si eres un ingeniero DevOps/SysOps, desarrollador o simplemente un entusiasta de Linux, puedes usar scripts en Bash para combinar diferentes comandos de Linux y automatizar tareas tediosas y repetitivas, para que puedas concentrarte en cosas más productivas y divertidas.
La guía es adecuada para cualquier persona que trabaje como desarrollador, administrador de sistemas o ingeniero DevOps y quiera aprender lo básico sobre la programación en Bash.
Los primeros 13 capítulos estarán enfocados exclusivamente en obtener una base sólida sobre scripting en Bash, y luego el resto de los capítulos te ofrecerán ejemplos y scripts de la vida real.

Acerca del autor
El Autor es Bobby Iliev, y he estado trabajando como Ingeniero DevOps en Linux desde 2014. Amante apasionado de Linux y un firme defensor de la filosofía del movimiento de código abierto. "Siempre hago lo que no sé hacer para aprender cómo hacerlo, y creo en compartir el conocimiento.
Creo que es esencial mantener siempre una actitud profesional y rodearse de buenas personas, trabajar arduamente y ser amable con todos. Debes rendir a un nivel constantemente más alto que lo"s demás. Esa es la marca de un verdadero profesional."
Para más información, visita su blog en https://bobbyiliev.com, síguele en Twitter @bobbyiliev_ y en YouTube.

Patrocinadores
Este libro es posible gracias a estas fantásticas empresas:

DigitalOcean
DigitalOcean es una plataforma de servicios en la nube que ofrece la simplicidad que los desarrolladores adoran y en la que las empresas confían para ejecutar aplicaciones de producción a gran escala.
Proporciona soluciones de computación, almacenamiento y redes altamente disponibles, seguras y escalables, que ayudan a los desarrolladores a crear software de calidad más rápido.
Fundada en 2012, con oficinas en Nueva York y Cambridge, MA, DigitalOcean ofrece precios transparentes y asequibles, una interfaz de usuario elegante y una de las bibliotecas más grandes de recursos de código abierto disponibles.
Para más información, visita https://www.digitalocean.com o sigue a @digitalocean en Twitter.
Si eres nuevo en DigitalOcean, puedes obtener un crédito gratis de $100 y poner en marcha tus propios servidores a través de este enlace de referencia:
Crédito de $100 gratis para DigitalOcean

DevDojo
DevDojo es un recurso para aprender todo sobre desarrollo web y diseño web. Aprende en tu descanso para el almuerzo o despierta y disfruta de una taza de café con nosotros para aprender algo nuevo.
Únete a esta comunidad de desarrolladores y todos podemos aprender juntos, construir juntos y crecer juntos.
Para más información, visita https://www.devdojo.com o sigue a @thedevdojo en Twitter.

Herramienta de Generación de Ebook en PDF
Este ebook fue generado por Ibis, desarrollado por Mohamed Said.
Ibis es una herramienta PHP que te ayuda a escribir ebooks en markdown.

Portada del libro
La portada de este ebook fue creada con Canva.com.
Si alguna vez necesitas crear un gráfico, cartel, invitación, logo, presentación, o cualquier cosa que luzca bien, prueba Canva.

Licencia
Licencia MIT
Copyright (c) 2020 Bobby Iliev
Por la presente, se otorga permiso, de forma gratuita, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para tratar el Software sin restricciones, incluyendo sin limitación los derechos a usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender copias del Software, y permitir que las personas a quienes se les suministre el Software lo hagan, sujeto a las siguientes condiciones:
El aviso de copyright anterior y este aviso de permiso deben ser incluidos en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITÁNDOSE A LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR E INFRINGIMIENTO. EN NINGÚN CASO LOS AUTORES O TITULARES DE LOS DERECHOS DE AUTOR SERÁN RESPONSABLES DE CUALQUIER RECLAMO, DAÑO O CUALQUIER OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE CONTRATO, AGRAVIO O DE CUALQUIER OTRA FORMA, QUE SURJA DE O EN CONEXIÓN CON EL SOFTWARE O EL USO O CUALQUIER OTRA GESTIÓN DEL SOFTWARE.

Introducción a la programación en Bash
¡Bienvenido a esta guía de entrenamiento sobre lo básico de Bash! En este curso rápido de Bash, aprenderás lo básico sobre Bash para que puedas comenzar a escribir tus propios scripts y automatizar tus tareas diarias.
Bash es un shell de Unix y un lenguaje de comandos. Está ampliamente disponible en varios sistemas operativos, y también es el intérprete de comandos predeterminado en la mayoría de los sistemas Linux.
Bash significa "Bourne-Again SHell". Al igual que otros shells, puedes usar Bash de forma interactiva directamente en tu terminal, y también puedes usar Bash como cualquier otro lenguaje de programación para escribir scripts. Este libro te ayudará a aprender lo básico de la programación en Bash, incluyendo variables de Bash, entrada de usuario, comentarios, argumentos, arreglos, expresiones condicionales, condicionales, bucles, funciones, depuración y pruebas.

Para escribir scripts en Bash, solo necesitas un terminal UNIX y un editor de texto como Sublime Text, VS Code o un editor basado en terminal como vim o nano.

Estructura de Bash
Comencemos creando un nuevo archivo con la extensión .sh. Como ejemplo, podríamos crear un archivo llamado devdojo.sh.
Para crear ese archivo, puedes usar el comando touch:
touch devdojo.sh
O también puedes usar tu editor de texto:
nano devdojo.sh
Para ejecutar/ejecutar un archivo de script Bash con el intérprete de shell Bash, la primera línea de un archivo de script debe indicar la ruta absoluta al ejecutable de Bash:
#!/bin/bash
Esto también se llama un Shebang.
Lo único que hace el shebang es instruir al sistema operativo para que ejecute el script con el ejecutable /bin/bash.

Bash Hello World
Una vez que tengamos nuestro archivo devdojo.sh creado y hayamos especificado el shebang de Bash en la primera línea, estamos listos para crear nuestro primer script de "Hola Mundo".
Para hacer eso, abre el archivo devdojo.sh nuevamente y agrega lo siguiente después de la línea #!/bin/bash: 

#!/bin/bash 

echo "¡Hola Mundo!"

Guarda el archivo y sal de él.
Después de eso, haz que el script sea ejecutable ejecutando:
chmod +x devdojo.sh
Luego, ejecuta el archivo:
./devdojo.sh
Verás el mensaje "¡Hola Mundo!" en la pantalla.
Otra forma de ejecutar el script sería:
bash devdojo.sh

Como Bash puede usarse de forma interactiva, también podrías ejecutar el siguiente comando directamente en tu terminal y obtendrías el mismo resultado:
echo "¡Hola DevDojo!"

Armar un script es útil cuando necesitas combinar varios comandos.

Variables en Bash
Al igual que en cualquier otro lenguaje de programación, puedes usar variables en Bash. Sin embargo, no hay tipos de datos en Bash, y una variable puede contener tanto números como caracteres.
Para asignar un valor a una variable, solo necesitas usar el signo =:

name="DevDojo"

Nota importante: no puedes tener espacios antes ni después del signo =.
Después, para acceder a la variable, debes usar el $ y referenciarla de la siguiente manera:

echo $name

Envolver el nombre de la variable entre llaves no es obligatorio, pero se considera una buena práctica y te recomiendo usarlas siempre que puedas:

echo ${name}

El resultado de lo anterior será: DevDojo, ya que este es el valor de nuestra variable.

Ahora, vamos a actualizar nuestro script devdojo.sh e incluir una variable.
Nuevamente, con tu editor de texto favorito, abre el archivo:

nano devdojo.sh

Y actualiza el archivo para que se vea así:

#!/bin/bash name="DevDojo" echo "Hi there $name"

Guarda el archivo y ejecútalo nuevamente:

./devdojo.sh

Verás el siguiente resultado en tu pantalla:

Hi there DevDojo

Aquí está un desglose del script:

  • #!/bin/bash - Primero, especificamos nuestro shebang.
  • name=DevDojo - Luego, definimos una variable llamada name y le asignamos un valor.
  • echo "Hi there $name" - Finalmente, mostramos el contenido de la variable en la pantalla usando echo.

También puedes agregar múltiples variables:

#!/bin/bash

name="DevDojo"

greeting="Hello"

echo "$greeting $name"

Guarda el archivo y ejecútalo nuevamente:
./devdojo.sh
Verás el siguiente resultado:
Hello DevDojo

Ten en cuenta que no es necesario agregar un punto y coma ; al final de cada línea. Funcionará de ambas maneras, ¡un poco como en JavaScript!

Entrada de Usuario en Bash
Con el script anterior, definimos una variable y mostramos su valor en la pantalla con echo $name.
Ahora, vamos a pedir la entrada del usuario en lugar de usar una variable fija. Para hacerlo, abre el archivo con tu editor de texto favorito y actualiza el script de la siguiente manera:

#!/bin/bash

echo "What is your name?"

read name

echo "Hi there $name"

echo "Welcome to DevDojo!"

Lo anterior solicitará al usuario que ingrese su nombre y luego almacenará esa entrada como una cadena de texto en una variable.
Luego podemos usar esa variable para imprimir un mensaje al usuario.

El resultado de este script será el siguiente:

Primero ejecuta el script:

./devdojo.sh

Luego, se te pedirá que ingreses tu nombre:
What is your name?

Escribe tu nombre y presiona enter, y obtendrás el siguiente resultado:

Hi there Bobby

Welcome to DevDojo!

Para reducir el código, podríamos cambiar la primera declaración echo por el comando read -p. El comando read con la bandera -p imprimirá un mensaje antes de solicitar la entrada del usuario:

#!/bin/bash
read -p "What is your name? " name
echo "Hi there $name"
echo "Welcome to DevDojo!"

¡Asegúrate de probar esto también!

Comentarios en Bash
Al igual que en cualquier otro lenguaje de programación, puedes agregar comentarios a tu script. Los comentarios se usan para dejar notas para ti mismo a lo largo de tu código.
Para hacerlo en Bash, necesitas agregar el símbolo # al comienzo de la línea. Los comentarios nunca se mostrarán en la pantalla.

Aquí tienes un ejemplo de un comentario:

# Esto es un comentario y no se mostrará en la pantalla

Vamos a añadir algunos comentarios a nuestro script:
#!/bin/bash
# Preguntar al usuario por su nombre
read -p "¿Cuál es tu nombre? " name
# Saludar al usuario
echo "¡Hola $name!"
echo "¡Bienvenido a DevDojo!"

Los comentarios son una excelente manera de describir algunas de las funcionalidades más complejas directamente en tus scripts para que otras personas puedan entender tu código con facilidad.

Argumentos en Bash

Puedes pasar argumentos a tu script de shell cuando lo ejecutas. Para pasar un argumento, simplemente necesitas escribirlo justo después del nombre de tu script. Por ejemplo:

./devdojo.com tu_argumento

En el script, luego podemos usar $1 para hacer referencia al primer argumento que especificamos. Si pasamos un segundo argumento, estará disponible como $2, y así sucesivamente.

Vamos a crear un script corto llamado arguments.sh como ejemplo:

#!/bin/bash

echo "El argumento uno es $1"

echo "El argumento dos es $2"

echo "El argumento tres es $3"

Guarda el archivo y hazlo ejecutable:
chmod +x arguments.sh
Luego ejecuta el archivo y pasa 3 argumentos:
./arguments.sh perro gato pájaro
La salida que obtendrás será:
El argumento uno es perro
El argumento dos es gato
El argumento tres es pájaro

Para hacer referencia a todos los argumentos, puedes usar $@:
#!/bin/bash
echo "Todos los argumentos: $@"
Si ejecutas el script nuevamente:
./arguments.sh perro gato pájaro

Obtenerás la siguiente salida:

Todos los argumentos: perro gato pájaro
Otra cosa que debes tener en cuenta es que $0 se usa para hacer referencia al propio script. Esta es una excelente manera de autodestruir el archivo si lo necesitas o simplemente obtener el nombre del script. Por ejemplo, vamos a crear un script que imprima el nombre del archivo y lo elimine después:
#!/bin/bash echo "El nombre del archivo es: $0 y se va a autodestruir." rm -f $0


Debes tener cuidado con la autodeleción y asegurarte de tener una copia de seguridad del script antes de eliminarlo. Arreglos en Bash Si alguna vez has hecho programación, probablemente ya estés familiarizado con los arreglos. Pero en caso de que no seas desarrollador, lo principal que debes saber es que, a diferencia de las variables, los arreglos pueden almacenar varios valores bajo un solo nombre. Puedes inicializar un arreglo asignando valores separados por espacio y entre paréntesis (). Ejemplo:
mi_array=("valor 1" "valor 2" "valor 3" "valor 4")
Para acceder a los elementos del arreglo, necesitas hacer referencia a ellos por su índice numérico. Nota: Ten en cuenta que debes usar llaves {}. Acceder a un solo elemento, por ejemplo, esto imprimirá: valor 2

echo ${mi_array[1]} Esto devolverá el último elemento: valor 4

echo ${mi_array[-1]} 
 Al igual que con los argumentos de la línea de comandos, usar @ devolverá todos los elementos del arreglo, como sigue: valor 1 valor 2 valor 3 valor 4

Preceder el arreglo con un signo de número (#) mostrará el número total de elementos en el arreglo. En nuestro caso, es 4:

echo ${mi_array[@]} 
 Para acceder a los elementos del arreglo, necesitas hacer referencia a ellos por su índice numérico. Nota: Ten en cuenta que debes usar llaves {}. Acceder a un solo elemento, por ejemplo, esto imprimirá: valor 2
echo ${#mi_array[@]}

Asegúrate de probar esto y practicarlo en tu sistema con diferentes valores.

Expresiones Condicionales en Bash

En informática, las sentencias condicionales, expresiones condicionales y construcciones condicionales son características de un lenguaje de programación que realizan diferentes cálculos o acciones dependiendo de si una condición booleana especificada por el programador evalúa a verdadero o falso.

En Bash, las expresiones condicionales se usan con el comando compuesto [[ y los comandos incorporados para probar atributos de archivos y realizar comparaciones de cadenas y aritméticas.

Aquí hay una lista de las expresiones condicionales más populares en Bash. ¡No tienes que memorizarlas! Puedes consultar esta lista siempre que lo necesites.

Expresiones de archivo:

  • Verdadero si el archivo existe
[[ -a ${archivo} ]]
.Verdadero si el archivo existe y es un archivo especial de bloque
[[ -b ${archivo} ]]
.Verdadero si el archivo existe y es un archivo especial de caracteres
[[ -c ${archivo} ]]
.Verdadero si el archivo existe y es un directorio
[[ -d ${archivo} ]]
.Verdadero si el archivo existe.
[[ -e ${archivo} ]]
.Verdadero si el archivo existe y es un archivo regular
[[ -f ${archivo} ]]
.Verdadero si el archivo existe y es un enlace simbólico
[[ -h ${archivo} ]]
  • Verdadero si el archivo existe y es legible.
     
    [[ -r ${archivo} ]]
  • Verdadero si el archivo existe y tiene un tamaño mayor a cero.
     
    [[ -s ${archivo} ]]
  • Verdadero si el archivo existe y es escribible.
     
    [[ -w ${archivo} ]]
  • Verdadero si el archivo existe y es ejecutable.
     
    [[ -x ${archivo} ]]
  • Verdadero si el archivo existe y es un enlace simbólico.
     
    [[ -L ${archivo} ]]

Expresiones de cadena:

  • Verdadero si la variable varname está definida (tiene un valor asignado).
     
    [[ -v ${varname} ]]
  • Verdadero si la longitud de la cadena es cero.
     
    [[ -z ${cadena} ]]
  • Verdadero si la longitud de la cadena no es cero.
     
    [[ -n ${cadena} ]]
  • Verdadero si las cadenas son iguales.
  • Se debe usar = con el comando test para la conformidad con POSIX.
  • Cuando se usa con el comando [[, esto realiza una coincidencia de patrones
  • como se describió anteriormente (Comandos compuestos).

    [[ ${cadena1} == ${cadena2} ]]
  • Verdadero si las cadenas no son iguales.

    [[ ${cadena1} != ${cadena2} ]]
.

Operadores aritméticos

Devuelve verdadero si los números son iguales:


[[ ${arg1} -eq ${arg2} ]]

Devuelve verdadero si los números no son iguales:


[[ ${arg1} -ne ${arg2} ]]

Devuelve verdadero si arg1 es menor que arg2:


[[ ${arg1} -lt ${arg2} ]]

Devuelve verdadero si arg1 es menor o igual a arg2:


[[ ${arg1} -le ${arg2} ]]

Devuelve verdadero si arg1 es mayor que arg2:


[[ ${arg1} -gt ${arg2} ]]

Devuelve verdadero si arg1 es mayor o igual a arg2:

 
[[ ${arg1} -ge ${arg2} ]]

Como nota al margen, arg1 y arg2 pueden ser enteros positivos o negativos.
Al igual que en otros lenguajes de programación, puedes usar condiciones AND y OR:

 
[[ test_case_1 ]] && [[ test_case_2 ]] # Y
[[ test_case_1 ]] || [[ test_case_2 ]] # O

Condicionales en Bash

En la sección anterior, cubrimos algunas de las expresiones condicionales más populares. Ahora podemos usarlas con sentencias condicionales estándar como if, if-else y switch case.

Sentencia If

El formato de una sentencia if en Bash es el siguiente:


if [[ alguna_prueba ]]
then
    <comandos>
fi

Aquí tienes un ejemplo rápido que te pedirá que ingreses tu nombre en caso de que lo hayas dejado vacío:


#!/bin/bash
# Ejemplo de sentencia if en Bash
read -p "¿Cuál es tu nombre? " name
if [[ -z ${name} ]]
then
    echo "¡Por favor ingresa tu nombre!"
fi

Sentencia If-Else

Con una sentencia if-else, puedes especificar una acción en caso de que la condición de la sentencia if no coincida. Podemos combinar esto con las expresiones condicionales de la sección anterior de la siguiente manera:


#!/bin/bash
# Ejemplo de sentencia if en Bash
read -p "¿Cuál es tu nombre? " name
if [[ -z ${name} ]]
then
    echo "¡Por favor ingresa tu nombre!"
else
    echo "¡Hola ${name}!"
fi

Puedes usar la sentencia if anterior con todas las expresiones condicionales de los capítulos anteriores:


#!/bin/bash
admin="devdojo"
read -p "¿Cuál es tu nombre de usuario? " username
# Verificar si el nombre de usuario proporcionado es el administrador
if [[ "${username}" == "${admin}" ]] ; then
    echo "¡Eres el usuario administrador!"
else
    echo "¡No eres el usuario administrador!"
fi

Aquí tienes otro ejemplo de una sentencia if que verificaría tu ID de usuario actual y no permitiría ejecutar el script como el usuario root:


#!/bin/bash
if (( $EUID == 0 )); then
    echo "Por favor, no lo ejecutes como root"
    exit
fi

Si colocas esto al principio de tu script, saldrá si el EUID es 0 y no ejecutará el resto del script. Esto fue discutido en el foro de la comunidad de DigitalOcean.

Sentencias Switch-Case

Al igual que en otros lenguajes de programación, puedes usar una sentencia case para simplificar condiciones complejas cuando hay múltiples opciones diferentes. Así, en lugar de usar varias sentencias if y if-else, podrías usar una sola sentencia case.

La sintaxis de la sentencia case en Bash es la siguiente:

 
case $alguna_variable in
    patron_1)
        comandos
        ;;
    patron_2| patron_3)
        comandos
        ;;
    *)
        comandos_por_defecto
        ;;
esac

Un resumen rápido de la estructura:

  • Todas las sentencias case comienzan con la palabra clave case.
  • En la misma línea que la palabra clave case, debes especificar una variable o una expresión seguida de la palabra clave in.
  • Después de eso, tienes tus patrones de case, donde debes usar ) para identificar el final del patrón.
  • Puedes especificar varios patrones divididos por una barra vertical |.
  • Después del patrón, especificas los comandos que te gustaría ejecutar en caso de que el patrón coincida con la variable o expresión que hayas especificado.
  • Todas las cláusulas deben terminar con ;; al final.
  • Puedes tener una sentencia por defecto agregando un * como patrón.
  • Para cerrar la sentencia case, usa la palabra clave esac (que es "case" al revés).

Aquí tienes un ejemplo de una sentencia case en Bash:


#!/bin/bash
echo -n "Introduce el nombre de una marca de coches: "
read car
case $car in
    Tesla)
        echo -n "La fábrica de ${car} está en los EE.UU."
        ;;
    BMW | Mercedes | Audi | Porsche)
        echo -n "La fábrica de ${car} está en Alemania."
        ;;
    Toyota | Mazda | Mitsubishi | Subaru)
        echo -n "La fábrica de ${car} está en Japón."
        ;;
    *)
        echo -n "${car} es una marca de coche desconocida."
        ;;
esac

Con este script, le pedimos al usuario que ingrese el nombre de una marca de coches como Tesla, BMW, Mercedes, etc. Luego, con una sentencia case, verificamos el nombre de la marca y si coincide con alguno de nuestros patrones, imprimimos la ubicación de la fábrica. Si el nombre de la marca no coincide con ninguno de nuestros patrones, imprimimos un mensaje por defecto: "marca de coche desconocida".

Conclusión

Te aconsejo que intentes modificar el script y jugar un poco con él para que puedas practicar lo que acabas de aprender en los dos últimos capítulos.

Para más ejemplos de sentencias case en Bash, asegúrate de revisar el capítulo 16, donde crearemos un menú interactivo en Bash utilizando una sentencia case para procesar la entrada del usuario.

Bucles en Bash

Al igual que en otros lenguajes, los bucles son muy convenientes. Con Bash puedes usar bucles for, while y until.

Bucles For

Aquí tienes la estructura de un bucle for:

 
for var in ${lista}
do
    tus_comandos
done

Ejemplo:

 
#!/bin/bash
usuarios="devdojo bobby tony"
for usuario in ${usuarios}
do
    echo "${usuario}"
done

Un resumen rápido del ejemplo:

  1. Primero, especificamos una lista de usuarios y almacenamos el valor en una variable llamada $usuarios.
  2. Luego, comenzamos nuestro bucle for con la palabra clave for.
  3. Después definimos una nueva variable que representará cada elemento de la lista que proporcionamos. En este caso, definimos una variable llamada usuario, que representará cada usuario de la variable $usuarios.
  4. Luego especificamos la palabra clave in seguida de nuestra lista a la que vamos a hacer el bucle.
  5. En la siguiente línea, usamos la palabra clave do, que indica lo que haremos en cada iteración del bucle.
  6. Finalmente, especificamos los comandos que queremos ejecutar.
  7. Terminamos el bucle con la palabra clave done.

También puedes usar el bucle for para procesar una serie de números. Por ejemplo, aquí tienes una forma de hacer un bucle del 1 al 10:

 
#!/bin/bash
for num in {1..10}
do
    echo ${num}
done

Espero que la traducción te haya sido útil. Si tienes más preguntas o necesitas más aclaraciones, ¡no dudes en preguntar!

Bucles While

La estructura de un bucle while es bastante similar a la del bucle for:

bash
while [ tu_condición ]
do
    tus_comandos
done

Aquí tienes un ejemplo de un bucle while:

bash
#!/bin/bash
counter=1
while [[ $counter -le 10 ]]
do
    echo $counter
    ((counter++))
done

Primero, especificamos una variable llamada counter y la inicializamos en 1. Luego, dentro del bucle, incrementamos el contador utilizando esta instrucción: ((counter++)). De esta manera, nos aseguramos de que el bucle se ejecute solo 10 veces y no se ejecute de manera indefinida. El bucle terminará tan pronto como el contador llegue a 10, ya que esa es la condición que hemos establecido: while [[ $counter -le 10 ]].

Vamos a crear un script que le pida al usuario su nombre y no permita una entrada vacía:

bash
#!/bin/bash
read -p "¿Cuál es tu nombre? " name
while [[ -z ${name} ]]
do
    echo "Tu nombre no puede estar en blanco. ¡Por favor, ingresa un nombre válido!"
    read -p "¿Puedes ingresar tu nombre nuevamente? " name
done
echo "¡Hola ${name}!"

Ahora, si ejecutas lo anterior y solo presionas Enter sin proporcionar ninguna entrada, el bucle se ejecutará nuevamente y te pedirá tu nombre una y otra vez hasta que realmente ingreses algo.

Bucles Until

La diferencia entre los bucles until y while es que el bucle until ejecutará los comandos dentro del bucle hasta que la condición se vuelva verdadera.

Estructura:

bash
until [ tu_condición ]
do
    tus_comandos
done

Ejemplo:

bash
#!/bin/bash
count=1
until [ $count -gt 10 ]
do
    echo $count
    ((count++))
done

Continue y Break

Al igual que en otros lenguajes, puedes usar continue y break en tus scripts de Bash:

  • continue le indica a tu script de Bash que detenga la iteración actual del bucle y comience la siguiente iteración.
  • break le indica a tu script de Bash que termine el bucle de inmediato.

Funciones en Bash

Las funciones son una excelente manera de reutilizar código. La estructura de una función en Bash es bastante similar a la de otros lenguajes:

bash
function nombre_de_funcion() {
    tus_comandos
}

También puedes omitir la palabra clave function al principio, lo que también funcionará:

bash
nombre_de_funcion() {
    tus_comandos
}

Personalmente prefiero incluirla por mejor legibilidad, pero es una cuestión de preferencia personal.

Ejemplo de una función que dice "¡Hola Mundo!":

bash
#!/bin/bash
function hello(){
    echo "¡Hola Mundo desde la función!"
}
hello

Nota: Una cosa a tener en cuenta es que no debes agregar los paréntesis cuando llamas a la función.

Pasar argumentos a una función funciona de la misma manera que pasar argumentos a un script:

bash
#!/bin/bash
function hello(){
    echo "¡Hola $1!"
}
hello DevDojo

En los próximos capítulos estaremos usando funciones con bastante frecuencia.

Depuración, pruebas y atajos

Para depurar tus scripts de Bash, puedes usar -x cuando ejecutes tus scripts:

bash
bash -x ./tu_script.sh

O puedes agregar set -x antes de la línea específica que deseas depurar. set -x habilita un modo de la shell donde todos los comandos ejecutados se imprimen en el terminal.

Otra manera de probar tus scripts es usar esta fantástica herramienta:

https://www.shellcheck.net/

Solo tienes que copiar y pegar tu código en el cuadro de texto, y la herramienta te dará algunas sugerencias sobre cómo puedes mejorar tu script.

También puedes ejecutar la herramienta directamente en tu terminal:

https://github.com/koalaman/shellcheck

Si te gusta la herramienta, asegúrate de darle una estrella en GitHub y contribuir.

Como SysAdmin/DevOps, paso gran parte de mi día en la terminal. Aquí tienes algunos de mis atajos favoritos que me ayudan a realizar tareas más rápido mientras escribo scripts de Bash o simplemente trabajo en la terminal.

Los dos siguientes son especialmente útiles si tienes un comando muy largo.

  • Eliminar todo desde el cursor hasta el final de la línea:
    Ctrl + k
  • Eliminar todo desde el cursor hasta el inicio de la línea:
    Ctrl + u
  • Eliminar una palabra hacia atrás desde el cursor:
    Ctrl + w
  • Buscar en tu historial hacia atrás. Probablemente este sea el que más uso. Es realmente útil y acelera mucho mi flujo de trabajo:
    Ctrl + r
  • Limpiar la pantalla, uso este atajo en lugar de escribir el comando clear:
    Ctrl + l
  • Detener la salida en pantalla:
    Ctrl + s
  • Habilitar la salida en pantalla en caso de que haya sido detenida previamente con Ctrl + s:
    Ctrl + q
  • Terminar el comando actual:
    Ctrl + c
  • Enviar el comando actual al fondo:
    Ctrl + z

Uso estos atajos regularmente todos los días, y me ahorran mucho tiempo.
Si crees que he omitido alguno, siéntete libre de unirte a la discusión en el foro de la comunidad de DigitalOcean.

Crear comandos personalizados de Bash

Como desarrollador o administrador de sistemas, es posible que tengas que pasar mucho tiempo en tu terminal. Siempre trato de buscar formas de optimizar las tareas repetitivas.

Una manera de hacerlo es escribir scripts de Bash cortos o crear comandos personalizados, también conocidos como alias. Por ejemplo, en lugar de escribir un comando muy largo cada vez, podrías crear un atajo para él.

Ejemplo

Empecemos con el siguiente escenario: como administrador de sistemas, es posible que tengas que revisar las conexiones a tu servidor web con bastante frecuencia. Usaré el comando netstat como ejemplo.

Lo que normalmente haría cuando accedo a un servidor que está teniendo problemas con las conexiones a los puertos 80 o 443, es verificar si hay algún servicio escuchando en esos puertos y cuántas conexiones hay a esos puertos.

El siguiente comando de netstat nos mostraría cuántas conexiones TCP tenemos actualmente en los puertos 80 y 443:

bash
netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l

Este es un comando bastante largo, por lo que escribirlo cada vez podría ser una pérdida de tiempo, especialmente cuando quieres obtener esa información rápidamente.

Para evitarlo, podemos crear un alias, para que en lugar de escribir todo el comando, solo tengamos que escribir un comando corto. Por ejemplo, supongamos que queremos poder escribir conn (abreviatura de connections) y obtener la misma información. Todo lo que necesitamos hacer en este caso es ejecutar el siguiente comando:

bash
alias conn="netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l"

De esta manera, estamos creando un alias llamado conn, que esencialmente sería un "acceso directo" para nuestro largo comando de netstat. Ahora, si ejecutas solo conn:

bash
conn

Espero que la traducción te sea útil. Si tienes más preguntas o necesitas más detalles, ¡no dudes en preguntar!

Obtendrás la misma salida que con el comando largo de netstat. Puedes ser aún más creativo y agregar algunos mensajes informativos como este:

bash
alias conn="echo 'Conexiones totales en los puertos 80 y 443:' ;
netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l"

Ahora, si ejecutas conn, obtendrás la siguiente salida:

yaml
Conexiones totales en los puertos 80 y 443:
12

Ahora, si cierras sesión y vuelves a iniciar sesión, tu alias se perderá. En el siguiente paso verás cómo hacer que este cambio sea persistente.

Hacer el cambio persistente

Para hacer que el cambio sea persistente, necesitamos agregar el comando alias en nuestro archivo de perfil de la shell.

Por defecto, en Ubuntu este archivo sería ~/.bashrc, y para otros sistemas operativos podría ser ~/.bash_profile. Abre el archivo con tu editor de texto favorito:

bash
nano ~/.bashrc

Ve al final del archivo y agrega lo siguiente:

bash
alias conn="echo 'Conexiones totales en los puertos 80 y 443:' ;
netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l"

Guarda y luego cierra el archivo.
De esta manera, ahora, incluso si cierras sesión y vuelves a iniciar sesión, tu cambio se mantendrá y podrás ejecutar tu comando personalizado de Bash.

Listar todos los alias disponibles

Para listar todos los alias disponibles para tu shell actual, solo tienes que ejecutar el siguiente comando:

bash
alias

Esto es útil en caso de que estés viendo un comportamiento extraño con algunos comandos.

Conclusión

Esta es una forma de crear comandos personalizados de Bash o alias de Bash.
Por supuesto, también podrías escribir un script de Bash y agregarlo en la carpeta /usr/bin, pero esto no funcionaría si no tienes acceso de root o sudo, mientras que con los alias puedes hacerlo sin necesidad de acceso root.

Nota: Esto fue publicado inicialmente en DevDojo.com.

Escribir tu primer script en Bash

¡Vamos a intentar juntar todo lo que hemos aprendido hasta ahora y crear nuestro primer script en Bash!

Planificación del script

Como ejemplo, escribiremos un script que obtendrá información útil sobre nuestro servidor, como:

  • Uso actual del disco
  • Uso actual de la CPU
  • Uso actual de la memoria RAM
  • Verificación de la versión exacta del Kernel

Siéntete libre de ajustar el script agregando o eliminando funcionalidades para que se adapte a tus necesidades.

Escribiendo el script

Lo primero que debes hacer es crear un nuevo archivo con la extensión .sh. Yo crearé un archivo llamado status.sh, ya que el script que vamos a crear nos dará el estado de nuestro servidor.

Una vez que hayas creado el archivo, ábrelo con tu editor de texto favorito.

Como aprendimos en el capítulo 1, en la primera línea de nuestro script de Bash debemos especificar lo que se llama el Shebang:

bash
#!/bin/bash

Lo único que hace el shebang es instruir al sistema operativo para que ejecute el script con el ejecutable /bin/bash.

Agregar comentarios

A continuación, como se discutió en el capítulo 6, comencemos agregando algunos comentarios para que las personas puedan entender fácilmente para qué sirve el script. Para hacer esto, simplemente agrega lo siguiente después del shebang:

bash
#!/bin/bash
# Script que devuelve el estado actual del servidor

Agregar tu primera variable

Ahora vamos a aplicar lo que aprendimos en el capítulo 4 y agregar algunas variables que podríamos querer usar a lo largo del script.
Para asignar un valor a una variable en Bash, solo tienes que usar el signo =.
Por ejemplo, vamos a almacenar el nombre del host de nuestro servidor en una variable para que podamos usarla más tarde:

bash
server_name=$(hostname)

Al usar $() le decimos a Bash que interprete el comando y luego asigne el valor a nuestra variable.
Ahora, si imprimimos la variable con echo, veremos el nombre de host actual:

bash
echo $server_name

Agregar tu primera función

Como ya sabes después de leer el capítulo 12, para crear una función en Bash necesitas usar la siguiente estructura:

bash
function nombre_de_funcion() {
    tus_comandos
}

Vamos a crear una función que devuelva el uso actual de la memoria en nuestro servidor:

bash
function memory_check() {
    echo ""
    echo "El uso actual de la memoria en ${server_name} es: "
    free -h
    echo ""
}

Explicación rápida de la función:

  • function memory_check() { - así definimos la función.
  • echo "" - aquí solo imprimimos una nueva línea.
  • echo "El uso actual de la memoria en ${server_name} es: " - aquí imprimimos un pequeño mensaje y la variable $server_name.
  • } - finalmente, así cerramos la función.

Una vez que se ha definido la función, para llamarla, simplemente usa el nombre de la función:

bash
# Definir la función
function memory_check() {
    echo ""
    echo "El uso actual de la memoria en ${server_name} es: "
    free -h
    echo ""
}

# Llamar la función
memory_check

Desafío: Agregar más funciones

Antes de ver la solución, te desafío a usar la función que hemos creado anteriormente y escribir algunas funciones por ti mismo.
Las funciones deben hacer lo siguiente:

  • Uso actual del disco
  • Uso actual de la CPU
  • Uso actual de la memoria RAM
  • Verificar la versión exacta del Kernel

Si no sabes qué comandos necesitas usar para obtener esa información, siéntete libre de buscar en Google.

Una vez que estés listo, puedes desplazarte hacia abajo y ver cómo lo hicimos y comparar los resultados.
Ten en cuenta que hay múltiples formas correctas de hacerlo.

El script de ejemplo

Así es como quedaría el resultado final:

bash
#!/bin/bash
##
# Script de BASH que verifica:
# - Uso de la memoria
# - Carga de la CPU
# - Número de conexiones TCP
# - Versión del Kernel
##
server_name=$(hostname)

function memory_check() {
    echo ""
    echo "El uso de la memoria en ${server_name} es: "
    free -h
    echo ""
}

function cpu_check() {
    echo ""
    echo "La carga de la CPU en ${server_name} es: "
    echo ""
    uptime
    echo ""
}

function tcp_check() {
    echo ""
    echo "Conexiones TCP en ${server_name}: "
    echo ""
    cat /proc/net/tcp | wc -l
    echo ""
}

function kernel_check() {
    echo ""
    echo "La versión del Kernel en ${server_name} es: "
    echo ""
    uname -r
    echo ""
}

function all_checks() {
    memory_check
    cpu_check
    tcp_check
    kernel_check
}

all_checks

¡Y ahí lo tienes! Ahora tienes un script que devuelve el estado actual del servidor.
Si tienes más preguntas o necesitas más ayuda, no dudes en preguntar. ¡Feliz codificación!

Conclusión
¡Los scripts en Bash son geniales! No importa si eres un ingeniero DevOps/SysOps, un desarrollador o simplemente un entusiasta de Linux, puedes usar scripts de Bash para combinar diferentes comandos de Linux y automatizar tareas diarias aburridas y repetitivas, ¡para que puedas concentrarte en cosas más productivas y divertidas!

Nota: Esto fue publicado inicialmente en DevDojo.com.

Crear un menú interactivo en Bash
En este tutorial, te mostraré cómo crear un menú de selección múltiple en Bash, para que tus usuarios puedan elegir qué acción ejecutar.

Reutilizaremos parte del código del capítulo anterior, así que, si aún no lo has leído, asegúrate de hacerlo.

Planificando la funcionalidad
Comencemos de nuevo repasando la funcionalidad principal del script:

  • Verifica el uso actual del disco
  • Verifica el uso actual de la CPU
  • Verifica el uso actual de la memoria RAM
  • Verifica la versión exacta del Kernel

En caso de que no lo tengas a mano, aquí está el script:

bash
#!/bin/bash
##
# Script de BASH para verificar:
# - Uso de la memoria
# - Carga de la CPU
# - Número de conexiones TCP
# - Versión del Kernel
##
server_name=$(hostname)

function memory_check() {
  echo ""
  echo "El uso de la memoria en ${server_name} es: "
  free -h
  echo ""
}

function cpu_check() {
  echo ""
  echo "La carga de la CPU en ${server_name} es: "
  echo ""
  uptime
  echo ""
}

function tcp_check() {
  echo ""
  echo "Conexiones TCP en ${server_name}: "
  echo ""
  cat /proc/net/tcp | wc -l
  echo ""
}

function kernel_check() {
  echo ""
  echo "La versión del Kernel en ${server_name} es: "
  echo ""
  uname -r
  echo ""
}

function all_checks() {
  memory_check
  cpu_check
  tcp_check
  kernel_check
}

Luego, construiremos un menú que permita al usuario elegir qué función ejecutar.
Por supuesto, puedes ajustar las funciones o agregar nuevas según tus necesidades.

Agregando algunos colores
Para hacer que el menú sea un poco más 'legible' y fácil de entender a primera vista, agregaremos algunas funciones de color.

Al principio de tu script, agrega las siguientes funciones de color:

bash
##
# Variables de color
##
green='\e[32m'
blue='\e[34m'
clear='\e[0m'

##
# Funciones de color
##
ColorGreen(){
  echo -ne $green$1$clear
}

ColorBlue(){
  echo -ne $blue$1$clear
}

Puedes usar las funciones de color de la siguiente manera:

bash
echo -ne $(ColorBlue 'Texto aquí')

El resultado será que el texto "Texto aquí" se mostrará en azul.

Agregando el menú
Finalmente, para agregar nuestro menú, crearemos una función separada con un switch case para las opciones del menú:

bash
menu(){
  echo -ne "
Mi Primer Menú
$(ColorGreen '1)') Uso de la memoria
$(ColorGreen '2)') Carga de la CPU
$(ColorGreen '3)') Número de conexiones TCP
$(ColorGreen '4)') Versión del Kernel
$(ColorGreen '5)') Verificar Todo
$(ColorGreen '0)') Salir
$(ColorBlue 'Elige una opción:') "
  
  read a
  case $a in
    1) memory_check ; menu ;;
    2) cpu_check ; menu ;;
    3) tcp_check ; menu ;;
    4) kernel_check ; menu ;;
    5) all_checks ; menu ;;
    0) exit 0 ;;
    *) echo -e $red" Opción incorrecta."$clear;
    WrongCommand;;
  esac
}

Explicación rápida del código
Primero, simplemente mostramos las opciones del menú con algo de color:

bash
echo -ne "
Mi Primer Menú
$(ColorGreen '1)') Uso de la memoria
$(ColorGreen '2)') Carga de la CPU
$(ColorGreen '3)') Número de conexiones TCP
$(ColorGreen '4)') Versión del Kernel
$(ColorGreen '5)') Verificar Todo
$(ColorGreen '0)') Salir
$(ColorBlue 'Elige una opción:') "

Luego, leemos la respuesta del usuario y la almacenamos en una variable llamada $a:

bash
read a

Finalmente, tenemos un switch case que ejecuta una función diferente dependiendo del valor de $a:

bash
case $a in
  1) memory_check ; menu ;;
  2) cpu_check ; menu ;;
  3) tcp_check ; menu ;;
  4) kernel_check ; menu ;;
  5) all_checks ; menu ;;
  0) exit 0 ;;
  *) echo -e $red" Opción incorrecta."$clear;
  WrongCommand;;
esac

Al final, necesitamos llamar a la función del menú para imprimir realmente el menú:

bash
# Llamamos a la función del menú
menu

Probando el script
Al final, tu script debería verse así:

bash
#!/bin/bash
##
# Script de BASH que verifica:
# - Uso de la memoria
# - Carga de la CPU
# - Número de conexiones TCP
# - Versión del Kernel
##
server_name=$(hostname)

function memory_check() {
  echo ""
  echo "El uso de la memoria en ${server_name} es: "
  free -h
  echo ""
}

function cpu_check() {
  echo ""
  echo "La carga de la CPU en ${server_name} es: "
  echo ""
  uptime
  echo ""
}

function tcp_check() {
  echo ""
  echo "Conexiones TCP en ${server_name}: "
  echo ""
  cat /proc/net/tcp | wc -l
  echo ""
}

function kernel_check() {
  echo ""
  echo "La versión del Kernel en ${server_name} es: "
  echo ""
  uname -r
  echo ""
}

function all_checks() {
  memory_check
  cpu_check
  tcp_check
  kernel_check
}

##
# Variables de color
##
green='\e[32m'
blue='\e[34m'
clear='\e[0m'

##
# Funciones de color
##
ColorGreen(){
  echo -ne $green$1$clear
}

ColorBlue(){
  echo -ne $blue$1$clear
}

menu(){
  echo -ne "
Mi Primer Menú
$(ColorGreen '1)') Uso de la memoria
$(ColorGreen '2)') Carga de la CPU
$(ColorGreen '3)') Número de conexiones TCP
$(ColorGreen '4)') Versión del Kernel
$(ColorGreen '5)') Verificar Todo
$(ColorGreen '0)') Salir
$(ColorBlue 'Elige una opción:') "
  
  read a
  case $a in
    1) memory_check ; menu ;;
    2) cpu_check ; menu ;;
    3) tcp_check ; menu ;;
    4) kernel_check ; menu ;;
    5) all_checks ; menu ;;
    0) exit 0 ;;
    *) echo -e $red" Opción incorrecta."$clear;
    WrongCommand;;
  esac
}

# Llamamos a la función del menú
menu

Para probar el script, crea un nuevo archivo con extensión .sh, por ejemplo: menu.sh y luego ejecútalo:

bash
bash menu.sh

La salida que recibirás será algo como esto:

css
Mi Primer Menú
1) Uso de la memoria
2) Carga de la CPU
3) Número de conexiones TCP
4) Versión del Kernel
5) Verificar Todo
0) Salir
Elige una opción:

Podrás elegir una opción diferente de la lista y cada número llamará a una función distinta del script.

¡Y eso es todo! Ahora tienes un menú interactivo en Bash que te permite elegir qué información ver de tu sistema. ¡Feliz programación!


Conclusión

¡Ahora sabes cómo crear un menú en Bash e implementarlo en tus scripts para que los usuarios puedan seleccionar diferentes opciones!

Nota: Este contenido fue publicado inicialmente en DevDojo.com.

Ejecutando scripts de BASH en múltiples servidores remotos
Cualquier comando que puedas ejecutar desde la línea de comandos puede ser usado en un script de Bash. Los scripts se utilizan para ejecutar una serie de comandos. Bash está disponible por defecto en los sistemas operativos Linux y macOS.

Imaginemos un escenario hipotético en el que necesitas ejecutar un script de BASH en varios servidores remotos, pero no quieres copiar manualmente el script a cada servidor, luego iniciar sesión en cada servidor de forma individual y solo entonces ejecutar el script.

Por supuesto, podrías usar una herramienta como Ansible, pero ¡vamos a aprender cómo hacerlo con Bash!

Requisitos previos
Para este ejemplo, usaré 3 servidores remotos con Ubuntu desplegados en DigitalOcean. Si aún no tienes una cuenta en DigitalOcean, puedes registrarte y obtener $100 de crédito gratuito a través de este enlace de referido:

https://m.do.co/c/2a9bba940f39

Una vez que tengas tu cuenta de DigitalOcean lista, adelante, despliega 3 "droplets" (servidores).

Yo ya he creado 3 servidores Ubuntu:

Pondré las direcciones IP de esos servidores en un archivo servers.txt, que utilizaré para hacer un bucle en nuestro script de Bash.

Si eres nuevo en DigitalOcean, puedes seguir los pasos para crear un Droplet aquí:
Cómo crear un Droplet desde el panel de control de DigitalOcean

También puedes seguir los pasos de este video sobre cómo hacer la configuración inicial de tu servidor:
Cómo hacer la configuración inicial del servidor con Ubuntu

O mejor aún, puedes seguir este artículo sobre cómo automatizar la configuración inicial del servidor con Bash:
Automatizando la configuración inicial del servidor con Ubuntu 18.04 usando Bash

Con los 3 nuevos servidores en marcha, ¡ya podemos centrarnos en ejecutar nuestro script de Bash en todos ellos con un solo comando!

El Script de BASH
Voy a reutilizar el script de demostración del capítulo anterior con algunos pequeños cambios. Simplemente ejecuta una serie de comprobaciones como el uso actual de memoria, el uso actual de la CPU, el número de conexiones TCP y la versión del kernel.

bash
#!/bin/bash
##
# Script BASH que comprueba lo siguiente:
# - Uso de memoria
# - Carga de CPU
# - Número de conexiones TCP
# - Versión del kernel
##
##
# Comprobación de memoria
##
server_name=$(hostname)
function memory_check() {
 echo "#######"
 echo "El uso actual de memoria en ${server_name} es: "
 free -h
 echo "#######"
}
function cpu_check() {
 echo "#######"
 echo "La carga actual de la CPU en ${server_name} es: "
 echo ""
 uptime
 echo "#######"
}
function tcp_check() {
 echo "#######"
 echo "Total de conexiones TCP en ${server_name}: "
 echo ""
 cat /proc/net/tcp | wc -l
 echo "#######"
}
function kernel_check() {
 echo "#######"
 echo "La versión exacta del kernel en ${server_name} es: "
 echo ""
 uname -r
 echo "#######"
}
function all_checks() {
 memory_check
 cpu_check
 tcp_check
 kernel_check
}
all_checks

Copia el código de abajo y guárdalo en un archivo llamado remote_check.sh. También puedes obtener el script desde aquí.

Ejecutando el Script en todos los Servidores
Ahora que tenemos el script y los servidores listos, y hemos agregado esos servidores en nuestro archivo servers.txt, podemos ejecutar el siguiente comando para hacer un bucle a través de todos los servidores y ejecutar el script remotamente, sin tener que copiar el script a cada servidor ni conectarnos a cada uno individualmente:

bash
for server in $(cat servers.txt) ; do ssh your_user@${server} 'bash -s' < ./remote_check.sh ; done

Lo que hace este bucle for es recorrer cada servidor en el archivo servers.txt y luego ejecutar el siguiente comando para cada servidor en la lista:

bash
ssh your_user@the_server_ip 'bash -s' < ./remote_check.sh

Obtendrás el siguiente resultado:

Conclusión

Este es solo un ejemplo muy simple de cómo ejecutar un script sencillo en múltiples servidores sin tener que copiar el script a cada servidor y sin tener que acceder a cada servidor individualmente.

Por supuesto, podrías ejecutar un script mucho más complejo y en muchos más servidores.

Si estás interesado en la automatización, te recomendaría revisar la página de recursos de Ansible en el sitio web de DigitalOcean:
Recursos de Ansible

Aviso: Este contenido fue publicado originalmente en DevDojo.

Trabajando con JSON en BASH usando jq

La herramienta de línea de comandos jq es un procesador de JSON ligero y flexible. Es excelente para analizar la salida JSON en BASH.

Una de las grandes ventajas de jq es que está escrito en C portátil, y no tiene dependencias en tiempo de ejecución. Todo lo que necesitas hacer es descargar un único binario o usar un gestor de paquetes como apt para instalarlo con un solo comando.

Planificación del script

Para la demostración en este tutorial, utilizaré una API REST externa que devuelve una salida JSON simple llamada QuizAPI:
https://quizapi.io/

Si deseas seguir este tutorial, asegúrate de obtener una clave API gratuita aquí:
https://quizapi.io/clientarea/settings/token

QuizAPI es gratuita para desarrolladores.

Instalando jq

Existen muchas formas de instalar jq en tu sistema. Una de las maneras más directas de hacerlo es usar el gestor de paquetes según tu sistema operativo.

Aquí tienes una lista de los comandos que necesitas usar dependiendo de tu sistema operativo:

  • Instalar jq en Ubuntu/Debian:

    bash
    sudo apt-get install jq

  • Instalar jq en Fedora:

    bash
    sudo dnf install jq

  • Instalar jq en openSUSE:

    bash
    sudo zypper install jq

  • Instalar jq en Arch:

    bash
    sudo pacman -S jq

  • Instalar en Mac con Homebrew:

    bash
    brew install jq

  • Instalar en Mac con MacPorts:

    bash
    port install jq

Si usas otro sistema operativo, te recomiendo revisar la documentación oficial aquí para más detalles:
https://stedolan.github.io/jq/download/

Una vez que hayas instalado jq, puedes verificar tu versión actual ejecutando este comando:

bash
jq --version

Analizando JSON con jq

Una vez que tengas instalado jq y tu API Key de QuizAPI, puedes analizar la salida JSON de QuizAPI directamente en tu terminal.

Primero, crea una variable que almacene tu clave API:

bash
API_KEY=TU_API_KEY_AQUI

Para obtener alguna salida de uno de los endpoints de QuizAPI, puedes usar el comando curl:

bash
curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10"

Para obtener una salida más específica, puedes usar el Generador de URL de QuizAPI aquí:
https://quizapi.io/api-config

Después de ejecutar el comando curl, la salida que obtendrás será algo como esto:

Una salida JSON bien formateada:

bash
curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq

Observa el | jq al final.
En este caso, la salida que obtendrás será algo como esto:

¡Ahora se ve mucho mejor!

¡La herramienta de línea de comandos jq formateó la salida por nosotros y agregó algunos colores bonitos!

Obteniendo el primer elemento con jq
Supongamos que solo queremos obtener el primer elemento de la salida JSON. Para hacer eso, solo tenemos que especificar el índice que queremos ver con la siguiente sintaxis:

bash
jq .[0]

Ahora, si ejecutamos nuevamente el comando curl y pasamos la salida a jq .[0] de esta forma:

bash
curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq .[0]

Solo obtendrás el primer elemento, y la salida se verá algo así:

Obteniendo un valor solo para una clave específica

A veces puede que quieras obtener solo el valor de una clave específica. Supongamos que, en nuestro ejemplo, la QuizAPI devuelve una lista de preguntas junto con las respuestas, la descripción, etc. Pero ¿qué pasa si solo quieres obtener las preguntas sin la información adicional?

Esto es bastante sencillo con jq. Todo lo que necesitas hacer es agregar la clave después del comando jq, y se vería algo como esto:

bash
jq .[].question

Tenemos que agregar el .[ ] porque la QuizAPI devuelve un arreglo, y al especificar .[ ], le decimos a jq que queremos obtener el valor .question para todos los elementos del arreglo.

La salida que obtendrás se verá algo así:

Usando jq en un script BASH

Vamos a crear un pequeño script en Bash que debe mostrar la siguiente información para nosotros:

  1. Obtener solo la primera pregunta del resultado.
  2. Obtener todas las respuestas para esa pregunta.
  3. Asignar las respuestas a variables.
  4. Imprimir la pregunta y las respuestas.

Para hacer esto, he preparado el siguiente script:

Nota: Asegúrate de reemplazar API_KEY por tu clave real de QuizAPI.

bash
#!/bin/bash
##
# Realiza una llamada a la API de QuizAPI y guarda la salida en una variable
##
output=$(curl 'https://quizapi.io/api/v1/questions?apiKey=API_KEY&limit=10' 2>/dev/null)

##
# Obtiene solo la primera pregunta
##
output=$(echo $output | jq .[0])

##
# Obtiene la pregunta
##
question=$(echo $output | jq .question)

##
# Obtiene las respuestas
##
answer_a=$(echo $output | jq .answers.answer_a)
answer_b=$(echo $output | jq .answers.answer_b)
answer_c=$(echo $output | jq .answers.answer_c)
answer_d=$(echo $output | jq .answers.answer_d)

##
# Muestra la pregunta y las respuestas
##
echo "
Pregunta: ${question}
A) ${answer_a}
B) ${answer_b}
C) ${answer_c}
D) ${answer_d}
"

Si ejecutas el script, deberías obtener una salida similar a esta:

bash
Pregunta: ¿Cuál es el lenguaje de programación más popular?
A) Python
B) JavaScript
C) Java
D) C#

Este script obtiene la primera pregunta de la API, extrae sus respuestas y las imprime en un formato limpio y legible.

¡Aquí tienes una forma muy sencilla de escribir un script para ejecutar el Cloudflare DDoS Protection! Este es un reto interesante para practicar. La solución que presentamos es accesible y económica, aunque un sistema de monitoreo como Nagios sería una opción más robusta para un enfoque de mayor escala.

En resumen, la automatización de la protección contra DDoS de Cloudflare usando un script Bash es bastante sencilla, aunque depende de que el servidor siga respondiendo. Si estás buscando algo más avanzado, puedes integrar el monitoreo para hacer que el script sea activado basado en estadísticas de sistemas de monitoreo como Nagios.

Trabajando con la API de Cloudflare con Bash
Yo alojo todos mis sitios web en DigitalOcean Droplets y también uso Cloudflare como mi proveedor de CDN. Una de las ventajas de usar Cloudflare es que reduce el tráfico general a tu usuario y también oculta la dirección IP de tu servidor detrás de su CDN.

Mi característica favorita de Cloudflare es su protección gratuita contra DDoS. Me ha salvado de ataques DDoS en múltiples ocasiones. Cloudflare tiene una API muy útil para habilitar o deshabilitar fácilmente la protección contra DDoS. En este capítulo, te reto a escribir un script Bash que habilite y desactive la protección contra DDoS de Cloudflare automáticamente cuando sea necesario.

Requisitos previos
Antes de seguir este tutorial, asegúrate de tener tu cuenta de Cloudflare configurada y tu sitio web listo. Si no estás seguro de cómo hacerlo, puedes seguir los pasos aquí:

  1. Crear una cuenta de Cloudflare y agregar un sitio web.
    Una vez que tengas tu cuenta de Cloudflare, asegúrate de obtener la siguiente información:
    • Una cuenta de Cloudflare
    • La clave API de Cloudflare
    • El Zone ID de Cloudflare

También asegúrate de que curl esté instalado en tu servidor ejecutando:

bash
curl --version

Si no tienes curl, instálalo dependiendo de tu distribución:

  • Para RedHat/CentOS:
    bash
    yum install curl
  • Para Debian/Ubuntu:
    bash
    apt-get install curl

Desafío - Requisitos del script
El script debe monitorear el uso de CPU en tu servidor y, si el uso de la CPU aumenta mucho, basándose en el número de vCPU, debería activar automáticamente la protección contra DDoS en Cloudflare mediante su API. Las principales características del script deberían ser:

  1. Verificar la carga de CPU en el servidor.
  2. En caso de un aumento de la carga de CPU, el script debería hacer una llamada a la API de Cloudflare y activar la protección contra DDoS para la zona especificada.
  3. Después de que la carga de CPU vuelva a la normalidad, el script desactivará la opción de "Estoy bajo ataque" y la restaurará a su estado normal.

Ejemplo de script
Ya he preparado un script de demostración que puedes usar como referencia. Pero te animo a intentar escribir el script por ti mismo primero, y solo luego mirar mi solución.

Para descargar el script, puedes ejecutar el siguiente comando:

bash
wget https://raw.githubusercontent.com/bobbyiliev/cloudflare-ddos-protection/main/protection.sh

Abre el script con tu editor de texto favorito:

bash
nano protection.sh

Y actualiza los siguientes detalles con tu información de Cloudflare:

bash
CF_CONE_ID=YOUR_CF_ZONE_ID
CF_EMAIL_ADDRESS=YOUR_CF_EMAIL_ADDRESS
CF_API_KEY=YOUR_CF_API_KEY

Después de eso, haz que el script sea ejecutable:

bash
chmod +x ~/protection.sh

Finalmente, configura 2 trabajos de cron para que se ejecuten cada 30 segundos. Para editar tu crontab, ejecuta:

bash
crontab -e

Y agrega el siguiente contenido:

bash
* * * * * /path-to-the-script/cloudflare/protection.sh
* * * * * ( sleep 30 ; /path-to-the-script/cloudflare/protection.sh )

Ten en cuenta que debes cambiar la ruta al script por la ruta real donde has almacenado el script.

Conclusión
Esta solución es bastante directa y asequible, aunque una de las desventajas es que si tu servidor se vuelve no responsable debido a un ataque, el script podría no ejecutarse.

Por supuesto, una mejor solución sería utilizar un sistema de monitoreo como Nagios, basado en las estadísticas del sistema de monitoreo para ejecutar el script, pero este desafío puede ser una buena experiencia de aprendizaje.

Resumen de los logs de acceso de NGINX y Apache con un script BASH
Una de las primeras cosas que haría si noto un uso elevado de CPU en alguno de mis servidores Linux sería revisar la lista de procesos con top o htop, y si noto que hay muchos procesos de Apache o NGINX, rápidamente revisaría los logs de acceso para determinar qué ha causado o está causando el pico de CPU o si hay algo malicioso.

Leer los logs puede ser intimidante, ya que el archivo de log puede ser enorme, y revisarlo manualmente puede llevar mucho tiempo. Además, el formato de log sin procesar puede resultar confuso para quienes tienen menos experiencia.

Requisitos del script
Este script BASH necesita analizar y resumir tus logs de acceso y proporcionarte información útil como:

  • Las 20 páginas principales con más solicitudes POST.
  • Las 20 páginas principales con más solicitudes GET.
  • Las 20 principales direcciones IP y su geolocalización.

Ejemplo de script
He preparado un script de demostración que puedes usar como referencia. Pero te animo a intentar escribir el script por ti mismo primero. Para descargar el script, puedes ejecutar:

bash
git clone https://github.com/bobbyiliev/quick_access_logs_summary.git

O también puedes ejecutar el siguiente comando para descargar el script en tu directorio actual:

bash
wget https://raw.githubusercontent.com/bobbyiliev/quick_access_logs_summary/master/spike_check

El script solo lee el contenido de tu archivo de log y lo resume para ti. Después de descargar el archivo, asegúrate de revisar su contenido por ti mismo.

Ejecutando el script
Una vez que hayas descargado el script, hazlo ejecutable con el siguiente comando:

bash
chmod +x spike_check

Luego, ejecuta el script con:

bash
./spike_check /path/to/your/access_log

Asegúrate de cambiar la ruta al archivo de log con la ruta real a tu archivo de acceso. Por ejemplo, si estás usando Apache en un servidor Ubuntu, el comando exacto sería:

bash
./spike_check /var/log/apache2/access.log

Si usas NGINX, el comando sería casi el mismo, pero con la ruta al log de acceso de NGINX:

bash
./spike_check /var/log/nginx/access.log

Entendiendo la salida
Cuando ejecutes el script, puede tardar un poco dependiendo del tamaño de los logs. La salida que deberías ver tendrá un formato similar a este:

Este enfoque te permitirá obtener un resumen claro y detallado de tus logs de acceso sin la necesidad de herramientas adicionales.

Resumen de la lectura:

Análisis de peticiones POST maliciosas:

En este caso, el script ha identificado 16 solicitudes POST al archivo xmlrpc.php en un servidor de WordPress, una ruta comúnmente explotada por atacantes en intentos de ataques de fuerza bruta. Aunque este caso específico no fue un ataque masivo, es una indicación temprana de un intento que podría escalar. Además, se identificaron algunas direcciones IP rusas, lo que sugiere que si no se espera tráfico de esa región, estas IPs podrían ser bloqueadas para prevenir futuros intentos.

Conclusión: Este es un ejemplo de cómo se puede usar un script Bash simple para analizar y resumir los registros de acceso y detectar comportamientos maliciosos. Si bien una revisión manual de los registros también es útil, automatizar este proceso con Bash puede ahorrar mucho tiempo y esfuerzo.

Envío de correos con Bash usando SSMTP:

SSMTP es una herramienta que permite enviar correos electrónicos desde un servidor hacia un servidor SMTP configurado. Es útil para notificaciones automáticas o alertas del sistema, pero no actúa como un servidor de correo que recibe emails.

Prerrequisitos:

  • Tener acceso a un servidor Ubuntu 18.04 con privilegios de sudo.
  • Tener configurado un servidor SMTP, como el servidor SMTP de Gmail o uno propio.

Instalación de SSMTP:

  1. Actualizar el caché de apt y luego instalar ssmtp y mailutils:
    bash
    sudo apt update
sudo apt install ssmtp
sudo apt install mailutils

Configuración de SSMTP:

  • Modificar el archivo de configuración /etc/ssmtp/ssmtp.conf para incluir tus credenciales SMTP:
    bash
    root=postmaster
mailhub=your_smtp_host.com:587
hostname=your_hostname
AuthUser=your_username@your_smtp_host.com
AuthPass=your_password
FromLineOverride=YES
UseSTARTTLS=YES

Envío de correos con SSMTP: Una vez configurado, puedes enviar un correo usando:

bash
echo "Here add your email body" | mail -s "Email subject" recipient_email@domain.com

Envío de archivos adjuntos: Si necesitas enviar archivos adjuntos, usa mpack. Instálalo y usa el siguiente comando:

bash
sudo apt install mpack
mpack -s "Your Subject here" your_file.zip recipient_email@domain.com

Conclusión: SSMTP es una manera confiable y sencilla de enviar correos electrónicos directamente desde scripts Bash, útil para notificaciones automáticas.

Generador de contraseñas con Bash:

A veces es necesario generar contraseñas aleatorias, ya sea para la instalación de software o para registrarse en sitios web. Aunque se pueden usar administradores de contraseñas, el propio Bash puede generar contraseñas de manera rápida y sencilla.

Prerrequisitos:

  • Un terminal Bash y un editor de texto como nano, vi, o vim.
  • Si usas Windows, puedes SSH a un servidor Linux para ejecutar el script.

Métodos para generar contraseñas aleatorias:

  1. Usar el comando date para obtener una cadena aleatoria:

    bash
    date | md5sum
date | sha256sum
date | base64

  2. Usar OpenSSL para generar bytes pseudo-aleatorios:

    bash
    openssl rand -base64 10

  3. Usar /dev/urandom para generar contraseñas:

    bash
    tr -cd '[:alnum:]' < /dev/urandom | fold -w10 | head -n 1

Script de generador de contraseñas: El siguiente script Bash permite al usuario elegir la longitud de la contraseña y luego genera una lista de 10 contraseñas aleatorias:

bash
#!/bin/bash
# Pregunta por la longitud de la contraseña
clear
printf "\n"
read -p "How many characters you would like the password to have? " pass_length
printf "\n"

# Genera 10 contraseñas aleatorias
for i in {1..10}; do
  tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_length} | head -n 1
done

# Mensaje de despedida
printf "Goodbye, ${USER}\n"

Conclusión: El script de generador de contraseñas es una forma útil y rápida de generar contraseñas seguras desde el terminal. Nota de seguridad: siempre asegúrate de utilizar contraseñas fuertes y considera usar autenticación de dos factores para añadir una capa extra de seguridad.

Consideraciones Finales:

  • Los scripts Bash son herramientas poderosas para automatizar tareas comunes en servidores, desde la protección contra ataques DDoS hasta el envío de correos y la generación de contraseñas.
  • Aunque los ejemplos dados son bastante simples, asegúrate de seguir buenas prácticas de seguridad, como usar contraseñas fuertes y no guardar contraseñas en texto claro.











Publicadas por a la/s
Etiquetas:

No hay comentarios.:

Publicar un comentario

Suscribirse a: Comentarios de la entrada (Atom)