103.5 - Crear, supervisar y matar procesos

Importancia

4

Descripción

El candidato debe ser capaz de realizar una gestión básica de los procesos.

Áreas de conocimiento clave:

  • Ejecutar trabajos en primer y segundo plano.

  • Enviar señales a los programas para que continúen ejecutándose después del cierre de sesión.

  • Supervisar procesos activos.

  • Seleccionar y ordenar procesos para su visualización.

  • Enviar señales a los procesos.

Contenidos

Control de trabajos

Los trabajos (Jobs) son procesos que se han iniciado de forma interactiva a través de un terminal, enviados a un segundo plano y aún no han finalizado la ejecución. Puedes conocer los trabajos activos (y su estado) en Linux ejecutando jobs.

El comando jobs anterior no produjo ningún resultado, lo que significa que no hay trabajos activos en este momento. Creemos nuestro primer trabajo ejecutando un comando que tarde un poco en finalizar la ejecución (el comando sleep con un parámetro de 60) y, mientras se ejecuta, presione Ctrl + Z: 

sleep 60
^Z
#Resultado: [1]+ Stopped sleep 60

La ejecución del comando se ha detenido (o, mejor dicho, suspendido) y el símbolo del sistema vuelve a estar disponible, si pruebas a ejecutar jobs otra vez, buscará trabajos por segunda vez y encontrará el suspendido.

En el resultado verás [1], es el ID del trabajo y se puede utilizar, precedido por % para cambiar el estado del trabajo mediante las utilidades bg y kill más adelante).

Y el signo + indica el trabajo actual predeterminado (es decir, el último suspendido o enviado al segundo plano). El trabajo anterior está marcado con un signo menos (-). Cualquier otro trabajo anterior no está marcado.

Otros parámetros del comando son:

Recuerda que un trabajo tiene un ID de trabajo y un ID de proceso (PID).

Especificaciones de trabajos

El comando jobs, así como otras utilidades como fg, bg y kill (que verá en la siguiente sección) necesitan una especificación de trabajo (o jobspec) para actuar sobre un trabajo en particular. Como acabamos de ver, esto puede ser, y normalmente es, el ID del trabajo precedido por %. Sin embargo, otras especificaciones de trabajo también son posibles. Echemos un vistazo a ellos:

  • %n -> Trabajo cuyo número de identificación es n .

  • %str -> Trabajo cuya línea de comando comienza con str .

  • %?str -> Trabajo cuya línea de comando contiene str .

  • %+ o %% -> Trabajo actual (el último que se inició en segundo plano o suspendido del primer plano).

  • %- -> Trabajo anterior (el que era % + antes del predeterminado, el actual).

Por ejemplo:

Estado del trabajo: suspensión, primer plano y segundo plano

Una vez que un trabajo está en segundo plano o ha sido suspendido, podemos hacer cualquiera de estas tres cosas:

  1. Llevarlo al primer plano con fg (foreground):

fg mueve el trabajo especificado al primer plano y lo convierte en el trabajo actual. Ahora podemos esperar hasta que termine, detenerlo nuevamente con Ctrl+Z o terminarlo con Ctrl+C.

  1. Llevarlo a un segundo plano con bg (background):

Una vez en segundo plano, el trabajo se puede volver a poner en primer plano con fg o matar (ver más abajo). Ten en cuenta el signo (&) que significa que el trabajo se ha enviado a segundo plano. De hecho, también puede usar el signo y comenzar un proceso directamente en segundo plano:

  1. Termine con una señal SIGTERM con kill:

Para asegurarnos de que el trabajo ha finalizado, ejecuta nuevamente jobs.

Trabajos separados: nohup

Los trabajos que hemos visto en las secciones anteriores se adjuntaron a la sesión del usuario que los invocó. Eso significa que si la sesión se termina, los trabajos desaparecen. Sin embargo, es posible separar los trabajos de las sesiones y hacer que se ejecuten incluso después de cerrar la sesión. Esto se logra con el comando nohup (“no hangup”).

Separemos el trabajo en segundo plano ping localhost de la sesión actual:

La salida nos muestra la ID del trabajo ([1]) y el PID ( 1251), seguido de un mensaje que nos informa sobre el archivo nohup.out. Este es el archivo predeterminado donde se guardarán stdout y stderr.

