# Automatizando tareas con Bash: Verificación del Sistema

En DevOps, uno de los pilares fundamentales es la **automatización**. Las tareas repetitivas pueden convertirse en cuellos de botella si no se gestionan adecuadamente, y aquí es donde **Bash scripting** juega un papel crucial. Con Bash, puedes crear scripts potentes para monitorear y gestionar sistemas de manera eficiente, especialmente en entornos **Linux**. En esta entrada, te mostraré un script que realiza una serie de chequeos del sistema: uso de CPU, procesos que consumen más recursos, espacio en disco, memoria disponible y verificación de conectividad a Internet. Además, te daré algunos **tips útiles** para aplicar Bash en tus flujos de trabajo DevOps.

## ¿Por qué usar Bash Scripting en DevOps?

* **Automatización**: Te permite automatizar tareas repetitivas como la limpieza de logs, el monitoreo de sistemas y la implementación de aplicaciones.
    
* **Flexibilidad**: Bash es excelente para manejar scripts ligeros, y es especialmente útil en sistemas donde no se pueden instalar herramientas adicionales.
    
* **Ahorro de tiempo**: Un script de verificación del sistema puede ahorrar minutos o incluso horas a lo largo del tiempo, lo cual es invaluable cuando gestionas múltiples servidores.
    
* **Facilidad de uso**: Una vez que dominas Bash, escribir y modificar scripts se vuelve intuitivo, incluso para tareas más complejas.
    

### Ejemplo: Script de Verificación del Sistema

Este es un **script básico** que puedes personalizar para cubrir tus necesidades específicas en DevOps. <mark>Realiza una serie de chequeos de uso de CPU, procesos, disco, memoria, red y conectividad a Internet.</mark>

```bash
#!/bin/bash

# Colores
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

# Variables de configuración
LOG_FILE="/var/log/system-monitor.log"
METRICS_FILE="/var/log/system-metrics.log"
ALERT_CPU_THRESHOLD=80
ALERT_MEM_THRESHOLD=80
ALERT_DISK_THRESHOLD=85
MONITOR_INTERVAL=300  # 5 minutos en segundos

# Mejor manejo de errores
set -euo pipefail
trap 'echo -e "${RED}Error: Comando falló en la línea $LINENO${NC}" | tee -a $LOG_FILE' ERR

# Función de logging mejorada
log_message() {
    local level=$1
    local message=$2
    local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
    echo -e "${timestamp} [$level] $message" | tee -a $LOG_FILE
}

# Función para verificar si se está ejecutando como root
check_root() {
    if [ "$EUID" -ne 0 ]; then 
        log_message "ERROR" "${RED}Este script necesita privilegios de root para instalar paquetes.${NC}"
        log_message "WARNING" "${YELLOW}Por favor, ejecute con sudo.${NC}"
        exit 1
    fi
}

# Función mejorada para instalar dependencias
install_dependencies() {
    local os_type=""
    
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        os_type=$ID
    fi
    
    log_message "INFO" "${BLUE}Verificando e instalando dependencias necesarias...${NC}"
    
    case $os_type in
        "ubuntu"|"debian")
            apt-get update -qq
            packages=(sysstat lm-sensors net-tools)
            for package in "${packages[@]}"; do
                if ! dpkg -l | grep -q "^ii.*$package"; then
                    log_message "INFO" "${GREEN}Instalando $package...${NC}"
                    DEBIAN_FRONTEND=noninteractive apt-get install -y $package
                fi
            done
            ;;
        "centos"|"rhel"|"fedora")
            packages=(sysstat lm_sensors net-tools)
            for package in "${packages[@]}"; do
                if ! rpm -q $package &>/dev/null; then
                    log_message "INFO" "${GREEN}Instalando $package...${NC}"
                    dnf install -y $package
                fi
            done
            ;;
        *)
            log_message "ERROR" "${RED}Sistema operativo no soportado para instalación automática.${NC}"
            exit 1
            ;;
    esac
}

....
```

