# Module 4

## Monitoreo y Optimización de Recursos del Sistema

### 🎯 Learning Objectives

After completing this module, you will be able to:

- Monitorear uso de CPU y memoria utilizando comandos top y htop
- Analizar consumo de espacio en disco con df y du
- Gestionar procesos del sistema usando ps, kill y nice
- Identificar cuellos de botella de rendimiento en el sistema
- Optimizar recursos mediante ajuste de prioridades de procesos

Click Next → to begin.

## Fundamentos de Gestión de Recursos del Sistema

## Arquitectura de Gestión de Recursos en Linux

Linux gestiona cuatro recursos críticos del sistema: CPU (procesador), memoria RAM, almacenamiento en disco y entrada/salida (I/O). El kernel de Linux actúa como administrador central, asignando estos recursos a procesos según políticas de prioridad y disponibilidad.

Cada proceso en ejecución consume recursos del sistema. El kernel rastrea el uso mediante estructuras de datos en el directorio `/proc`, un sistema de archivos virtual que proporciona información en tiempo real sobre procesos y recursos del sistema.

## Métricas Clave de Rendimiento

Para optimizar el rendimiento del sistema, los administradores monitorean:

- Uso de CPU: Porcentaje de tiempo que el procesador dedica a ejecutar código de usuario vs. sistema
- Carga del sistema (load average): Promedio de procesos en cola esperando recursos de CPU
- Memoria disponible: RAM libre vs. utilizada, incluyendo caché y buffers
- Espacio en disco: Capacidad utilizada vs. disponible en sistemas de archivos
- Operaciones I/O: Velocidad de lectura/escritura en dispositivos de almacenamiento

## Conceptos de Optimización

La optimización del sistema implica identificar y resolver cuellos de botella — componentes que limitan el rendimiento general. Un proceso puede consumir CPU excesivamente, agotar la memoria disponible o saturar el subsistema de disco.

Los administradores utilizan herramientas de monitoreo para:

1. Identificar procesos problemáticos
2. Analizar patrones de consumo de recursos
3. Ajustar prioridades o terminar procesos según sea necesario
4. Prevenir problemas mediante monitoreo proactivo

Linux proporciona un conjunto robusto de comandos integrados que permiten monitoreo en tiempo real sin necesidad de software adicional.

Diagrama arquitectónico que muestra el kernel de Linux en el centro distribuyendo recursos (CPU, memoria, disco, I/O) a múltiples procesos en ejecución

#### 💡 Key Takeaways

- Linux gestiona CPU, memoria, disco e I/O como recursos críticos del sistema
- El directorio /proc proporciona información en tiempo real sobre recursos
- Las métricas clave incluyen uso de CPU, carga del sistema, memoria y espacio en disco
- La optimización identifica cuellos de botella y ajusta el uso de recursos

## Monitoreo de CPU con top y htop

## Comando top: Interpretación de Salida

El comando `top` proporciona una vista dinámica en tiempo real de los procesos en ejecución. La salida se actualiza cada pocos segundos y muestra:

Línea de resumen del sistema:

- uptime: Tiempo transcurrido desde el último reinicio
- users: Número de usuarios conectados
- load average: Promedios de carga del sistema en 1, 5 y 15 minutos

Estadísticas de CPU:

- us (user): Tiempo de CPU en procesos de usuario
- sy (system): Tiempo de CPU en procesos del kernel
- ni (nice): Tiempo de CPU en procesos con prioridad ajustada
- id (idle): Porcentaje de CPU inactiva
- wa (wait): Tiempo esperando operaciones de I/O

Lista de procesos: Cada proceso muestra PID (identificador), usuario propietario, prioridad (PR), valor nice (NI), uso de memoria (%MEM), uso de CPU (%CPU) y comando ejecutado.

## Herramienta htop: Interfaz Interactiva

`htop` es una versión mejorada de `top` con interfaz a color e interacción con mouse. Características destacadas:

- Visualización por núcleo: Barras separadas para cada núcleo de CPU
- Navegación intuitiva: Teclas de flecha para desplazarse, F9 para enviar señales
- Filtrado: F4 para filtrar procesos por nombre
- Árbol de procesos: F5 muestra jerarquía padre-hijo
- Ordenamiento flexible: Click en encabezados de columna para ordenar

Comandos útiles en `htop`:

- F6: Seleccionar criterio de ordenamiento
- F9: Enviar señal a proceso seleccionado
- F10: Salir de htop
- Space: Marcar proceso para operaciones en lote

Captura de pantalla ilustrada de la interfaz htop mostrando barras de CPU por núcleo, uso de memoria y lista de procesos con código de colores

#### 💡 Key Takeaways

- top muestra procesos en tiempo real con estadísticas de CPU, memoria y carga del sistema
- Load average indica presión sobre la CPU: valores > número de núcleos señalan saturación
- htop proporciona interfaz interactiva con visualización por núcleo y navegación mejorada
- Ambas herramientas permiten identificar rápidamente procesos que consumen recursos excesivos

## Análisis de Memoria y Disco

## Monitoreo de Memoria: free y /proc/meminfo

El comando `free` muestra estadísticas de uso de memoria del sistema:

    free -h

La opción `-h` presenta valores en formato legible (MB, GB). Campos importantes:

- total: Memoria RAM total instalada
- used: Memoria utilizada por procesos
- free: Memoria completamente sin usar
- available: Memoria disponible para nuevos procesos (incluye caché recuperable)
- buff/cache: Memoria usada para buffers y caché del kernel

El archivo `/proc/meminfo` proporciona información detallada:

    cat /proc/meminfo | grep -E 'MemTotal|MemFree|MemAvailable'

Nota importante: Linux utiliza memoria libre para caché de disco, mejorando el rendimiento. Esta memoria se libera automáticamente cuando los procesos la necesitan.

## Análisis de Disco: df y du

df (disk free) muestra espacio disponible en sistemas de archivos montados:

    df -h

Muestra puntos de montaje, tamaño total, espacio usado, disponible y porcentaje de uso.