Ahora podemos presionar sesión, iniciar otro como Ctrl + C para liberar el símbolo del sistema, cerrar la root y usar tail -f para verificar si el comando se está ejecutando y la salida se está escribiendo en el archivo predeterminado:

Si queremos matar el proceso, debemos especificar su PID:

Si te has olvidado del PID del proceso, puedes buscar con ps aux | grep ping

Caso práctico: Cazador de pdfs

Vamos a aprender cómo ejecutar procesos en segundo plano de forma persistente con nohup, incluso si cerramos la terminal. Para hacerlo más interesante, simularemos un "cazador de PDFs" 🔍📂.

1️⃣ Preparación: Creación de archivos PDF de prueba

Primero, asegúrate de estar en tu carpeta de inicio y crea varios archivos PDF:

Para hacerlo aún más divertido, usa un bucle para crear muchos más de golpe:

2️⃣ Búsqueda manual de archivos PDF

Antes de usar nohup, probemos el comando find manualmente para ver qué resultados obtenemos:

Este comando busca archivos con la extensión .pdf en tu carpeta de inicio.

3️⃣ Ejecutando la búsqueda con nohup

Ahora vamos a ejecutar la búsqueda, pero asegurándonos de que siga funcionando aunque cerremos la terminal:

El & al final hace que el proceso se ejecute en segundo plano. La salida se guarda por defecto en un archivo llamado nohup.out.

💡 Ejercicio: Abre una nueva terminal y revisa el contenido de nohup.out con:

4️⃣ Personalizando la salida

En lugar de dejar que nohup use el archivo predeterminado, redirigiremos la salida a un archivo específico:

Ahora, revisemos si el archivo resultados_pdf.out se está generando:

5️⃣ Verificando que el proceso sigue corriendo

Ejecuta este comando para listar los procesos en ejecución y comprobar si find aún está trabajando:

Si el proceso aún está en marcha, significa que nohup lo está manteniendo activo. Si ya terminó, es porque la búsqueda fue rápida.

6️⃣ Deteniendo un proceso en segundo plano (si es necesario)

Si por alguna razón quieres detener la búsqueda antes de que termine, puedes encontrar su ID de proceso (PID) y matarlo:

(Recuerda reemplazar <PID> con el número de proceso que aparece en la salida del comando ps aux).

Caso práctico: El Contador Secreto de Archivos con nohup

1️⃣ Creando un "laberinto" de archivos 🏗️

Para hacer esto más interesante, primero generaremos varias carpetas con archivos dentro:

Con esto, habremos creado 5 carpetas y distribuido 20 archivos de forma aleatoria en ellas.

Puedes ver la estructura con ls -R

2️⃣ Contando archivos de forma tradicional

Probemos el comando find manualmente para contar los archivos:

Esto nos dirá cuántos archivos hay en la carpeta mi_experimento.

3️⃣ Haciendo el conteo persistente con nohup 🚀

Ahora usaremos nohup para contar archivos y asegurarnos de que siga ejecutándose aunque cerremos la terminal:

El proceso se ejecutará en segundo plano y guardará la cantidad de archivos en conteo_archivos.out.

🔍 Ejercicio:

  • Cierra la terminal y ábrela de nuevo.

  • Verifica si el archivo conteo_archivos.out tiene el resultado con:

4️⃣ Creando más archivos para ver el efecto de nohup

Mientras el proceso sigue corriendo, agreguemos más archivos:

Luego, volvamos a revisar el conteo:

¿El resultado ha cambiado? 🤔 Si no, prueba ejecutar de nuevo el comando de conteo.

Pureba ahora a borrar algun archivo y vuelve a revisar.

5️⃣ Para ver los cambios en tiempo real:

Para detener el proceso:

(Recuerda reemplazar <PID> con el número de proceso correcto).

Monitorización de procesos

Un proceso o tarea es una instancia de un programa en ejecución. Por lo tanto, se crean nuevos procesos cada vez que escribe comandos en el terminal. El comando watch ejecuta un programa periódicamente (2 segundos por defecto) y nos permite mirar el cambio de salida del programa con el tiempo. Por ejemplo, podemos monitorear cómo cambia el promedio de carga a medida que se ejecutan más procesos escribiendo watch uptime

