Comprender los procesos en Linux

Este tutorial brinda detalles sobre qué son los procesos, cómo se usan y cómo se pueden administrar en Linux.

Como administrador del sistema, probablemente haya interactuado con procesos de muchas maneras diferentes.

A veces, es posible que desee ejecutar comandos para identificar procesos que consumen muchos recursos en su servidor.

Es posible que haya recibido una llamada de un usuario que indica que uno de sus procesos se atascó y que es posible que deba eliminarlo para seguir trabajando.

Los procesos están realmente en el centro del sistema operativo Linux:creados por el mismo Kernel, representan las operaciones en ejecución que están ocurriendo actualmente en su host Linux.

Los procesos están en todas partes, pueden ejecutarse en fondo o puede optar por inicializarlos usted mismo para operaciones personalizadas.

Puede optar por comenzar ellos, para interrumpir ellos, para reanudar ellos o para detener ellos.

En el tutorial de hoy, analizaremos muy de cerca los procesos, qué son y cómo se utilizan en nuestro sistema operativo.

Descubriremos todos los comandos asociados con los procesos, qué son las señales y cómo podemos asignar más recursos computacionales a nuestros procesos existentes.

¿Listo?

Lo que aprenderás

Al leer este tutorial hasta el final, aprenderá sobre los siguientes conceptos

• Qué procesos son y cómo se crean en un sistema Linux
• Cómo se pueden identificar los procesos en un sistema Linux
• ¿Qué antecedentes y primer plano los procesos son
• Qué señales son y cómo se pueden utilizar para interactuar con los procesos
• Cómo utilizar pgrep así como el pkill comandar con eficacia
• Cómo ajustar la prioridad del proceso usando nice y Renice
• Cómo ver la actividad del proceso en tiempo real en Linux

Es un programa bastante largo, así que sin más preámbulos, comencemos con una breve descripción de qué son los procesos.

Conceptos básicos de los procesos de Linux

En resumen, los procesos ejecutan programas en su host Linux que realizan operaciones como escribir en un disco, escribir en un archivo o ejecutar un servidor web, por ejemplo.

El proceso tiene un propietario y se identifican mediante un ID de proceso (también llamado PID )

Por otro lado, los programas son líneas o código o líneas de instrucciones de máquina almacenadas en un almacenamiento de datos persistente.

Pueden simplemente permanecer en su almacenamiento de datos, o pueden estar en ejecución, es decir, ejecutándose como procesos.

Para realizar las operaciones a las que están asignados, los procesos necesitan recursos :tiempo de CPU , memoria (como RAM o espacio en disco ), pero también memoria virtual como espacio de intercambio en caso de que su proceso se vuelva demasiado codicioso.

Obviamente, los procesos pueden ser iniciados , detenido , interrumpido e incluso asesinado .

Antes de emitir cualquier comando, veamos cómo el núcleo mismo crea y administra los procesos.

Inicialización de procesos en Linux

Como ya dijimos, los procesos son gestionados por el Kernel en Linux.

Sin embargo, hay un concepto central que debe comprender para saber cómo Linux crea procesos.

De forma predeterminada, cuando inicia un sistema Linux, su kernel de Linux se carga en la memoria, se le asigna un sistema de archivos virtual en la RAM (también llamado initramfs ) y se ejecutan los comandos iniciales.

Uno de esos comandos inicia el primer proceso en Linux.

Históricamente, este proceso se llamaba proceso init, pero fue reemplazado por el proceso de inicialización systemd en muchas distribuciones recientes de Linux.

Para probarlo, ejecute el siguiente comando en su host

$ ps -aux | head -n 2

Como puede ver, el proceso systemd tiene un PID de 1.

Si tuviera que imprimir todos los procesos en su sistema, usando una visualización de árbol, encontraría que todos los procesos son secundarios del systemd.

$ pstree

Cabe destacar el hecho de que todos esos pasos de inicialización (excepto el lanzamiento del proceso inicial) se realizan en un espacio reservado llamado espacio del kernel.

El espacio del kernel es un espacio reservado para el Kernel para que pueda ejecutar las herramientas esenciales del sistema correctamente y asegurarse de que todo su host se ejecute de manera consistente.

Por otro lado, el espacio del usuario está reservado para los procesos lanzado por el usuario y administrado por el propio núcleo.

Como consecuencia, el proceso systemd es el primer proceso que se inicia en el espacio del usuario.

Creación de Procesos usando Fork y Exec

