Introducción
Un sistema Linux en ejecución es mucho más que sus archivos. El kernel gestiona el hardware y los procesos; cada comando se ejecuta como un proceso con un identificador, y el shell realiza el seguimiento de los trabajos en primer y segundo plano. Los administradores observan primero este estado y después actúan sobre el proceso relevante más pequeño.
En este laboratorio, identificará el sistema operativo y el kernel, interpretará el tiempo de actividad y las medias de carga, inspeccionará las relaciones entre procesos, buscará procesos por nombre, enviará señales de terminación, practicará el control interactivo de trabajos, interpretará el estado de salida, ejecutará un comando desvinculado con nohup y leerá mensajes recientes del kernel.
Identificar el sistema e interpretar la carga
En este paso, identificará el kernel y la distribución, comprobará cuánto tiempo lleva el sistema en ejecución y aprenderá qué representan las medias de carga.
Cree un espacio de trabajo y acceda a él:
mkdir -p /home/labex/project/process-lab
cd /home/labex/project/process-lab
El comando uname informa sobre el kernel. Las opciones -s, -r y -m seleccionan el nombre del kernel, la versión del kernel y la arquitectura de la máquina:
uname -srm
uname -a muestra todos los campos disponibles en una sola línea:
uname -a
El kernel no es lo mismo que la distribución de Linux. Lea los metadatos de la distribución:
cat /etc/os-release
Busque campos como NAME, VERSION e ID. A continuación, compruebe el tiempo de actividad y la carga:
uptime
La salida incluye la hora actual, cuánto tiempo lleva ejecutándose el sistema, el número de usuarios conectados y tres medias de carga. Esas medias describen el trabajo ejecutable o no interrumpible durante aproximadamente 1, 5 y 15 minutos. No son porcentajes; su significado depende en parte del número de núcleos de CPU.
Consulte el registro compacto de carga del kernel:
cat /proc/loadavg
Los tres primeros valores corresponden a la idea de media de carga. Los campos posteriores muestran las tareas ejecutables y el ID de proceso asignado más recientemente.
Guarde un pequeño resumen del sistema para consultarlo más adelante:
uname -srm > system-summary.txt
uptime >> system-summary.txt
cat system-summary.txt
El archivo debe contener una línea con la información del kernel y otra con la información de actividad del sistema.
Inspeccionar procesos y actividad de recursos
En este paso, inspeccionará los identificadores de proceso, las relaciones con los procesos padre, los estados y una instantánea de la actividad de los recursos del sistema.
Un proceso es un programa en ejecución. Cada proceso tiene un ID de proceso, o PID. La mayoría de los procesos también tienen un ID de proceso padre, o PPID, que identifica el proceso que los inició.
El comando ps muestra una instantánea de los procesos. Seleccione campos útiles y ordénelos por PID:
cd /home/labex/project/process-lab
ps -eo pid,ppid,user,stat,comm --sort=pid | head -n 15
La opción -e selecciona todos los procesos y -o define las columnas:
PIDes el identificador del proceso.PPIDes el identificador del proceso padre.USERes el propietario del proceso.STATes el estado del proceso junto con posibles indicadores adicionales.COMMANDes el nombre del ejecutable.
Entre las letras de estado habituales se incluyen R para en ejecución, S para suspensión interrumpible, D para suspensión no interrumpible, T para detenido y Z para zombi. Un proceso en suspensión normalmente solo está esperando trabajo.
La forma de estilo BSD ps aux proporciona columnas de CPU y memoria, además de las líneas de comando completas:
ps aux | head -n 10
top se actualiza continuamente cuando se utiliza de forma interactiva. El modo por lotes produce una instantánea estable: -b selecciona la salida por lotes y -n 1 solicita una actualización.
top -b -n 1 | head -n 12
La cabecera resume el tiempo de actividad, la carga, los estados de las tareas, el uso de CPU y la memoria. La tabla de procesos situada debajo ayuda a localizar los procesos que consumen recursos activamente.
Ahora abra la vista interactiva:
top
Observe cómo se actualizan los valores, localice las columnas %CPU y %MEM y, después, pulse q para volver al shell. top interactivo resulta útil cuando necesita observar cambios a lo largo del tiempo; el modo por lotes es mejor cuando debe guardar la salida o procesarla con otro comando.
Guarde una instantánea centrada en los procesos como resultado verificable:
ps -eo pid,ppid,user,stat,comm --sort=pid > process-snapshot.txt
head -n 5 process-snapshot.txt
Iniciar y localizar un proceso de práctica
En este paso, iniciará un proceso inofensivo en segundo plano, capturará su PID y lo localizará con ps y pgrep.
El & final indica al shell que ejecute un comando en segundo plano y devuelva inmediatamente el prompt. Inicie un proceso sleep de cinco minutos con el nombre visible labex-worker:
cd /home/labex/project/process-lab
bash -c 'exec -a labex-worker sleep 300' &
El valor especial del shell $! contiene el PID del proceso en segundo plano iniciado más recientemente. Guárdelo antes de iniciar otro comando en segundo plano:
worker_pid=$!
echo "$worker_pid" > worker.pid
Inspeccione exactamente ese proceso. La opción -p selecciona un PID y -o elige los campos:
ps -o pid,ppid,user,stat,etime,args -p "$worker_pid"
ETIME muestra el tiempo de ejecución transcurrido, mientras que ARGS incluye el nombre visible del proceso. Utilice pgrep -f para buscar en la línea de comando completa; -a también la muestra:
pgrep -af labex-worker
El PID mostrado por pgrep debe coincidir con el contenido de worker.pid. Buscar mediante un patrón preciso es más seguro que actuar sobre todos los procesos que tengan un nombre general.
Detener procesos con señales
En este paso, solicitará una terminación ordenada con SIGTERM y utilizará SIGKILL únicamente con un proceso diseñado para ignorar esa solicitud.
El comando kill envía una señal a un PID. Si no especifica una señal, envía SIGTERM, la señal 15. SIGTERM solicita un apagado ordenado y da al proceso la oportunidad de realizar tareas de limpieza.
Lea el PID del proceso de trabajo y envíe SIGTERM:
cd /home/labex/project/process-lab
worker_pid=$(cat worker.pid)
kill "$worker_pid"
sleep 1
El siguiente error esperado de ps confirma que el proceso terminó:
ps -p "$worker_pid" || echo "labex-worker stopped after SIGTERM"
Ahora inicie un proceso controlado que ignore intencionadamente SIGTERM:
bash -c 'trap "" TERM; exec -a labex-stubborn sleep 300' &
stubborn_pid=$!
echo "$stubborn_pid" > stubborn.pid
Espere un momento para que el nuevo shell instale su controlador de señales:
sleep 1
Envíe SIGTERM, espere brevemente e inspeccione el proceso:
kill -TERM "$stubborn_pid"
sleep 1
ps -o pid,stat,args -p "$stubborn_pid"
El proceso todavía debe estar presente porque este proceso de práctica ignora SIGTERM. SIGKILL, la señal 9, no se puede capturar ni ignorar. Utilícela únicamente después de que una señal ordenada no haya surtido efecto:
kill -KILL "$stubborn_pid"
Recoja el trabajo en segundo plano terminado. El estado distinto de cero es esperado, por lo que || true permite que la secuencia de práctica continúe:
wait "$stubborn_pid" 2>/dev/null || true
ps -p "$stubborn_pid" || echo "labex-stubborn required SIGKILL"
SIGKILL no da al proceso la oportunidad de guardar su estado ni de liberar correctamente los recursos de la aplicación, por lo que es el último recurso.
kill actúa sobre un PID conocido. Cuando necesite seleccionar un proceso por su nombre o por la línea de comando completa, pkill combina la coincidencia y el envío de señales. Inicie otro proceso controlado con una línea de comando distintiva:
bash -c 'exec -a labex-helper sleep 300' &
helper_pid=$!
echo "$helper_pid" > helper.pid
Confirme la coincidencia exacta de la línea de comando completa antes de actuar:
pgrep -af '^labex-helper 300$'
Envíe SIGTERM a esa coincidencia exacta con pkill -f. Los anclajes ^ y $ evitan que este patrón de formación coincida con líneas de comando no relacionadas:
pkill -TERM -f '^labex-helper 300$'
wait "$helper_pid" 2>/dev/null || true
ps -p "$helper_pid" || echo "labex-helper stopped by pkill"
Utilice patrones precisos con pkill e inspeccione primero las coincidencias mediante pgrep; los patrones amplios pueden detener más procesos de los previstos.
Controlar trabajos en primer y segundo plano
En este paso, suspenderá un comando en primer plano, lo reanudará en segundo plano, lo devolverá al primer plano y lo interrumpirá.
El control de trabajos pertenece al shell interactivo actual. Inicie un proceso sleep en primer plano con un nombre reconocible:
cd /home/labex/project/process-lab
bash -c 'exec -a labex-job sleep 300'
El proceso en primer plano ocupa ahora el terminal. Pulse Ctrl+Z. El shell envía una señal de detención y devuelve el prompt.
Enumere los trabajos conocidos por este shell. La opción -l incluye el ID del proceso:
jobs -l
Debe aparecer un trabajo con el estado Stopped. Reanude el trabajo número 1 en segundo plano:
bg %1
jobs -l
El estado debe ser ahora Running y el prompt debe seguir disponible. Devuelva el trabajo al primer plano:
fg %1
Pulse Ctrl+C para enviar una señal de interrupción al trabajo en primer plano. El prompt debe volver a aparecer. Confirme que no queda ningún trabajo de práctica:
pgrep -af labex-job || echo "No labex-job process remains"
Cree un marcador de finalización después de terminar la secuencia interactiva:
touch job-control.done
Utilice el control de trabajos para los comandos vinculados al terminal actual. Más adelante utilizará nohup para trabajos que no deban depender de la sesión del terminal.
Leer el estado de salida y ejecutar tareas desvinculadas
En este paso, interpretará el estado de salida de un comando y ejecutará una tarea breve en segundo plano cuya salida se conserve de forma independiente de la pantalla del terminal.
Cada comando devuelve un estado entero. Cero significa éxito; un valor distinto de cero indica algún tipo de error. La variable del shell $? contiene el estado del comando que acaba de finalizar.
Ejecute un comando correctamente y, a continuación, muestre inmediatamente su estado:
cd /home/labex/project/process-lab
true
echo "true status: $?"
El resultado es 0. Ahora ejecute un comando que no puede encontrar su ruta:
ls missing-path
Capture su estado antes de que otro comando sustituya el valor de $?:
missing_status=$?
echo "missing-path status: $missing_status"
El valor es distinto de cero. Guarde ambas interpretaciones esperadas:
printf 'success=0\nfailure=%s\n' "$missing_status" > exit-status.txt
El comando nohup hace que un programa ignore la señal de desconexión del terminal. El & final lo inicia en segundo plano. La redirección < /dev/null desconecta la entrada del terminal, mientras que > nohup.log 2>&1 envía ambos flujos de salida a un registro:
nohup bash -c 'for item in one two three; do echo "background: $item"; sleep 1; done' < /dev/null > nohup.log 2>&1 &
Guarde el PID del proceso en segundo plano y permita que la tarea breve termine:
echo $! > nohup.pid
sleep 4
cat nohup.log
Debe ver tres líneas, desde background: one hasta background: three. Para trabajos de larga duración, el PID y el registro guardados ofrecen formas de inspeccionar el progreso.
Inspeccionar mensajes recientes del kernel
En este paso, inspeccionará el búfer de mensajes del kernel y guardará la versión del kernel en ejecución como referencia estable.
El kernel registra mensajes sobre el inicio, el hardware, los controladores y los eventos de ejecución en un búfer circular. dmesg lee ese búfer. Normalmente se requieren privilegios administrativos:
cd /home/labex/project/process-lab
sudo dmesg | tail -n 10
Los mensajes exactos varían según la máquina y el momento. Concéntrese en el campo similar a una marca de tiempo y en el componente o subsistema que produjo cada mensaje.
La opción --level filtra por severidad. Muestre las advertencias y los errores recientes:
sudo dmesg --level=err,warn | tail -n 10
Que no haya salida no significa que el comando haya fallado; puede indicar que el búfer actual no contiene mensajes con esos niveles. Busque en los mensajes recientes términos habituales relacionados con el almacenamiento y la red:
sudo dmesg | grep -Ei 'disk|filesystem|network|eth' | tail -n 10
De nuevo, los resultados dependen del sistema actual. Guarde la versión del kernel indicada por uname -r:
uname -r > kernel-version.txt
cat kernel-version.txt
Los mensajes del kernel son evidencias, no diagnósticos automáticos. Combínelos con el estado de los procesos, los registros de los servicios y los síntomas observados antes de decidir qué acción tomar.
Resumen
Identificó un sistema Linux, interpretó el tiempo de actividad y las medias de carga, e inspeccionó los PID, los procesos padre, los propietarios, los estados y la actividad de los recursos mediante herramientas interactivas y de instantáneas. Inició y localizó procesos con nombre, actuó sobre ellos con precisión mediante kill y pkill, utilizó SIGTERM antes que SIGKILL y practicó el control de trabajos en primer y segundo plano.
También interpretó el estado de salida, ejecutó tareas desvinculadas con nohup y registros explícitos, e inspeccionó mensajes del kernel con dmesg. Estos hábitos de observación previa son la base de una resolución segura de problemas relacionados con procesos y le preparan para los diagnósticos de servicios, registros y redes que estudiará más adelante en el curso.