El comando se ejecuta hasta que se interrumpe, por lo que deberíamos detenerlo con Ctrl + C. Obtenemos dos líneas como salida: la primera corresponde a watch y nos dice con qué frecuencia se ejecutará el comando ( Every 2.0s: uptime), qué comando/programa mirar ( uptime) así como el comando nombre de host y fecha ( debian: mar 20 de agosto 23:31:27 2019). La segunda línea de salida es el tiempo de actividad e incluye la hora ( 23:31:27), cuánto tiempo ha estado activo el sistema ( up 21 min), el número de usuarios activos ( 1 usuario) y carga promedio del sistema o número de procesos en ejecución o en estado de espera durante los últimos 1, 5 y 15 minutos ( promedio de carga: 0.00, 0.00, 0.00).

Del mismo modo, puedes verificar el uso de la memoria a medida que se crean nuevos procesos con watch free.

Para cambiar el intervalo de actualización para watch usa las opciones -n o --interval más el número de segundos con watch -n 5 free

Envío de señales a procesos: kill

El comando kill, a pesar de su nombre, es un comando que envia señales a procesos. Cada proceso tiene un identificador de proceso único o PID. Una forma de averiguar el PID de un proceso es mediante el comando pgrep o pidof seguido del nombre del proceso:

Similar a pgrep, el comando pkill mata un proceso basado en su nombre:

Para matar varias instancias del mismo proceso, se puede usar el comando killall

Tanto pkill como killall funcionan de la misma manera que kill en que envían una señal de terminación a los procesos especificados. Si no se proporciona ninguna señal, se envía el valor predeterminado de SIGTERM. Sin embargo, kill solo toma un trabajo o una ID de proceso como argumento. Las señales se pueden especificar por nombre, numero o con opciones.

Para que kill funcione de manera similar a pkill o killall (y nos ahorremos los comandos para descubrir los PID primero) podemos usar la sustitución de comandos:

Tambien podemos cerrar los procesos de un usuario (por ejemplo por una sesión abierta descontrolada a un intruso):

Algunas señales comunes a enviar (recuerda que con kill -l puedes revisarlos todos):

Comando
Señal
Descripción

kill -2

SIGINT

Interrumpir un proceso (Ctrl + C).

kill -9

SIGKILL

Mata el proceso de golpe, es más agresivo, puede dejar procesos "zombie". No hay ningun proceso inmutable para este comando. Último recurso.

kill -15

SIGTERM

termina lo que estas haciendo y finaliza, reubica todos los procesos que dependen de él a otros procesos.

kill -18

SIGCONT

continue, reanuda un proceso en pausa pero lo hace en el terminal desde que has lanzado el comando por lo que el ctrl+C ya no hace caso. Se ha pasado a segundo plano. Si queremos reanudar ponemos manualmente el kill -2

kill -19

SIGSTOP

stop, proceso en pausa (Ctrl+Z), por ejemplo con el buscaminas o el pìng. El proceso podemos seguir viéndolo.

Top y ps

Cuando se trata de monitoreo de procesos, dos herramientas invaluables son top y ps. Mientras que el primero produce resultados dinámicamente, el segundo lo hace estáticamente. En cualquier caso, ambos son excelentes utilidades para tener una visión integral de todos los procesos en el sistema.

top te muestra los procesos en tiempo real, es como un administrador de tareas.

  • Con la letra "f" puedes modificar la vista de filtros y añadir o quitar columnas con "espacio".

  • Con derecha o izquierda puedes mover las columnas también.

  • Con "r" (renice) cambias la prioridad de un proceso, esto lo veremos más adelante.

  • Con "M" ordena por uso de memoria, con "N" por numero de ID, con "T" por tiempo de ejecución y con "P" por porcentaje de CPU.

  • Para salir con "q".

Captura de ejemplo de la salida de top

La salida top se divide en dos áreas: el área resumen y el área de tareas.

En el área de resumen se compone de las cinco filas superiores y nos proporciona la siguiente información:

  • Hora actual (formato 24 horas): 11:20:29

  • Tiempo de actividad (cantidad de tiempo que el equipo ha estado activo y funcionando): 2:21 up

  • Número de usuarios conectados y promedio de carga de la CPU durante los últimos 1, 5 y 15 minutos, respectivamente:

Esta linea se puede invocar, además con el comando uptime

  • Número total de procesos en modo activo

  • Ejecutándose (los ejecutados en el momento)

  • Durmiendo (aquellos que esperan reanudar la ejecución)

  • Detenido (por una señal de control de trabajo)

  • Zombie (aquellos que han completado la ejecución pero todavía están esperando que su proceso padre los elimine de la tabla de procesos)

  • Procesos de usuario (us)

  • Procesos de sistema/kernel (sy)

  • Procesos establecidos en un valor nice — cuanto mejor sea el valor, menor será la prioridad (ni)

  • Nada — tiempo de inactividad de la CPU (id)

  • Procesos en espera de operaciones de E/S (wa)

  • Procesos que sirven interrupciones de hardware — periféricos que envían las señales del procesador que requieren atención (hi)

  • Procesos que sirven interrupciones de software (si)

  • Los procesos que sirven las tareas de otras máquinas virtuales en un entorno virtual, por lo tanto, roban tiempo (st)

  • Monto total de memoria

  • Memoria sin utilizar

  • Memoria en uso

  • La memoria intermedia (buffer) y almacenada en caché para evitar el acceso excesivo al disco

Observa cómo el total es la suma de los otros tres valores .

  • La cantidad total de espacio de swap

  • Espacio de swap no utilizado

  • Espacio en uso de swap

  • La cantidad de memoria de intercambio que se puede asignar a los procesos sin causar más intercambio

La información de la memoria se puede obtener con el comando free o free -h para que te lo muestre en "human-readeable"

El área de tareas en top: campos y columnas

Debajo del área de resumen, aparece el área de tareas, que incluye una serie de campos y columnas de información sobre los procesos en ejecución:

  • PID Identificador de proceso.

  • USER Usuario que emitió el comando que generó el proceso.

  • PR Prioridad de proceso en el kernel.

  • NI Valor nice del proceso. Los valores más bajos tienen mayor prioridad que los más altos.

  • VIRT Cantidad total de memoria utilizada por el proceso (incluido la swap).

  • RES Memoria RAM utilizada por el proceso.

  • SHR Memoria compartida del proceso con otros procesos.

  • S Estado del proceso. Los valores incluyen: S (suspensión interrumpible — esperando que termine un evento), R (ejecutable — ya sea en ejecución o en la cola que se ejecutará) o Z (procesos secundarios terminados en zombies cuyas estructuras de datos aún no se han eliminado de la tabla de procesos).

  • %CPU Porcentaje de CPU utilizado por el proceso.

  • %MEM Porcentaje de RAM utilizada por el proceso, es decir, el valor RES expresado como porcentaje.

  • TIME+ Tiempo total de actividad del proceso.

  • COMMAND Nombre del comando/programa que generó el proceso..

A parte de top existen otras utilidades relacionadas que aumentan la experiencia de usuario de gestión de procesos, una es htop y la otra es bottom

  • htop viene instalada por defecto en distribuciones Ubuntu sino puedes instalarla con un simple apt install

  • bottom es un proyecto open-source cross-platform para un montón de distros que puedes encontrar aquí.

    • Para instalarlo simplemente ejecuta:

Luego el comando es btm

Visualización de procesos estáticos

Como se dijo anteriormente, ps muestra una instantánea de los procesos. Para ver todos los procesos con un terminal (tty), escriba ps a o ps -p 811 para buscar un proceso por su PID.

Al final, este comando es un snapshot de los procesos que hay en el sistema en el momento en que se ejecuta el comando pero no los ves en vivo sino la instantánea:

Del mismo modo, para buscar los procesos iniciados por un usuario en particular usaremos:

Podemos configurar los parámetros que nos interesa ver:

Todos estos comandos lo que están haciendo es consultar ficheros del sistema que están guardados en ficheros de registro en el directorio /proc .

Caso Práctico: "La Caza del Proceso Fantasma"

Escenario:

Imagina que eres un administrador de sistemas en una empresa de tecnología. Recientemente, has notado que el rendimiento del servidor ha disminuido significativamente. Sospechas que un proceso no autorizado (un "proceso fantasma") está consumiendo recursos del sistema. Tu misión es identificar y eliminar este proceso para restaurar el rendimiento normal del servidor.

Preparación

Para que los estudiantes no sospechen, pásales primero el siguiente script que instalara sl y lolcat:

Ahora que ejecuten el siguiente comando:

A continuación el segundo script de Prueba, esta vez sí malicioso: space-cowboy.sh

Para transmitir el archivo en red:

Si tu equipo y los estudiantes están en la misma red local, puedes compartir el script ejecutando un servidor HTTP en el directorio donde está el script:

✅ Pasos en tu equipo (servidor)

  1. Ve al directorio donde tienes el script:

  2. Inicia un servidor HTTP en el puerto 8000 (o cualquier otro):

  3. Encuentra tu dirección IP local con:

    Supongamos que la IP es 192.168.1.100.

✅ Paso en los equipos de los estudiantes (clientes)

Los estudiantes pueden descargar el script con:

o

Solo asegúrate de que el firewall no bloquee el puerto 8000.

ESTUDIANTES

Instrucciones para Ejecutar el Script

  1. Guarda el script: Guarda el contenido anterior en un archivo llamado space-cowboy.sh.

  2. Haz el script ejecutable (opcional):

  3. Ejecuta el script:

Cómo Encontrar el Proceso Fantasma paso a paso:

  1. Monitoreo Inicial con watch:

    • Utiliza el comando watch para monitorear el uso de la CPU y la memoria.

    • Observa el promedio de carga del sistema. Si ves que la carga es alta, es una señal de que hay procesos consumiendo muchos recursos.

  2. Identificación del Proceso Fantasma con top:

    • Abre top para ver una lista de procesos en tiempo real.

    • Ordena los procesos por uso de CPU presionando P.

    • Identifica algún proceso sospechoso. Anota su PID (Identificador de Proceso).

  3. O bien usa ps para buscar procesos del usuario fantasma:

    • Esto debería mostrar el proceso fantasma ejecutándose.

  4. Obtención de Detalles del Proceso con ps:

    • Usa ps para obtener más detalles sobre el proceso sospechoso.

    • Reemplaza <PID> con el PID del proceso que identificaste en el paso anterior.

  5. Envío de Señales al Proceso con kill:

    • Intenta terminar el proceso de manera amigable enviando una señal SIGTERM.

    • Si el proceso no se detiene, usa SIGKILL para forzar su terminación.

  6. Uso de pkill y killall:

    • Si hay múltiples instancias del mismo proceso, usa pkill o killall.

    • O bien:

  7. Verificación de la Eliminación del Proceso:

    • Vuelve a ejecutar top para verificar que el proceso fantasma ha sido eliminado y que el uso de recursos ha vuelto a la normalidad.

    • También puedes usar watch para monitorear el promedio de carga del sistema.

Recuerda que en cualquier momento puedes restaurar el sistema con el siguiente script:

Gestión de Procesos con Apache2

Objetivo

En esta actividad, aprenderás a gestionar el servidor web Apache HTTPD (apache2) utilizando diferentes comandos. Realizarás tareas de instalación, monitoreo, finalización y reinicio de procesos de manera eficiente.

Parte 1: Instalación y Verificación de Apache HTTPD

Antes de gestionar los procesos de Apache, primero debemos asegurarnos de que el servicio está instalado y en funcionamiento.

  1. Instalar Apache HTTPD (si aún no está instalado).

    • En Debian/Ubuntu:

  2. Verificar el estado del servicio Apache usando systemd.

    • Mostrar el estado del servicio:

    • Ver si el servicio está activo:

    • Obtener los logs del servicio:

  3. Iniciar y habilitar Apache para que arranque con el sistema.

    • Iniciar el servicio manualmente:

    • Habilitar Apache en el arranque del sistema:

  4. Testear que el servidor Apache está funcionando.

    • Consultar la IP del servidor:

    • Abrir un navegador y acceder a http://<IP_DEL_SERVIDOR> para comprobar que se muestra la página de inicio de Apache.

    • También se puede probar con curl:

Parte 2: Identificación de Procesos de Apache

  1. Descubrir los PID de todos los procesos generados por Apache HTTPD usando dos comandos diferentes.

    • Comando 1:

    • Comando 2:

  2. Mostrar todos los procesos iniciados por el usuario del servidor web (www-data).

    • Comando:

Parte 3: Finalización de Procesos de Apache

  1. Terminar todos los procesos de Apache HTTPD sin usar sus PID con dos comandos diferentes.

    • Comando 1:

    • Comando 2:

  2. Finalizar todas las instancias de Apache HTTPD en una sola línea usando kill con la señal predeterminada SIGTERM, sin necesidad de identificar los PID manualmente.

    • Comando:

Parte 4: Monitoreo en Tiempo Real con top

  1. Iniciar top y realizar las siguientes acciones:

    • Mostrar una vista de árbol de procesos.

      • Dentro de top, presionar:

    • Mostrar rutas completas de procesos, diferenciando entre espacio de usuario y espacio de kernel.

      • Dentro de top, presionar:

Parte 5: Reinicio del Servidor Apache con SIGHUP

La señal SIGHUP puede usarse para reiniciar ciertos demonios sin detenerlos por completo. Cuando se envía SIGHUP al proceso padre de Apache, se matan los procesos hijos, pero el padre vuelve a leer su configuración y genera un nuevo conjunto de procesos hijos.

  1. Iniciar el servidor web Apache.

    • Comando:

  2. Obtener el PID del proceso principal de Apache (el que fue iniciado con init).

    • Comando:

  3. Enviar la señal SIGHUP al proceso principal de Apache para que se reinicie sin interrumpir el servicio.

    • Comando:

Parte 6: Testeo Final del Servicio

  1. Verificar nuevamente el estado del servicio.

  2. Comprobar que Apache sigue sirviendo páginas web.

    • Desde el mismo servidor:

    • Desde otro equipo en la red:

Preguntas Finales:

  • ¿Cuál es la diferencia entre usar kill, pkill y killall para finalizar procesos?

  • ¿Por qué es útil reiniciar Apache con SIGHUP en lugar de detenerlo completamente?

  • ¿Qué ventajas ofrece systemctl sobre los comandos tradicionales (kill, ps, top)?

  • ¿Cómo podríamos automatizar la supervisión del servicio Apache para detectar y reiniciarlo si se detiene inesperadamente?

Organización de ventanas

tmux es un llamado "terminal multiplexer", ósea una herramienta de panelización para poder manejar múltiples terminales en una sola ventana. En realidad esto es sencillo en un entorno gráfico o en terminal podriamos simplemente generar nuevas pero el poder de tmux reside en que puedes asociar, salir o disociar los terminales mientras siguen funcionando de fondo y puedes volver a conectarte y quedarte en el momento en el que estabas.

tmux fue lanzado en 2007 y es mas moderno que screen (el cual veremos más abajo), este incluye algunas diferencias notables:

  • Modelo cliente-servidor: el servidor suministra una serie de sesiones, cada una de las cuales puede tener varias ventanas vinculadas que, a su vez, pueden ser compartidas por varios clientes.

  • Selección interactiva de sesiones, ventanas y clientes a través de menús.

  • La misma ventana se puede vincular a varias sesiones.

  • Disponibilidad de diseños de teclas vim y Emacs.

  • Soporte para terminales UTF-8 y 256 colores.

En general, tiene una interfaz más moderna y cómoda y es especialmente útil para trabajar en terminales remotos ya que te permite comenzar una tarea de larga duración, desconectar dejándolo funcionando y recuperar el progreso en la siguiente conexión.

Los archivos de configuración para tmux se encuentran normalmente en /etc/tmux.conf y ~/.tmux.conf. También existe la posibilidad de iniciar tmux -f para proporcionar un archivo de configuración alternativo. Puede encontrar un ejemplo de archivo de configuración tmux ubicado en /usr/share/doc/tmux/example_tmux.conf.

Podemos probar su capacidad con:

Abre dos terminales en una misma sesión, en uno escribe lo siguiente:

Pulsa Ctrl+b d para disociarte de tmux

Vuelve a escribir tmux a

Puedes observar que el proceso sigue ejecutandose

Para empezar escribiremos tmux que creará una sesión:

La barra inferior nos muestra la sesión actual.

En la barra inferior podemos ver:

  • [0] -> El nombre de referencia de la ventana

  • 0:bash -> el 0 indica el índice de la ventana, bash el nombre del terminal y el * indica la ventana actual.

  • "lnxsvr" 17:07 05-Sep-23 -> Esto indica el hostname y la fecha y hora.

Es interesante ver que si escribimos otro programa como htop, el nombre del terminal cambiará para reflejar el proceso que se esta desarrollando.

Podemos salir del terminal de tmux simplemente con exit. Si solo hay una sesión, nos devolverá la terminal por defecto.

Para volver a crear una sesión con un nombre diferente:

O para asociarse a una sesión de tmux ya funcionando:

Podemos listar el número de sesiones abiertas de tmux con:

O destruir las sesiones abiertas con:

Su uso de basa en comandos con el prefijo Ctrl+b:

Ctrl+b c -> crear nueva ventana.

Ctrl+b n -> cambiar a la siguiente terminal.

Ctrl+b p -> cambiar a la anterior terminal.

Ctrl+b 0,1,2,3 -> para moverme entre terminales.

Ctrl+b , -> para editar el nombre del terminal en la barra inferior.

Ctrl+b d -> disociar la sesión, ósea, dejarla en segundo plano y volver al terminal.

Ctrl+b s -> cambiar entre sesiones de tmux y selecciona la que te interesa.

Ctrl + b & -> Destruir una ventana.

Ctrl+b f -> Buscar una ventana por nombre.

Ctrl+b . -> Cambiar el numero de índice de la ventana.

Ctrl+b ? -> el modo ayuda donde muestra todos estos atajos de teclado.

Podemos ver en la barra inferior los distintos terminales, *es el actual y el - indica el anterior usado.

La función de división de ventanas son los llamados paneles, estos son pseudo-terminales completos vinculados a una ventana. Esto significa que matar un panel también matará su pseudo-terminal y cualquier programa asociado que se ejecute dentro.

Para dividir una ventana horizontalmente, usamos Ctrl+b " o bien use Ctrl+b % para dividirlo verticalmente o, por último, Ctrl+b x para destruir un panel.

Otros comandos de panel importantes:

  • Ctrl+b ↑ , ↓ , ← , → para moverse entre paneles.

  • Ctrl+b ; pasar al último panel activo.

  • Ctrl+b Ctrl+arrow key cambiar el tamaño del panel en una línea.

  • Ctrl+b Alt+arrow key cambiar el tamaño del panel en cinco líneas.

  • Ctrl+b { intercambiar paneles (actual a anterior).

  • Ctrl+b } intercambiar paneles (actual a siguiente).

  • Ctrl+b z panel de acercar/alejar.

  • Ctrl+b t tmux muestra un reloj elegante dentro del panel (deténgalo presionando q).

  • Ctrl+b ! convertir el panel en ventana.

screen viene de GNU screen, el método de multiplexar ventanas usado para emular múltiples pantallas VT100 independientes en un solo terminal físico. Realmente es muy parecido a tmux.

La pantalla se invoca escribiendo:

Primero verás un mensaje de bienvenida, presione la barra espaciadora o Enter para cerrar el mensaje y verás el símbolo del sistema ($), puede parecer que no ha pasado nada, pero el hecho es que screen ya ha creado y gestionado su primera sesión y ventana.

El prefijo de comando ahora es Ctrl+a úsalo para ver todas las ventanas en la parte inferior de la pantalla del terminal, como ya hemos visto con tmux, pulsa Ctrl+a w :

Vamos con los atajos de teclado comunes:

Ctrl+a c -> para crear otra ventana

Ctrl+a A -> editar el nombre de la ventana actual

Ctrl+a n -> ir a la ventana siguiente

Ctrl+a p -> ir a la ventana anterior

Ctrl+a 0,1,2,3 -> ir al numero correspondiente

Ctrl+a " -> ver listado de todas las ventanas

Ctrl+a k -> finalizar ventana

Con tmux o screen puedo incluso reenviar información a otro panel, para saber en que terminal estas escribe tty y mostrará algo como /dev/pts/X donde X es el número de referencia.

Ahora simplemente redirige un output de un comando al destino de antes, por ejemplo con un monitoreo:

Este método es una manera eficiente de gestionar múltiples flujos de información en un entorno de terminal compartido y puede resultar útil en:

  • Monitoreo Remoto: Si estás monitoreando un log en un panel, pero necesitas revisar y analizar la información en tiempo real en otro, puedes reenviar la salida sin interrumpir la ejecución original.

  • Compartir Salida con Otros Usuarios: Si otro usuario está conectado al mismo sistema y su terminal es /dev/pts/4, podrías enviarle información directamente, lo que es útil en entornos colaborativos.

  • Automatización: En scripts o trabajos de mantenimiento, podrías necesitar redirigir la salida de comandos automáticamente a diferentes terminales para su revisión posterior.

Previous103.4 - Uso de secuencias de texto, tuberías y redireccionamientosNextEjercicios 103.5

Last updated