Cuando crea y ejecuta un programa en Linux, generalmente implica dos pasos principales:bifurcación y ejecutar .

Operación de horquilla

Fork es una operación de clonación, toma el proceso actual, también llamado proceso principal, y lo clona en un nuevo proceso con una ID de proceso completamente nueva.

Al bifurcar, todo se copia del proceso principal:la pila , el montón , pero también los descriptores de archivo que significan la entrada estándar, la salida estándar y el error estándar.

Significa que si mi proceso principal estaba escribiendo en la consola de shell actual, el proceso secundario también escribirá en la consola de shell.

La ejecución del proceso clonado también comenzará en la misma instrucción que el proceso principal.

Ejecutar operación

La operación de ejecución se usa en Linux para reemplazar la imagen del proceso actual con la imagen de otro proceso.

En el diagrama anterior, vimos que la pila del proceso principal contenía tres instrucciones restantes.

Como consecuencia, las instrucciones se copiaron al nuevo proceso pero no son relevantes para lo que queremos ejecutar.

La operación exec reemplazará la imagen del proceso (es decir, el conjunto de instrucciones que deben ejecutarse) por otra.

Si, por ejemplo, ejecutara el comando exec en su terminal bash, su shell terminaría tan pronto como se complete el comando, ya que su imagen de proceso actual (su intérprete bash) sería reemplazada con el contexto del comando que está tratando de ejecutar .

$ exec ls -l

Si tuviera que rastrear las llamadas al sistema realizadas al crear un proceso, encontraría que el primer comando C llamado es el exec.

Creación de procesos desde un entorno shell

Cuando inicia una consola de shell, se aplican exactamente los mismos principios que cuando ejecuta un comando.

Una consola de shell es un proceso que espera la entrada del usuario.

También inicia un intérprete de bash cuando presiona Intro y proporciona un entorno para que se ejecuten sus comandos.

Pero el caparazón sigue los pasos que describimos anteriormente.

Cuando presiona Intro, el shell se bifurca a un proceso secundario que será responsable de ejecutar su comando. El shell esperará pacientemente hasta que finalice la ejecución del proceso secundario.

Por otro lado, el proceso hijo está vinculado a los mismos descriptores de archivo y puede compartir variables que fueron declaradas en un ámbito global.

El proceso hijo ejecuta el “exec ” para reemplazar la imagen del proceso actual (que es la imagen del proceso del shell) en la imagen del proceso del comando que está intentando ejecutar.

El proceso secundario finalmente terminará e imprimirá su resultado en la salida estándar que heredó del proceso principal, en este caso, la propia consola de shell.

Ahora que tiene algunos conceptos básicos sobre cómo se crean los procesos en su entorno Linux, veamos algunos detalles sobre los procesos y cómo se pueden identificar fácilmente.

Identificación de procesos en ejecución en Linux

La forma más fácil de identificar procesos en ejecución en Linux es ejecutar ps comando.

$ ps

De forma predeterminada, el comando ps le mostrará la lista de los procesos en ejecución actuales propiedad del usuario actual.

En este caso, solo se están ejecutando dos procesos para mi usuario:el intérprete de bash y el comando ps Me he topado con él.

La parte importante aquí es que los procesos tienen propietarios , la mayoría de las veces el usuario que los ejecuta en primer lugar.

Para ilustrar esto, tengamos una lista de los primeros diez procesos en su sistema operativo Linux, con un formato de visualización diferente.

$ ps -ef | head -n 10

Como puede ver aquí, los diez procesos principales son propiedad del usuario "root “.

Esta información será especialmente importante a la hora de interactuar con procesos con señales.

Para mostrar los procesos que pertenecen y son ejecutados por el usuario conectado actual, ejecute el siguiente comando

$ ps u

Hay muchas opciones diferentes para el comando ps y se pueden ver ejecutando el comando manual.

$ man ps

Por experiencia, los dos comandos más importantes para ver los procesos en ejecución son

ps aux

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

Eso corresponde a una lista de procesos al estilo BSD , donde el siguiente comando

ps -ef

UID  PID  PPID C STIME TTY  TIME CMD

Corresponde a una lista de procesos de estilo POSIX .

Ambos representan procesos en ejecución actuales en un sistema, pero el primero tiene la opción "u" para "orientado al usuario", lo que facilita la lectura de las métricas del proceso.

Ahora que ha visto qué son los procesos y cómo se pueden enumerar, veamos qué procesos en segundo plano y en primer plano hay en su host.