<mark>Revisa el Código en el </mark> [<mark>Repositorio</mark>](https://github.com/roxsross/roxs-projects-blog/blob/automation/bash/check.sh)

### Explicación del Script

#### 1\. **Verificación de usuario root**

La función `check_root` verifica si el script se está ejecutando con privilegios de root. Muchos comandos, como la instalación de paquetes o la modificación de configuraciones del sistema, requieren permisos elevados.

```bash
check_root() {
    if [ "$EUID" -ne 0 ]; then 
        echo "Este script necesita privilegios de root para instalar paquetes."
        echo "Por favor, ejecute con sudo."
        exit 1
    fi
}
```

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text"><strong>¿Por qué es importante?</strong> Si no tienes permisos de root, ciertas tareas como la instalación de paquetes fallarán, por lo que es fundamental verificar este paso antes de continuar.</div>
</div>

#### 2\. **Instalación de dependencias**

La función `install_dependencies` detecta el tipo de sistema operativo y, según si es basado en Debian (como Ubuntu) o RedHat (como CentOS/Rocky o Fedora), instala herramientas necesarias como `sysstat` (para monitorear la CPU) y `lm-sensors` (para monitorear la temperatura del hardware).

```bash
install_dependencies() {
    # Detectar el sistema operativo y usar apt-get o dnf según sea necesario
    # ...
}
```

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text"><strong>Tip DevOps</strong>: Mantener las dependencias siempre actualizadas en todos tus entornos asegura que los scripts funcionen de manera uniforme en múltiples servidores.</div>
</div>

#### 3\. **Verificación del estado del sistema**

El script genera un reporte con la siguiente información del sistema:

* **Carga de CPU:** Usa `mpstat` para obtener un resumen detallado de la carga de CPU. Si `mpstat` no está instalado, el script recurre a la salida de `top` para mostrar la utilización de la CPU.
    
* **Top procesos por CPU:** Con `ps aux`, se muestra una lista de los procesos que más CPU consumen.
    
* **Espacio en disco:** Muestra el uso del disco usando `df -h`, que lista los sistemas de archivos con el espacio utilizado y disponible.
    
* **Memoria RAM y SWAP:** Usa `free -h` para mostrar el uso de la memoria y el espacio de intercambio (SWAP).
    
* **Estado de la red:** Verifica la conexión a Internet con un simple ping a `8.8.8.8` y muestra las interfaces de red activas usando `ip addr show`.
    
* **Logs recientes:** Muestra los últimos 5 registros de `journalctl`, que es útil para diagnosticar problemas recientes en el sistema.
    

### Mejora y Personalización

Este script es solo un punto de partida, pero puedes ampliarlo para cubrir más escenarios según tus necesidades en DevOps:

1. **Agregar alertas**: Puedes configurar el script para que envíe alertas por correo o Slack si alguna métrica del sistema está fuera de los límites aceptables.
    
    ```bash
    # Envío de alertas si el espacio en disco es bajo
    if [ "$(df / | awk 'NR==2 {print $5}' | sed 's/%//g')" -gt 90 ]; then
        echo "Advertencia: Espacio en disco bajo" | mail -s "Alerta del Sistema" admin@empresa.com
    fi
    ```
    
2. **Cron Jobs**: Si este script es útil para ti, puedes configurarlo para que se ejecute automáticamente cada cierto tiempo usando **cron**.
    
    ```bash
    # Abre el crontab para edición
    crontab -e
    
    # Añade esta línea para ejecutar el script todos los días a las 8 AM
    0 8 * * * /ruta/a/tu/script.sh
    ```
    
3. **Exportar logs**: Puede ser útil guardar los resultados en un archivo de log para un análisis posterior.
    
    ```bash
    # Guardar el resultado del script en un log
    ./script.sh > /var/log/system-check.log
    ```
    

### Tips y Trucos para Bash Scripting en DevOps

1. **Usa variables con cuidado**: Siempre es una buena práctica declarar variables al principio del script. Evita usar nombres de variables que podrían entrar en conflicto con comandos del sistema.
    
2. **Prueba tus scripts en entornos de prueba**: Antes de usar cualquier script en producción, pruébalo en un entorno aislado para asegurarte de que no tenga errores graves.
    
3. **Manejo de errores**: Agregar control de errores mejora la confiabilidad. Utiliza el comando `set -e` para asegurarte de que el script se detenga si ocurre un error grave.
    
4. **Usa comentarios**: Aunque Bash es fácil de entender, comentar cada sección te ayudará a recordar lo que hace cada parte del script cuando vuelvas a verlo en el futuro.
    
5. **Convierte scripts en herramientas reutilizables**: Si ves que un script te resulta útil en más de un proyecto, considera convertirlo en un comando personalizado o empaquetarlo en un archivo ejecutable más formal.
    

### Funcionamiento

Para ejecutar el script [`check.sh`](https://github.com/roxsross/roxs-projects-blog/blob/automation/bash/check.sh), sigue estos pasos:

1. **Abre una terminal**: Accede a tu terminal o consola de comandos.
    
2. **Navega a la ubicación del script**: Utiliza el comando `cd` para cambiar al directorio donde se encuentra el archivo [`check.sh`](https://github.com/roxsross/roxs-projects-blog/blob/automation/bash/check.sh). Por ejemplo, si está en tu carpeta de usuario:
    
    ```bash
    cd /ruta/a/la/carpeta
    ```
    
    Reemplaza `/ruta/a/la/carpeta` con la ruta real.
    
3. **Dale permisos de ejecución**: Asegúrate de que el script tenga permisos de ejecución. Puedes hacerlo con el siguiente comando:
    
    ```bash
    chmod +x check.sh
    ```
    
4. **Ejecuta el script**: Ahora puedes ejecutar el script. Dado que el script requiere privilegios de root para algunas funciones, es recomendable usar `sudo`:
    
    ```bash
    sudo ./check.sh
    ```
    
5. **Proporciona tu contraseña**: Si se te solicita, ingresa tu contraseña de usuario para continuar.
    

### Notas Adicionales

* Asegúrate de que el script está bien escrito y que no contiene errores. Si hay algún problema durante la ejecución, revisa los mensajes de error que aparecen en la consola.
    
* Si deseas que el script se ejecute automáticamente en intervalos regulares, considera agregarlo a un cron job en Linux.
    

<mark>El script </mark> [`check.sh`](http://check.sh) <mark>está diseñado para ser ejecutado en diferentes entornos de desarrollo, lo que te permite aprovechar la flexibilidad de herramientas como Vagrant, Killercoda, y máquinas locales.</mark>

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729788367200/7c74fc66-e89f-40fc-8d29-9678324ffeb6.gif align="center")

### ¿Te Interesa Aprender sobre Vagrant?

Si quieres saber más sobre Vagrant y cómo utilizarlo de manera efectiva en tus proyectos, ¡déjame un comentario! Estoy aquí para armar un tutorial paso a paso que te guiará desde la instalación hasta la configuración de tus entornos de desarrollo. ¡No dudes en preguntar!