Objetivos

Aprender a gestionar procesos en primer y segundo plano utilizando comandos como jobs, fg y bg.
Aplicar señales para suspender, reanudar y finalizar procesos con kill, pkill y killall.
Identificar procesos en ejecución y analizar el impacto de la carga del sistema mediante herramientas como ps, top y uptime.
Ejecutar scripts que generan carga de CPU y evaluar su efecto en el promedio de carga del sistema.
Monitorear y administrar procesos en tiempo real utilizando top, ajustando la visualización y eliminando procesos desde su interfaz interactiva.

Entorno Inicial

Usuario: student
Máquina: servera
Contraseña inicial: student
Herramientas utilizadas: Shell Bash y utilidades básicas de Linux.

Pasos del Laboratorio

Prerequisitos

Inicio de sesión
- Inicia sesión en la máquina servera desde bastion como el usuario student utilizando la llave privada proporcionada:
```
ssh student-#-servera
```

Parte 1: Control de Trabajos en Bash

Abrir dos terminales
- Abre dos ventanas de terminal, una al lado de la otra.
- En cada terminal, inicia sesión en la máquina servera desde bastion como el usuario student:
```
ssh student-#-servera
```
Crear un script de prueba
- En la terminal izquierda, crea el directorio /home/student/bin:
```
mkdir /home/student/bin
```
- Dentro de este directorio, crea un script llamado control:
```
vim /home/student/bin/control
```
- Escribe el siguiente contenido en el script:
```
#!/bin/bash
while true; do
    echo -n "$@ " >> ~/control_outfile
    sleep 1
done
```
- Guarda y cierra el archivo (:wq).
- Hacer el script ejecutable:
```
chmod +x /home/student/bin/control
```
Ejecutar el script
```
control technical
```

Verificar salida

En la terminal derecha:

tail -f ~/control_outfile

Salida esperada:

technical technical technical technical ...

Suspender y reanudar el proceso
- En la terminal izquierda, suspende con Ctrl + Z.
- En la terminal derecha, verificar que la salida del comando tail se ha detenido.
- Luego terminal izquierda vea la lista de trabajos:
```
jobs
```
- Reinicie el trabajo en segundo plano:
```
bg
```
- Verificar que el trabajo se está ejecutando nuevamente:
```
jobs
```
- En la terminal derecha verificar la salida esperada:
```
technical technical technical technical ...
```
Cerrar sesión del usuario student en ambas terminales
```
exit
```

Parte 2: Finalización y Gestión de Procesos con Señales

Abrir dos terminales
- Abre dos ventanas de terminal, una al lado de la otra.
- En cada terminal, inicia sesión en la máquina servera desde bastion como el usuario student:
```
ssh student-#-servera
```
Crear un script de prueba
- En la terminal izquierda dentro del directorio bin, crea un script llamado instance:
```
vim /home/student/bin/instance
```
- Escribe el siguiente contenido en el script:
```
#!/bin/bash
while true; do
  echo -n "$@ " >> ~/instance_outfile
  sleep 5
done
```
- Guarda y cierra el archivo (:wq).
- Hacer el script ejecutable
```
chmod +x /home/student/bin/instance
```

Ejecutar múltiples procesos

instance network &

instance interface &

instance connection &

Verificar salida

En la terminal derecha:

tail -f ~/instance_outfile

Salida esperada:

network interface network connection ...

Suspender un proceso con SIGSTOP
- En la terminal izquierda verificamos los trabajos en segundo plano:
```
jobs
```
- Suspendemos el proceso:
```
kill -SIGSTOP %1
```
- Verificamos nuevamente:
```
jobs
```
Finalizar un proceso con SIGTERM
- En la terminal izquierda verificamos los trabajos en segundo plano:
```
jobs
```
- Finalizamos el proceso:
```
kill -SIGTERM %2
```
- Verificamos nuevamente:
```
jobs
```
Reanudar un proceso con SIGCONT
- En la terminal izquierda verificamos los trabajos en segundo plano:
```
jobs
```
- Reanudamos el proceso:
```
kill -SIGCONT %1
```
- Verificamos nuevamente:
```
jobs
```

Finalizar procesos restantes

kill -SIGTERM %1  
kill -SIGTERM %3  
jobs

Finalizar procesos tail

ps -ef | grep tail
pkill -SIGTERM tail
ps -ef | grep tail

Cerrar sesión en ambas terminales
```
exit
```

Parte 3: Monitoreo de Procesos con `top`

Abrir dos terminales
- Abre dos ventanas de terminal, una al lado de la otra.
- En cada terminal, inicia sesión en la máquina servera desde bastion como el usuario student:
```
ssh student-#-servera
```

Crear un script de carga de CPU

En la terminal izquierda dentro del directorio bin, crea un script llamado monitor:

vim /home/student/bin/monitor

Escribe el siguiente contenido en el script:

#!/bin/bash
while true; do
    var=1
    while [[ var -lt 60000 ]]; do
        var=$(($var+1))
    done
    sleep 1
done

Guarda y cierra el archivo (:wq).
Hacer el script ejecutable:

chmod +x /home/student/bin/monitor

Monitorear con top en la terminal derecha:
```
top
```
Verificar la cantidad de CPU en la terminal izquierda:
```
lscpu
```
Ejecutar script en segundo plano
```
monitor &
```
- Verifica el proceso en top y anota su PID.
Ejecutar múltiples instancias adicionales
```
monitor &
monitor &
```

En la terminal derecha verificar el aumento del uso de CPU:

Salida esperada:

 PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
6881 student   20   0  222448   3032   2784 S  18.6   0.2   0:11.48 monitor
6498 student   20   0  222448   2996   2748 S  15.6   0.2   0:47.86 monitor
6071 student   20   0  222448   2964   2716 S  18.1   0.2   2:07.86 monitor

Finalizar procesos desde top
- Presiona k, ingresa PID, y confirma con señal 15 (SIGTERM).
Cerrar sesión en ambas terminales
```
exit
```

Resultados Esperados

Los participantes podrán gestionar procesos eficientemente, moviéndolos entre primer y segundo plano según sus necesidades.
Se aplicarán señales adecuadas para controlar la ejecución de procesos, asegurando una administración segura y efectiva.
Se interpretará correctamente el promedio de carga, identificando su relación con el uso de CPU y procesos en espera.
Se observarán los efectos de múltiples procesos simultáneos en el rendimiento del sistema y se aplicarán estrategias para su optimización.
Se utilizará top para monitorear procesos en tiempo real y administrar su ejecución de forma práctica.