Procesos en segundo plano y en primer plano

La definición de procesos en segundo plano y en primer plano se explica por sí misma.

Trabajos y procesos en el shell actual

Un proceso en segundo plano en Linux es un proceso que se ejecuta en segundo plano, lo que significa que un usuario no lo administra activamente a través de un shell, por ejemplo.

En el lado opuesto, un proceso en primer plano es un proceso con el que se puede interactuar a través de la entrada directa del usuario.

Digamos, por ejemplo, que abrió una terminal de shell y escribió el siguiente comando en su consola.

$ sleep 10000

Como probablemente haya notado, su terminal se colgará hasta que finalice el proceso de suspensión. Como consecuencia, el proceso no se ejecuta en segundo plano, se ejecuta en primer plano.

Soy capaz de interactuar con él. Si presiono Ctrl + Z, enviará directamente una señal de parada al proceso, por ejemplo.

Sin embargo, existe una forma de ejecutar el proceso en segundo plano.

Para ejecutar un proceso en segundo plano, simplemente coloque un “& ” firme al final de su comando.

$ sleep 10000 &

Como puede ver, el control se devolvió directamente al usuario y el proceso comenzó a ejecutarse en segundo plano

Para ver su proceso ejecutándose, en el contexto del shell actual, puede ejecutar el comando de trabajos

$ jobs

Los trabajos son una lista de procesos que se iniciaron en el contexto del shell actual y que aún pueden estar ejecutándose en segundo plano.

Como puede ver en el ejemplo anterior, actualmente tengo dos procesos ejecutándose en segundo plano.

Las diferentes columnas de izquierda a derecha representan la identificación del trabajo, el estado del proceso (que descubrirá en la siguiente sección), y ejecutó el comando.

Uso de los comandos bg y fg

Para interactuar con trabajos, tiene dos comandos disponibles:bg y fg .

El comando bg se usa en Linux para enviar un proceso a segundo plano y la sintaxis es la siguiente

$ bg %<job_id>

De manera similar, para enviar un proceso al primer plano, puede usar el fg de la misma manera

$ fg %<job_id>

Si volvemos a la lista de trabajos de nuestro ejemplo anterior, si quiero traer el trabajo 3 al primer plano, es decir, a la ventana de shell actual, ejecutaría el siguiente comando

$ fg %3

Al emitir un comando Ctrl + Z, puedo detener el proceso. Puedo vincularlo con un comando bg para enviarlo al fondo.

Ahora que tiene una mejor idea de qué son los procesos en segundo plano y en primer plano, veamos cómo es posible que interactúe con el proceso mediante señales.

Interactuar con procesos usando señales

En Linux, las señales son una forma de comunicación entre procesos (también llamado IPC ) que crea y envía notificaciones asincrónicas a procesos en ejecución sobre la ocurrencia de un evento específico.

Las señales se utilizan a menudo para enviar una muerte o un comando de terminación a un proceso para cerrarlo (también llamado señal de interrupción).

Para enviar una señal a un proceso, debe usar el matar comando.

$ kill -<signal number> <pid>|<process_name>

Por ejemplo, para forzar la finalización de un proceso HTTPD (PID =123) (sin un apagado limpio), debe ejecutar el siguiente comando

$ kill -9 123

Explicación de las categorías de señales

Como se explicó, hay muchas señales que uno puede enviar para notificar un proceso específico.

Aquí está la lista de los usados ​​más comunes:

• INICIO DE SESIÓN :abreviatura de interrupción de señal es una señal utilizada para interrumpir un proceso en ejecución. También es la señal que se envía cuando un usuario presiona Ctrl + C en una terminal;
• SUSCRÍBETE :la abreviatura de Signal Hangup es la señal que envía tu terminal cuando está cerrado. De manera similar a SIGINT, el proceso termina;
• SIGKILL :señal utilizada para forzar la detención de un proceso, ya sea que se pueda detener correctamente o no. Esta señal no puede ser ignorada excepto por el proceso init (o el systemd en distribuciones recientes);

• SIGQUIT :señal específica enviada cuando un usuario quiere salir o salir del proceso actual. Se puede invocar presionando Ctrl + D y a menudo se usa en terminales o en sesiones SSH;
• SIGUSR1, SIGUSR2 :esas señales se usan únicamente con fines de comunicación y se pueden usar en programas para implementar controladores personalizados;
• SIGSTOP :indica al proceso que detenga su ejecución sin terminar el proceso. El proceso entonces está esperando para continuar o para ser eliminado por completo;
• CONT SIG :si el proceso se marca como detenido, le indica al proceso que comience su ejecución nuevamente.