du (disk usage) calcula espacio utilizado por directorios:

    du -sh /var/log/*

Opciones útiles:

- `-s`: Resumir (solo total)
- `-h`: Formato legible
- `-c`: Mostrar total general

Escenarios comunes:

- Identificar directorios que ocupan más espacio: `du -sh /* | sort -h`
- Encontrar archivos grandes: `find /home -type f -size +100M`
- Monitorear crecimiento de logs: `du -sh /var/log/ && sleep 60 && du -sh /var/log/`

Infografía mostrando barras comparativas de uso de memoria (total, used, free, available, buff/cache) y barras de sistemas de archivos con porcentajes de uso de disco

#### 💡 Key Takeaways

- free muestra memoria total, usada y disponible; buff/cache es memoria recuperable
- /proc/meminfo proporciona estadísticas detalladas de memoria del kernel
- df analiza espacio en sistemas de archivos montados, du calcula uso por directorio
- Combinar df y du ayuda a identificar particiones llenas y archivos que ocupan más espacio

## Gestión Avanzada de Procesos

## Listar Procesos: ps aux y ps -ef

El comando `ps` muestra procesos en ejecución. Dos formatos comunes:

BSD style:

    ps aux

Muestra todos los procesos de todos los usuarios con uso de CPU y memoria.

UNIX style:

    ps -ef

Muestra formato completo incluyendo PPID (Parent Process ID) — útil para rastrear jerarquías.

Filtrar procesos específicos:

    ps aux | grep apache2

## Señales de Procesos

Las señales son mensajes que el kernel envía a procesos. Principales señales:

- SIGTERM (15): Solicitud de terminación normal — permite limpieza
- SIGKILL (9): Terminación forzada inmediata — sin limpieza
- SIGHUP (1): Recarga de configuración (hang up)
- SIGSTOP (19): Pausar proceso
- SIGCONT (18): Reanudar proceso pausado

## Comandos kill y killall

kill envía señales a procesos por PID:

    kill -15 1234        # SIGTERM al proceso 1234
    kill -9 1234         # SIGKILL forzado
    kill -SIGTERM 1234   # Formato alternativo

killall envía señales a procesos por nombre:

    killall -15 firefox  # Termina todos los procesos firefox
    killall -9 chrome    # Fuerza terminación de chrome

Mejor práctica: Siempre intente SIGTERM (15) primero para permitir limpieza adecuada. Use SIGKILL (9) solo cuando SIGTERM falle.

## Prioridades: nice y renice

Los valores nice determinan prioridad de CPU:

- Rango: -20 (máxima prioridad) a +19 (mínima prioridad)
- Default: 0
- Usuarios normales: Solo pueden aumentar nice (reducir prioridad)
- root: Puede establecer cualquier valor

nice inicia procesos con prioridad ajustada:

    nice -n 10 ./script-pesado.sh

renice modifica prioridad de procesos en ejecución:

    renice -n 5 -p 1234      # Ajusta proceso 1234
    renice -n 10 -u usuario  # Ajusta todos los procesos del usuario

Diagrama de flujo ilustrando el ciclo de vida de un proceso desde inicio hasta terminación, mostrando diferentes señales y sus efectos

#### 💡 Key Takeaways

- ps aux y ps -ef muestran procesos en ejecución con diferentes formatos de salida
- SIGTERM permite terminación limpia; SIGKILL fuerza terminación inmediata
- kill envía señales por PID; killall envía señales por nombre de proceso
- nice y renice ajustan prioridad de CPU (valores -20 a +19)

## Carga del Sistema y Uptime

## Comando uptime y Promedios de Carga

El comando `uptime` proporciona información rápida sobre el estado del sistema:

    uptime

Salida típica:

    14:23:45 up 7 days, 3:42, 2 users, load average: 0.15, 0.25, 0.30

Componentes de la salida:

- Hora actual: 14:23:45
- Tiempo de actividad: 7 días, 3 horas, 42 minutos desde último reinicio
- Usuarios conectados: 2 sesiones activas
- Load average: Promedios de carga en 1, 5 y 15 minutos

## Interpretación de Load Average

Los valores de load average representan el número promedio de procesos en estado ejecutable o esperando por CPU:

En sistemas de un solo núcleo:

- < 1.0: Sistema saludable con recursos disponibles
- 1.0: CPU completamente utilizada pero no saturada
- > 1.0: Procesos esperando — posible cuello de botella

En sistemas multinúcleo: Divida el load average por el número de núcleos. Un sistema de 4 núcleos:

- Load de 4.0 = 100% de utilización (1.0 por núcleo)
- Load de 2.0 = 50% de utilización (0.5 por núcleo)
- Load de 8.0 = 200% de utilización — sistema saturado

Verificar número de núcleos:

    nproc

o

    lscpu | grep '^CPU(s):'

## Análisis de Tendencias

Los tres valores de load average revelan tendencias:

- Valores decrecientes (2.5, 1.8, 1.2): Carga disminuyendo — situación mejorando
- Valores crecientes (0.8, 1.5, 2.3): Carga aumentando — posible problema desarrollándose
- Valores estables (1.0, 1.0, 1.0): Carga constante — patrón predecible

Mejor práctica: Monitoree load average regularmente y establezca alertas cuando supere el número de núcleos por períodos prolongados.

Gráfico de línea temporal mostrando tres curvas de load average (1, 5 y 15 minutos) con zona verde (saludable), amarilla (advertencia) y roja (saturación) según número de núcleos

#### 💡 Key Takeaways

- uptime muestra tiempo de actividad del sistema y promedios de carga en 1, 5 y 15 minutos
- Load average indica procesos esperando CPU; valores > número de núcleos señalan saturación
- Tres valores de load average revelan tendencias: crecientes, decrecientes o estables
- Divida load average por número de núcleos para calcular porcentaje de utilización

## Monitoreo de Entrada/Salida

## Herramienta iostat

El comando `iostat` (parte del paquete `sysstat`) reporta estadísticas de CPU y dispositivos de I/O:

    iostat -x 2 5

Opciones:

- `-x`: Estadísticas extendidas de dispositivos
- `2`: Intervalo de 2 segundos
- `5`: Mostrar 5 iteraciones

Métricas clave de dispositivos:

- r/s: Lecturas por segundo
- w/s: Escrituras por segundo
- rkB/s: Kilobytes leídos por segundo
- wkB/s: Kilobytes escritos por segundo
- await: Tiempo promedio de espera para operaciones I/O (ms)
- %util: Porcentaje de tiempo que el dispositivo estuvo ocupado

Interpretación:

- %util cerca de 100%: Dispositivo saturado — cuello de botella
- await alto (>20ms en SSD, >100ms en HDD): Latencia excesiva
- rkB/s y wkB/s altos: Actividad intensa de disco

## Comando iotop

`iotop` muestra uso de I/O por proceso en tiempo real (requiere permisos de root):

    sudo iotop

Características:

- Ordenamiento por velocidad de lectura/escritura
- Identificación de procesos causando I/O intensivo
- Interfaz similar a `top` pero enfocada en disco

Comandos interactivos:

- `o`: Mostrar solo procesos con I/O activo
- `a`: Acumular I/O en lugar de mostrar velocidad actual
- `left/right`: Cambiar criterio de ordenamiento

## Análisis de Cuellos de Botella de I/O

Señales de problemas de I/O:

1. Alta utilización de disco (%util >80% sostenido)
2. Tiempos de espera elevados (await >50ms)
3. Procesos en estado D (espera no interrumpible de I/O)
4. Load average alto con CPU idle (wa% alto en `top`)

Soluciones comunes:

- Identificar procesos con `iotop` y optimizar o limitar
- Reducir escrituras innecesarias en logs
- Implementar caché más agresivo
- Migrar a almacenamiento más rápido (SSD)
- Distribuir carga entre múltiples discos

Visualización de métricas de I/O mostrando discos con indicadores de lectura/escritura, porcentaje de utilización y tiempos de espera con código de colores

#### 💡 Key Takeaways

- iostat reporta estadísticas de CPU y dispositivos de I/O con métricas de rendimiento
- %util cerca de 100% indica saturación de dispositivo — cuello de botella de I/O
- iotop identifica procesos específicos causando actividad de disco intensiva
- await alto y load average con CPU idle señalan problemas de entrada/salida

## 🔬 Monitoreo y Optimización de Recursos del Sistema en Ubuntu

Objective: Aprender a monitorear el uso de recursos del sistema (CPU, memoria, disco) utilizando herramientas de línea de comandos, gestionar procesos activos y optimizar el rendimiento mediante ajuste de prioridades.

⏱ Estimated time: 45 minutes💻 Platform: Ubuntu Linux (20.04 o superior)
Prerequisites:

- Acceso a terminal con usuario estándar (no root)
- Privilegios sudo configurados
- Conexión a Internet para instalar herramientas adicionales

### Procedures

1 Verificar el estado general del sistema con el comando uptime

El comando `uptime` muestra cuánto tiempo lleva ejecutándose el sistema y los promedios de carga. Ejecuta:

    uptime

Los tres números al final representan el promedio de carga del sistema en los últimos 1, 5 y 15 minutos. Un valor inferior al número de CPUs indica un sistema saludable.

✓ Expected Output

    10:23:45 up 2 days, 3:14, 1 user, load average: 0.52, 0.58, 0.59

🔍 Verify: Verifica que el comando muestre la hora actual, el tiempo de actividad y tres valores de carga promedio.
2 Monitorear el uso de memoria del sistema con el comando free

Usa `free` con la opción `-h` para mostrar la información en formato legible para humanos:

    free -h

Para ver actualizaciones continuas cada 2 segundos:

    free -h -s 2

Presiona `Ctrl+C` para detener el monitoreo continuo. Observa las columnas:

- total: Memoria total instalada
- used: Memoria en uso
- free: Memoria libre
- available: Memoria disponible para nuevos procesos (incluye caché reutilizable)

✓ Expected Output

                  total        used        free      shared  buff/cache   available
    Mem:           7.7G        2.1G        3.2G        156M        2.4G        5.2G
    Swap:          2.0G          0B        2.0G

🔍 Verify: Confirma que la columna 'available' muestre memoria suficiente para operaciones normales (al menos 20% del total).
3 Instalar y ejecutar htop para monitoreo interactivo

Primero, instala `htop` si no está disponible:

    sudo apt update
    sudo apt install htop -y

Luego ejecuta htop:

    htop

En la interfaz de htop:

- Las barras superiores muestran el uso de CPU y memoria
- La lista muestra procesos ordenados por uso de CPU
- Usa las teclas de flecha para navegar
- Presiona `F6` para cambiar el criterio de ordenamiento
- Presiona `F5` para vista de árbol de procesos
- Presiona `q` para salir

✓ Expected Output

    Interfaz interactiva con barras de colores mostrando CPUs [||||  25.3%], memoria y swap, seguida de una lista de procesos con columnas PID, USER, PRI, NI, VIRT, RES, SHR, S, CPU%, MEM%, TIME+, Command

🔍 Verify: Verifica que puedas ver las barras de CPU individuales y la lista de procesos actualizada en tiempo real.
4 Analizar el espacio en disco con el comando df

Usa `df` para ver el espacio disponible en todos los sistemas de archivos montados:

    df -h

Para ver solo sistemas de archivos reales (excluir temporales):

    df -h -x tmpfs -x devtmpfs

La columna Use% indica el porcentaje de espacio utilizado. Valores superiores al 80% requieren atención.

✓ Expected Output

    Filesystem      Size  Used Avail Use% Mounted on
    /dev/sda1        50G   28G   20G  59% /
    /dev/sda2       100G   45G   50G  48% /home

🔍 Verify: Confirma que ningún sistema de archivos muestre un uso superior al 90%.
5 Identificar directorios que consumen más espacio con du

Navega a tu directorio home y analiza el uso de espacio:

    cd ~
    du -h --max-depth=1 | sort -hr | head -n 10

Este comando:

- `du -h --max-depth=1`: Muestra el tamaño de directorios en el nivel actual
- `sort -hr`: Ordena numéricamente en orden descendente
- `head -n 10`: Muestra los 10 directorios más grandes

Para analizar un directorio específico en detalle:

    du -sh ~/.cache/*

✓ Expected Output

    2.4G    ./Downloads
    1.8G    ./Documents
    845M    ./.cache
    234M    ./Pictures
    89M     ./.local
    45M     ./Videos

🔍 Verify: Verifica que el comando identifique los directorios más grandes en tu directorio home.
6 Listar todos los procesos activos usando el comando ps

Ejecuta `ps aux` para ver todos los procesos del sistema:

    ps aux | head -n 20

Para buscar un proceso específico por nombre:

    ps aux | grep firefox

Para ver procesos en formato de árbol:

    ps auxf | less

Columnas importantes:

- USER: Usuario propietario del proceso
- PID: ID del proceso
- %CPU: Porcentaje de uso de CPU
- %MEM: Porcentaje de uso de memoria
- COMMAND: Comando que inició el proceso

✓ Expected Output

    USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root         1  0.0  0.1 169704 11428 ?        Ss   Dec18   0:03 /sbin/init
    root         2  0.0  0.0      0     0 ?        S    Dec18   0:00 [kthreadd]
    student   1234  2.5  3.2 2456789 98765 ?       Sl   10:20   1:23 /usr/bin/firefox

🔍 Verify: Confirma que puedas identificar el PID, usuario y uso de recursos de cualquier proceso.
7 Crear un proceso de prueba con consumo de CPU

Crea un script simple que consuma CPU para propósitos de prueba:

    cat > ~/cpu_test.sh << 'EOF'
    #!/bin/bash
    # Script de prueba para consumo de CPU
    echo "Iniciando proceso de prueba con PID: $$"
    while true; do
        echo "Procesando..." > /dev/null
    done
    EOF

Haz el script ejecutable:

    chmod +x ~/cpu_test.sh

Ejecútalo en segundo plano:

    ~/cpu_test.sh &

Anota el número PID que se muestra. También puedes obtenerlo con:

    ps aux | grep cpu_test.sh | grep -v grep

✓ Expected Output

    [1] 5678
    Iniciando proceso de prueba con PID: 5678

🔍 Verify: Usa el comando `top` o `htop` brevemente para confirmar que el proceso cpu_test.sh aparece consumiendo CPU. Anota el PID.
8 Monitorear el proceso de prueba con top

Ejecuta `top` y observa el proceso que acabas de crear:

    top

Dentro de top:

- Presiona `Shift+P` para ordenar por uso de CPU
- Presiona `Shift+M` para ordenar por uso de memoria
- Presiona `k` para preparar el envío de señal a un proceso (no lo hagas aún)
- Presiona `q` para salir

Busca tu proceso `cpu_test.sh` en la lista. Debería mostrar un uso elevado de CPU.

✓ Expected Output

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    5678 student  20   0    8456   3244   2788 R  99.3   0.1   0:45.32 cpu_test.sh

🔍 Verify: Confirma que el proceso cpu_test.sh aparezca en la lista de top con un porcentaje de CPU alto (superior al 50%).
9 Modificar la prioridad del proceso con renice

Primero, verifica la prioridad actual del proceso (columna NI en top o htop). El valor de nice va de -20 (mayor prioridad) a 19 (menor prioridad). El valor predeterminado es 0.

Reduce la prioridad del proceso de prueba para que consuma menos recursos (reemplaza 5678 con tu PID real):

    renice +10 -p 5678

Verifica el cambio:

    ps -o pid,ni,comm -p 5678

El valor NI debería mostrar ahora 10. Procesos con valores más altos de nice obtienen menos tiempo de CPU.

✓ Expected Output

    5678 (process ID 5678) old priority 0, new priority 10
      PID  NI COMMAND
     5678  10 cpu_test.sh

🔍 Verify: Confirma que el valor NI (nice) del proceso haya cambiado a 10 usando el comando ps mostrado.
10 Enviar señal SIGTERM al proceso de prueba

La señal SIGTERM (15) solicita amablemente a un proceso que termine. Envía esta señal a tu proceso de prueba:

    kill -15 5678

O de forma equivalente:

    kill -SIGTERM 5678

Verifica si el proceso terminó:

    ps -p 5678

Si el proceso aún existe (algunos procesos ignoran SIGTERM), verás su información. Si terminó correctamente, verás un mensaje de error.

✓ Expected Output

    PID TTY          TIME CMD
    (o)
    error: process ID list syntax error
    (si el proceso terminó exitosamente)

🔍 Verify: Ejecuta `ps aux | grep cpu_test.sh` y confirma que el proceso ya no aparece en la lista.
11 Practicar con SIGKILL en un nuevo proceso de prueba

Inicia nuevamente el script de prueba:

    ~/cpu_test.sh &

Anota el nuevo PID. Esta vez, usa la señal SIGKILL (9) que termina forzosamente el proceso sin darle oportunidad de limpieza:

    kill -9 [NUEVO_PID]

Por ejemplo, si el PID es 6234:

    kill -9 6234

SIGKILL no puede ser ignorada por el proceso y lo termina inmediatamente.

✓ Expected Output

    [1]+  Killed                  ~/cpu_test.sh

🔍 Verify: Confirma que el mensaje 'Killed' aparezca en la terminal y que `ps aux | grep cpu_test.sh` no muestre el proceso.
12 Usar killall para terminar procesos por nombre

Inicia dos instancias del script de prueba:

    ~/cpu_test.sh &
    ~/cpu_test.sh &

Verifica que ambas instancias estén ejecutándose:

    ps aux | grep cpu_test.sh | grep -v grep

Usa `killall` para terminar todas las instancias por nombre:

    killall cpu_test.sh

Este comando envía SIGTERM por defecto. Para forzar la terminación:

    killall -9 cpu_test.sh

✓ Expected Output

    [1]-  Terminated              ~/cpu_test.sh
    [2]+  Terminated              ~/cpu_test.sh

🔍 Verify: Ejecuta `ps aux | grep cpu_test.sh` y confirma que no existan instancias del script en ejecución.
13 Analizar información detallada de memoria del sistema

El archivo `/proc/meminfo` contiene información detallada sobre la memoria del sistema. Visualiza su contenido:

    cat /proc/meminfo | head -n 20

Para ver valores específicos:

    grep -E 'MemTotal|MemFree|MemAvailable|Cached|SwapTotal|SwapFree' /proc/meminfo

Para calcular el porcentaje de memoria en uso:

    free | grep Mem | awk '{print "Uso de memoria: " ($3/$2) * 100 "%"}'

✓ Expected Output

    MemTotal:        8052564 kB
    MemFree:         3256788 kB
    MemAvailable:    5489632 kB
    Cached:          2145876 kB
    SwapTotal:       2097148 kB
    SwapFree:        2097148 kB
    Uso de memoria: 35.6789%

🔍 Verify: Confirma que puedas identificar la memoria total, disponible y el uso de swap en el sistema.
14 Monitorear procesos con alto consumo de memoria

Identifica los 10 procesos que consumen más memoria:

    ps aux --sort=-%mem | head -n 11

Para un formato más compacto mostrando solo información relevante:

    ps aux --sort=-%mem | awk 'NR==1 || NR<=11 {printf "%-10s %-6s %5s %5s %s\n", $1, $2, $3, $4, $11}'

Esto muestra: USER, PID, %CPU, %MEM y COMMAND para los procesos con mayor uso de memoria.

✓ Expected Output

    USER       PID    %CPU  %MEM COMMAND
    student    2345   1.2   8.9  /usr/lib/firefox/firefox
    student    3456   0.5   5.4  /usr/bin/gnome-shell
    root       1234   0.1   3.2  /usr/sbin/mysqld

🔍 Verify: Verifica que la lista muestre procesos ordenados de mayor a menor consumo de memoria (columna %MEM).
15 Limpiar archivos de prueba y verificar el aprendizaje

Elimina el script de prueba creado:

    rm ~/cpu_test.sh

Verifica que no queden procesos de prueba ejecutándose:

    ps aux | grep cpu_test

Ejecuta un resumen final de recursos del sistema:

    echo "=== Estado del Sistema ==="
    uptime
    echo ""
    echo "=== Memoria ==="
    free -h | grep -E 'Mem|Swap'
    echo ""
    echo "=== Espacio en Disco ==="
    df -h / /home 2>/dev/null | grep -v tmpfs

✓ Expected Output

    === Estado del Sistema ===
    11:45:32 up 2 days, 4:36, 1 user, load average: 0.45, 0.52, 0.58

    === Memoria ===
    Mem:           7.7G        2.3G        3.1G        145M        2.3G        5.1G
    Swap:          2.0G          0B        2.0G

    === Espacio en Disco ===
    /dev/sda1        50G   28G   20G  59% /
    /dev/sda2       100G   45G   50G  48% /home

🔍 Verify: Confirma que el script de prueba fue eliminado y que el resumen muestre información coherente del sistema.

### ⚠️ Troubleshooting

El comando htop no se encuentra o muestra 'command not found'

Instala htop ejecutando: `sudo apt update && sudo apt install htop -y`. Si no tienes privilegios sudo, usa el comando `top` que viene preinstalado en todos los sistemas Linux.

Al ejecutar kill no termina el proceso y sigue apareciendo en ps

Algunos procesos pueden ignorar SIGTERM (señal 15). Espera 5-10 segundos y vuelve a verificar con `ps`. Si persiste, usa `kill -9 PID` para enviar SIGKILL, que no puede ser ignorada. Verifica que estés usando el PID correcto.

El comando renice muestra 'Permission denied' al intentar cambiar la prioridad

Solo puedes reducir la prioridad (aumentar el valor nice) de tus propios procesos sin sudo. Para aumentar la prioridad (valores negativos de nice) o modificar procesos de otros usuarios, necesitas usar: `sudo renice -5 -p PID`. Usuarios normales solo pueden usar valores de nice de 0 a 19.

El script cpu_test.sh no consume CPU como se esperaba

Verifica que el script esté ejecutándose en segundo plano con `jobs` o `ps aux | grep cpu_test`. Si terminó automáticamente, revisa que lo hayas iniciado con `&` al final. Si el sistema tiene múltiples CPUs, el consumo puede distribuirse. Usa `htop` para ver el uso por CPU individual.

El comando du tarda mucho tiempo en ejecutarse o no muestra resultados

El comando `du` analiza todo el contenido de directorios, lo cual puede tardar en directorios grandes. Presiona `Ctrl+C` si tarda mucho. Usa `--max-depth=1` para limitar la profundidad del análisis o analiza directorios específicos más pequeños. Evita ejecutar `du` en directorios del sistema como `/` sin privilegios adecuados.

### 🏆 Optimización de Sistema Bajo Carga

Apply what you learned — complete this task without step-by-step guidance.

Escenario: Tu sistema Ubuntu está experimentando lentitud. Debes identificar la causa y optimizar el rendimiento.

Tareas a completar:

1. Simular carga del sistema: Crea tres scripts diferentes que consuman recursos:

   - Un script que consuma CPU continuamente
   - Un script que cree múltiples archivos pequeños para simular actividad de disco
   - Un script que genere un bucle creando variables en memoria

2. Diagnóstico: Sin detener los scripts, utiliza las herramientas aprendidas para:

   - Identificar cuál proceso consume más CPU
   - Determinar cuál proceso consume más memoria
   - Verificar si hay espacio en disco suficiente
   - Obtener el promedio de carga del sistema

3. Optimización: Basándote en tu análisis:

   - Ajusta las prioridades de los procesos según su importancia (el de memoria es crítico, el de CPU puede tener baja prioridad)
   - Termina el proceso que crea archivos si el espacio en disco baja del 80%
   - Documenta en un archivo de texto los comandos que usaste y los resultados obtenidos

4. Monitoreo continuo: Configura un comando que actualice cada 5 segundos un archivo de log con:

   - Timestamp actual
   - Uso de CPU de los tres procesos
   - Memoria disponible
   - Espacio libre en disco

Criterios de éxito:

- Los tres scripts de simulación deben ejecutarse simultáneamente
- Debes poder identificar correctamente el proceso con mayor consumo de cada recurso
- Las prioridades deben reflejar la importancia de cada proceso
- El archivo de log debe generarse automáticamente y mostrar tendencias de uso
- Todos los procesos deben terminarse de forma controlada al finalizar

Pista: Investiga cómo usar `watch`, `tee` y redirección de salida para el monitoreo continuo. Considera usar `basename` para identificar procesos por nombre de script.

I have completed this lab exercise

## 📝 Knowledge Check

Test your understanding of the material covered in this module. Select the best answer for each question.

#### Question 1

En la salida de `top`, observas que el valor 'wa' (wait) es 45%. ¿Qué indica esto?

A) La CPU está esperando que se completen operaciones de entrada/salida (I/O) B) La memoria RAM está casi agotada y el sistema está usando swap C) El sistema tiene 45% de CPU disponible para nuevos procesos D) Hay 45 procesos en estado de espera (waiting)

#### Question 2

Necesitas terminar un proceso que no responde a SIGTERM. ¿Qué comando es más apropiado?

A) kill -1 PID B) kill -9 PID C) kill -15 PID D) kill -STOP PID

#### Question 3

El comando `free -h` muestra 'available: 512M' pero 'free: 50M'. ¿Qué significa esto?

A) El sistema tiene un problema de memoria y necesita reiniciarse B) Hay 512 MB disponibles para nuevos procesos; la diferencia está en buff/cache recuperable C) Solo 50 MB están realmente disponibles; 512 MB es un error de cálculo D) El sistema está usando 462 MB de swap

#### Question 4

En un servidor con 8 núcleos de CPU, el comando `uptime` muestra 'load average: 12.5, 10.2, 8.7'. ¿Cuál es la interpretación correcta?

A) El sistema está funcionando normalmente — load average siempre debe ser >10 B) El sistema está saturado; hay más procesos esperando CPU que núcleos disponibles, y la carga está aumentando C) El sistema está mejorando; la carga ha disminuido de 12.5 a 8.7 en los últimos 15 minutos D) El load average no es relevante en sistemas multinúcleo

#### Question 5

¿Qué comando muestra cuánto espacio en disco ocupa el directorio /var/log y todos sus subdirectorios en formato legible?

A) df -h /var/log B) du -sh /var/log C) ls -lh /var/log D) free -h /var/log

#### Question 6

Un proceso con PID 2345 está consumiendo 90% de CPU. ¿Qué comando lo reduce a prioridad más baja sin terminarlo?

A) kill -19 2345 B) renice -n 15 -p 2345 C) nice -n -10 -p 2345 D) killall -STOP 2345

#### Question 7

En `iostat -x`, observas que un disco muestra '%util: 98%' y 'await: 150ms' consistentemente. ¿Qué indica esto?

A) El disco está funcionando óptimamente al 98% de su capacidad B) El disco es un cuello de botella — está saturado y las operaciones de I/O tienen latencia alta C) El disco tiene 98% de espacio utilizado y necesita limpieza D) El await de 150ms es normal para discos SSD modernos

#### Question 8

¿Cuál es la mejor práctica para terminar un servicio que ya no responde?

A) Siempre usar kill -9 inmediatamente para garantizar terminación rápida B) Reiniciar el servidor completo para asegurar limpieza total C) Primero intentar kill -15 (SIGTERM) para permitir limpieza, luego kill -9 (SIGKILL) si falla D) Usar killall sin especificar señal — deja que el sistema decida

## 🎯 Module Summary

Este módulo cubrió herramientas esenciales para monitorear y optimizar recursos del sistema Linux. Aprendiste a usar `top` y `htop` para analizar uso de CPU, `free` y `/proc/meminfo` para monitorear memoria, `df` y `du` para gestionar espacio en disco, y `ps`, `kill`, `nice` para controlar procesos. También exploraste interpretación de load average con `uptime` y análisis de I/O con `iostat` e `iotop`. Dominar estas herramientas permite identificar cuellos de botella de rendimiento, gestionar recursos eficientemente y mantener sistemas Linux saludables y optimizados.

### Learning Objectives — Review

- Monitorear uso de CPU y memoria utilizando comandos top y htop
- Analizar consumo de espacio en disco con df y du
- Gestionar procesos del sistema usando ps, kill y nice
- Identificar cuellos de botella de rendimiento en el sistema
- Optimizar recursos mediante ajuste de prioridades de procesos

🎉

### Module Complete!

You have completed all sections of this module.