Para ver la lista completa de todas las señales disponibles, puede ejecutar el siguiente comando

$ kill -l

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGSTKFLT
17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU
25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH
29) SIGIO       30) SIGPWR      31) SIGSYS      34) SIGRTMIN
35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4
39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6
59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

Estados de Señales y Procesos

Ahora que sabe que es posible interrumpir, matar o detener procesos, es hora de que aprenda sobre los estados de los procesos.

Los procesos tienen muchos estados diferentes, pueden ser:

• Correr :los procesos en ejecución son los que utilizan alguna potencia computacional (como el tiempo de CPU) en el momento actual. Un proceso también se puede llamar "ejecutable" si se cumplen todas las condiciones de ejecución y está esperando algún tiempo de CPU por parte del programador de CPU.
• Detenido :una señal se detiene está vinculada a la señal SIGSTOP o al atajo de teclado Ctrl + Z. La ejecución del proceso está suspendida y está esperando un SIGCONT o un SIGKILL.
• Dormir :un proceso durmiente es un proceso que espera que algún evento o un recurso (como un disco) esté disponible.

Aquí hay un diagrama que representa los diferentes estados del proceso vinculados a las señales que puede enviarles.

Ahora que sabe un poco más sobre los estados de los procesos, echemos un vistazo a los comandos pgrep y pkill.

Proceso de manipulación con pgrep y pkill

En Linux, ya hay muchas cosas que puede hacer simplemente usando el comando ps.

Puede limitar su búsqueda a un proceso en particular y puede usar el PID para eliminarlo por completo.

Sin embargo, hay dos comandos que fueron diseñados para que sus comandos sean aún más cortos:pgrep y pkill

Usando el comando pgrep

El pgrep comando es un atajo para usar el comando ps canalizado con el comando grep.

El comando pgrep buscará todas las ocurrencias de un proceso específico usando un nombre o un patrón definido.

La sintaxis del comando pgrep es la siguiente

$ pgrep <options> <pattern>

Por ejemplo, si tuviera que buscar todos los procesos llamados "bash" en su host, ejecutaría el siguiente comando

$ pgrep bash

El comando pgrep no está restringido a los procesos que pertenecen al usuario actual de forma predeterminada.

Si otro usuario fuera a ejecutar el comando bash, aparecería en la salida del comando pgrep.

También es posible buscar procesos utilizando caracteres globales.

Usando el comando pkill

Por otro lado, el comando pkill también es un atajo para el comando ps que se usa con el comando kill.

El comando pkill se usa para enviar señales a los procesos en función de sus ID o sus nombres.

La sintaxis del comando pkill es la siguiente

$ pkill <options> <pattern>

Por ejemplo, si desea eliminar todas las ventanas de Firefox en su host, debe ejecutar el siguiente comando

$ pkill firefox

De manera similar al comando pgrep, tiene la opción de reducir los resultados especificando un usuario con la opción -u.

Para eliminar todos los procesos que comiencen con "fuego" y sean propiedad del usuario actual y raíz, debe ejecutar el siguiente comando

$ pkill user,root fire*

Si no tiene los derechos para detener un proceso, recibirá un mensaje de error de permiso denegado en su salida estándar.

También tiene la opción de enviar señales específicas especificando el número de señal en el comando pkill

Por ejemplo, para detener Firefox con una señal SIGSTOP, ejecutaría el siguiente comando

$ pkill -19 firefox

Ajuste de la prioridad del proceso usando nice y renice

En Linux, no todos los procesos tienen la misma prioridad en lo que respecta al tiempo de CPU.

A algunos procesos, como los procesos muy importantes ejecutados por root, se les da una mayor prioridad para que el sistema operativo trabaje en tareas que realmente le importan al sistema.

La prioridad del proceso en Linux se denomina nivel agradable.

El nivel agradable es una escala de prioridad que va de -20 a 19.

Cuanto más bajo vayas en la escala de amabilidad, mayor será la prioridad.

Del mismo modo, cuanto más alto se encuentre en la escala de amabilidad, menor será su prioridad.

Para recordarlo, puedes recordar el hecho de que “cuanto más amable eres, más dispuesto estás a compartir recursos con los demás”.

Para iniciar un determinado programa o proceso con un buen nivel determinado, ejecutará el siguiente comando

$ nice -n <level> <command>

Por ejemplo, para ejecutar el comando tar con un nivel de tar personalizado, ejecutaría el siguiente comando

$ nice -n 19 tar -cvf test.tar file

De manera similar, puede usar el comando renice para establecer el nivel agradable de un proceso en ejecución en un valor dado.

$ renice -n <priority> <pid>

Por ejemplo, si tengo un proceso en ejecución con el PID 123, puedo usar el comando renice para establecer su prioridad en un valor dado.

$ renice -n 18 123

Amabilidad y permisos

Si no es miembro del grupo sudo (o miembro del grupo rueda en las distribuciones basadas en Red Hat), existen algunas restricciones en lo que se refiere a lo que puede hacer con el comando agradable.

Para ilustrarlo, intente ejecutar el siguiente comando como un usuario que no sea sudo

$ nice -n -1 tar -cvf test.tar file

nice: cannot set niceness: Permission denied

Cuando se trata de amabilidad, hay una regla que debes saber:

Como usuario no root (o sudo), no podrá establecer un nivel de Niza más bajo que el asignado por defecto (que es cero), y no podrá volver a configurar un proceso en ejecución para un nivel inferior al actual.

Para ilustrar el último punto, inicie un comando de suspensión en segundo plano con un buen valor de 2.

$ nice -n 2 sleep 10000 &

A continuación, identifique el ID de proceso del proceso que acaba de crear.

Ahora, intente establecer el nivel agradable de su proceso en un valor inferior al que especificó en primer lugar.

$ renice -n 1 8363

Como probablemente notó, no podrá establecer el nivel de amabilidad en 1, sino solo en un valor superior al que especificó.

Ahora, si elige ejecutar el comando como sudo, podrá establecer el nivel agradable en un valor más bajo.

Ahora que tiene una idea clara de los comandos nice y renice, veamos cómo puede monitorear sus procesos en tiempo real en Linux.

Monitoreo de procesos en Linux usando top y htop

En un artículo anterior, discutimos cómo es posible construir una tubería de monitoreo completa para monitorear los procesos de Linux en tiempo real.

Uso de top en Linux

Top es un comando interactivo que cualquier usuario puede ejecutar para tener una lista completa y ordenada de todos los procesos que se ejecutan en un host Linux.

Para ejecutar top, simplemente ejecútelo sin ningún argumento.

Top se ejecutará en modo interactivo.

$ htop

Si desea ejecutar top para un número personalizado de iteraciones, ejecute el siguiente comando

$ top -n <number>

El comando superior primero mostrará estadísticas resumidas sobre su sistema en la parte superior, por ejemplo, la cantidad de tareas en ejecución, el porcentaje de CPU utilizado o el consumo de memoria.

Justo debajo, tiene acceso a una lista en vivo de todos los procesos que se ejecutan o duermen en su host.

Esta vista se actualizará cada tres segundos, pero obviamente puedes modificar este parámetro.

Para aumentar la frecuencia de actualización en el comando superior, presione el comando "d" y elija una nueva frecuencia de actualización

Del mismo modo, puede cambiar el valor agradable de un proceso en ejecución en vivo presionando la tecla "r" en su teclado.

Se aplican las mismas reglas de permisos si desea modificar los procesos a un valor inferior al que ya están asignados.

Como consecuencia, es posible que deba ejecutar el comando como sudo.

Uso de htop en Linux

Alternativamente, si está buscando una forma más agradable de visualizar los procesos en su host Linux, puede usar el comando htop.

De forma predeterminada, el comando htop no está disponible en la mayoría de las distribuciones, por lo que deberá instalarlo con las siguientes instrucciones.

$ sudo apt-get update
$ sudo apt-get install htop

Si está ejecutando una distribución basada en Red Hat, ejecute los siguientes comandos.

$ sudo yum -y install epel-release
$ sudo yum -y update
$ sudo yum -y install htop

Finalmente, para ejecutar el comando htop, simplemente ejecútelo sin argumentos.

$ htop

Como puede ver, la salida es muy similar excepto que muestra información en una salida más amigable para los humanos.

Conclusión

En este tutorial, aprendió muchos conceptos sobre procesos:cómo se crean, cómo se pueden administrar y cómo se pueden monitorear de manera efectiva.

Si está buscando más tutoriales relacionados con la administración del sistema Linux, tenemos una sección completa dedicada a ello en el sitio web, así que asegúrese de consultarla.