¿Qué es jou­r­na­l­ctl y qué puede hacer?

journalctl permite gestionar y analizar los registros del sistema en Linux. La he­rra­mie­n­ta ofrece funciones de su­pe­r­vi­sión de las ac­ti­vi­da­des del sistema, solución de problemas o de se­gui­mie­n­to de registros en tiempo real, así como la visión detallada de los datos de registro. Además, journalctl resulta in­di­s­pe­n­sa­ble a la hora de dia­g­no­s­ti­car los problemas del sistema.

¿Qué es jou­r­na­l­ctl?

journalctl es una eficiente he­rra­mie­n­ta para consultar y mostrar registros de eventos o ficheros log en Linux. journalctl se co­n­s­ti­tu­ye como un co­m­po­ne­n­te clave de systemd, ad­mi­ni­s­tra­dor de sistemas y servicios, que muchas di­s­tri­bu­cio­nes modernas de Linux, como Ubuntu, Fedora y Arch Linux, utilizan por defecto. El nombre “jou­r­na­l­ctl” se compone de “journal” (registro) y “ctl” (control), términos que hacen re­fe­re­n­cia a su función de he­rra­mie­n­ta de control y análisis de registros.

journalctl permite el acceso al registro del sistema, ge­s­tio­na­do por systemd-journald. El registro del sistema es una colección ce­n­tra­li­za­da de mensajes y eventos que tienen lugar mientras el sistema Linux está en fu­n­cio­na­mie­n­to. A di­fe­re­n­cia de los registros tra­di­cio­na­les basados en texto, journalctl ofrece una forma es­tru­c­tu­ra­da y eficiente de buscar, filtrar y mostrar datos de registro en tiempo real. Gracias a ello, es posible dia­g­no­s­ti­car problemas o mo­ni­to­ri­zar el estado del sistema.

journalctl guarda los archivos de registro en formato binario, pues este tipo de archivo es más compacto y eficiente que su equi­va­le­n­te basado en texto. Esto permite, a pesar de la gran cantidad de datos re­gi­s­tra­dos, las búsquedas rápidas de eventos es­pe­cí­fi­cos o de in­fo­r­ma­ción. Además, la es­tru­c­tu­ra y en­cri­p­ta­ción de este tipo de archivos ofrecen mayor seguridad, pues di­fi­cu­l­tan la ma­ni­pu­la­ción de los datos de registro.

Pe­r­so­na­li­zar el espacio de al­ma­ce­na­mie­n­to de los archivos de registro

journalctl puede uti­li­zar­se para limitar y co­n­fi­gu­rar el espacio que ocupan los archivos de registro en el disco duro. Si se quiere llevar a cabo la citada co­n­fi­gu­ra­ción, hay que usar la co­n­fi­gu­ra­ción del servicio systemd-journald. Los ajustes de co­n­fi­gu­ra­ción se guardan en /etc/systemd/journald.conf, un archivo en el que se pueden ver las si­guie­n­tes entradas:

• SystemMaxUse: limita el espacio de al­ma­ce­na­mie­n­to para registros en el di­re­c­to­rio del sistema.
• RuntimeMaxUse: limita el espacio de al­ma­ce­na­mie­n­to para registros en el di­re­c­to­rio temporal.

Para es­ta­ble­cer el límite de espacio de al­ma­ce­na­mie­n­to, puedes incluir las si­guie­n­tes líneas, que puedes ir mo­di­fi­ca­n­do según necesites:

[Journal]
SystemMaxUse=50M
RuntimeMaxUse=50M

Los valores de este ejemplo (50M) pueden cambiarse según sea necesario. También se pueden cambiar las unidades: K (kilobytes), M (megabytes), G (gigabytes) o T (terabytes). Después de editar el fichero de co­n­fi­gu­ra­ción, hay que reiniciar systemd-journald para que los cambios se hagan efectivos:

sudo systemctl restart systemd-journald

Aplicando los pasos an­te­rio­res, habrás co­n­fi­gu­ra­do systemd-journald para limitar el espacio de al­ma­ce­na­mie­n­to de los archivos de registro. Asegúrate de que el límite es­ta­ble­ci­do es su­fi­cie­n­te para almacenar datos de registro ne­ce­sa­rios, sin que ello consuma demasiado espacio en el disco duro. Ten en cuenta que los registros más antiguos se borran au­to­má­ti­ca­me­n­te cuando se llega al límite fijado.

De­te­r­mi­nar el uso del disco duro

Antes de co­n­fi­gu­rar el espacio de al­ma­ce­na­mie­n­to para los archivos de registro, puedes comprobar primero cuánto espacio de al­ma­ce­na­mie­n­to ocupa ac­tua­l­me­n­te el “journal”. Para ello, hay que usar el argumento --disk-usage:

journalctl --disk-usage
Journals take up 8.0M on disk.

Borrar entradas de registro antiguas

Si el Journal ocupa demasiado espacio en disco, puedes borrar las entradas de registro antiguas. Para ello, hay dos formas de proceder:

Con --vacuum-size puedes reducir el tamaño del Journal es­pe­ci­fi­ca­n­do un tamaño. En este caso, se van eli­mi­na­n­do todas las entradas antiguas hasta que el Journal ocupe el tamaño deseado.

sudo journalctl --vacuum-tamaño=1G

Como al­te­r­na­ti­va, se puede reducir el tamaño de Journal es­pe­ci­fi­ca­n­do un periodo de al­ma­ce­na­mie­n­to de archivos con la opción --vacuum-time. Todas las entradas an­te­rio­res al periodo es­pe­ci­fi­ca­do se eli­mi­na­rán. Si deseas conservar las entradas de Journal del último año, por ejemplo, puedes in­tro­du­cir:

sudo journalctl --vacuum-time=1years

¿Para qué sirve jou­r­na­l­ctl?

Una de las funciones más im­po­r­ta­n­tes de journalctl es el filtrado de entradas de registro según distintos criterios. Gracias a ella, se puede buscar in­fo­r­ma­ción es­pe­cí­fi­ca e ide­n­ti­fi­car problemas con mayor rapidez. A co­n­ti­nua­ción, te pre­se­n­ta­mos algunas de las opciones de filtrado más comunes de journalctl.

Mostrar registros

Con el comando journalctl se muestran las entradas de registro del sistema actual en orden cro­no­ló­gi­co inverso. Si in­tro­du­ces journalctl -f o journalctl --follow, podrás ver las entradas en tiempo real. Las nuevas entradas se muestran au­to­má­ti­ca­me­n­te en el orden en que llegan.

La cantidad de datos que se te muestre puede resultar difícil de manejar (desde decenas a ce­n­te­na­res de líneas), si bien depende del tiempo que lleve systemd eje­cu­tá­n­do­se en tu sistema. Para encontrar lo que estás buscando de forma eficiente, puedes filtrar los registros aún más uti­li­za­n­do otros comandos de Linux.

Filtrar por tiempo

jou­r­na­l­ctl se puede utilizar para filtrar los registros a partir de un periodo de tiempo es­pe­cí­fi­co, lo que permite obtener de forma más eficiente la in­fo­r­ma­ción relevante.

Filtrar por se­cue­n­cias de arranque

Filtrar los registros por procesos de arranque es es­pe­cia­l­me­n­te útil si se quieren comprobar eventos es­pe­cí­fi­cos del sistema en un momento de­te­r­mi­na­do o durante un escenario de arranque concreto. Esto facilita el dia­g­nó­s­ti­co de problemas, ya que las entradas de registro se pueden limitar a un estado de sistema es­pe­cí­fi­co o a una co­n­fi­gu­ra­ción del sistema.

1. Arranque actual: utiliza journalctl -b para mostrar todas las entradas de registro re­co­pi­la­das desde el último arranque.
2. Arranques an­te­rio­res: utiliza la opción -b seguida de una cifra para mostrar las entradas de registro co­rre­s­po­n­die­n­tes a un arranque es­pe­cí­fi­co anterior. Por ejemplo, si in­tro­du­ces journalctl -b 1, se mostrará el arranque in­me­dia­ta­me­n­te anterior.
3. Lista de todas las se­cue­n­cias de arranque di­s­po­ni­bles: el comando journalctl --list-boots muestra una lista de los procesos de arranque di­s­po­ni­bles con sus re­s­pe­c­ti­vas ide­n­ti­fi­ca­cio­nes (ID). Puedes utilizar un ID es­pe­cí­fi­co para acceder a los registros asociados a un proceso de arranque concreto.

Mientras que en algunas di­s­tri­bu­cio­nes de Linux el al­ma­ce­na­mie­n­to de procesos de arranque an­te­rio­res está activado por defecto, en otras debe activarse ma­nua­l­me­n­te. Para ello, con el comando sudo mkdir -p /var/log/journal, puedes crear un di­re­c­to­rio en el que se al­ma­ce­na­rán los registros.

Como al­te­r­na­ti­va, puedes editar el archivo de co­n­fi­gu­ra­ción del Journal con sudo nano /etc/systemd/journald.conf. A co­n­ti­nua­ción, establece la opción Storage= en persistent para habilitar el registro pe­r­si­s­te­n­te:

. . .
[Journal]
Storage=persistent

Filtrar por ventanas de tiempo

A veces puede ser necesario mostrar las entradas de registro de un periodo de tiempo es­pe­cí­fi­co. journalctl ofrece las opciones --since y --until, que pueden uti­li­zar­se para re­s­tri­n­gir las entradas a un periodo de tiempo concreto. Para ello, se aplica el formato de tiempo YYYY-MM-DD HH:MM:SS. El comando para, por ejemplo, mostrar todas las entradas de registro entre el 1 de enero de 2023 a las 12:00 y el 2 de enero de 2023 a las 12:00, tendría el siguiente aspecto:

journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00"

La co­m­bi­na­ción de los dos comandos también puede usarse para filtrar un periodo de tiempo más corto:

journalctl --since 09:00 --until "1 hour ago"

Como al­te­r­na­ti­va, se pueden omitir partes del formato anterior. Por ejemplo, se puede tener acceso a todas las entradas desde un momento de­te­r­mi­na­do:

journalctl --since "2023-11-16 15:25:00"

journalctl también se puede usar con valores relativos como yesterday (ayer), today (hoy) o tomorrow (mañana). Para mostrar los registros de ayer, puedes in­tro­du­cir lo siguiente:

journalctl --since yesterday

Filtrar por el interés de los mensajes

La capacidad de filtrar las entradas de registro por interés de mensaje con journalctl también es ex­tre­ma­da­me­n­te útil, ya que permite buscar in­fo­r­ma­ción relevante y centrarse en aspectos concretos de los registros del sistema. De esta forma es posible, entre otras cosas, realizar un dia­g­nó­s­ti­co eficiente de errores, detectar los problemas de forma temprana y mo­ni­to­ri­zar el re­n­di­mie­n­to rá­pi­da­me­n­te.

Filtrar por prioridad

Para filtrar los registros con journalctl según tus intereses es­pe­cí­fi­cos en los mensajes, puedes utilizar los niveles de gravedad de los mensajes. Para ello, puedes utilizar el nombre del nivel re­s­pe­c­ti­vo o su valor numérico co­rre­s­po­n­die­n­te. Cuanto menor sea el número, más im­po­r­ta­n­te es el mensaje:

• 0: emerg (eme­r­ge­n­cia)
• 1: alert (alarma)
• 2: crit (crítico)
• 3: err (error)
• 4: warning (ad­ve­r­te­n­cia)
• 5: notice (nota)
• 6: info (in­fo­r­ma­ción)
• 7: debug (solución de problemas)

Para filtrar los mensajes teniendo en cuenta un nivel de gravedad concreto puedes recurrir a la opción -p. El siguiente comando, por ejemplo, solo muestra las entradas de registro con prioridad “err” (error) y superior:

journalctl -p err

Filtrar por unidad

Filtrar los registros por unidad con journalctl es es­pe­cia­l­me­n­te útil si quieres enfocarte en servicios o procesos concretos. Para ello, utiliza la opción -u. Por ejemplo, para mostrar las entradas de registro del servidor web Apache, puedes in­tro­du­cir lo siguiente:

journalctl -u apache2

La búsqueda se puede refinar aún más uti­li­za­n­do los valores de tiempo relativo. Si, por ejemplo, quieres saber si se ha ejecutado algún servicio hoy, puedes in­tro­du­cir lo siguiente:

journalctl -u apache2 --since today

Con journalctl, también puedes combinar registros de datos de di­fe­re­n­tes unidades. Si tu proceso de Nginx está conectado a una unidad PHP-FPM, por ejemplo, se pueden combinar las entradas de ambos en orden cro­no­ló­gi­co. El comando sigue la sintaxis que se muestra:

journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today

Filtrar por ID de proceso, usuario o de grupo

journalctl también puede usarse para filtrar entradas de registro por ID de proceso, usuario o grupo. Si conoces el ID del proceso (PID) que quieres buscar, puedes filtrar la in­fo­r­ma­ción que deseas usando la opción _PID. Por ejemplo, si el PID es 8088, el comando tendría la sintaxis que se muestra:

journalctl _PID=8088

Si lo deseas, también puedes filtrar por _UID o _GID para tener acceso a las entradas que fueron re­gi­s­tra­das por un usuario o grupo es­pe­cí­fi­co. Para conocer tu nombre de usuario puedes utilizar el comando id -u www-data, que en este caso muestra la salida 33.

id -u www-data
33

A co­n­ti­nua­ción, puedes filtrar por _UID, pues ya conoces el ID de usuario:

journalctl _UID=33 --since today

Para ver para qué ID de grupo (GID) se han creado entradas, puedes utilizar la opción -F, que muestra todos los valores guardados para el campo “ID de grupo”:

journalctl -F _GID
32
99
102
133
81
84
100
0
124
87

Filtrar por campo de co­m­po­ne­n­te

Filtrar por el campo co­m­po­ne­n­te es sumamente útil para centrarse en apli­ca­cio­nes, servicios o procesos es­pe­cí­fi­cos. El campo co­m­po­ne­n­te lo utilizan no­r­ma­l­me­n­te distintos servicios o co­m­po­ne­n­tes de software para ide­n­ti­fi­car in­fo­r­ma­ción es­pe­cí­fi­ca en los registros. Este tipo de filtrado permite limitar las entradas de registro a un co­m­po­ne­n­te, apli­ca­ción o unidad de servicio concretos. Por ejemplo, para filtrar las entradas que contienen el archivo eje­cu­ta­ble bash, debes in­tro­du­cir el siguiente comando:

journalctl /usr/bin/bash

Mostrar mensajes del kernel

Filtrar entradas de registro por mensajes del kernel con journalctl es una forma efectiva de analizar in­fo­r­ma­ción es­pe­cí­fi­ca sobre el fu­n­cio­na­mie­n­to del kernel en un sistema Linux. Los mensajes del kernel pueden ofrecer indicios sobre problemas de hardware, co­n­fli­c­tos de co­n­tro­la­do­res u otros eventos del sistema.

Los mensajes del kernel en­co­n­tra­dos en dmesg también pueden filtrarse desde el journal. Pueden mostrarse con las opciones -k o --dmesg:

journalctl -k

Los mensajes del kernel del proceso de arranque actual son los que se muestran por defecto. Los mensajes de un proceso de arranque al­te­r­na­ti­vo pueden filtrarse con las opciones de selección de arranque ya conocidas. Por ejemplo, si deseas ver los mensajes del kernel de los últimos cinco procesos de arranque, introduce lo siguiente:

journalctl -k -b -5

Cambiar la vi­sua­li­za­ción del Journal en jou­r­na­l­ctl

Pe­r­so­na­li­zar la vi­sua­li­za­ción en journalctl permite a los usuarios buscar en los registros de una forma más concreta y, de esta forma, encontrar la in­fo­r­ma­ción deseada con mayor rapidez. Con la vi­sua­li­za­ción de datos de registro en tiempo real o de un periodo concreto, se pueden reconocer rá­pi­da­me­n­te los errores y los problemas en el sistema.

Acortar o ampliar la salida

Además, es posible pe­r­so­na­li­zar la forma en que journalctl muestra los datos. La salida puede acortarse o ampliarse. De forma pre­de­te­r­mi­na­da, journalctl muestra la entrada completa en el pager y muestra tantas entradas como sea posible en la parte derecha de la pantalla. Esto se puede acortar con la opción --no-full:

journalctl --no-full

Puedes ampliar la vi­sua­li­za­ción uti­li­za­n­do la opción -a:

journalctl -a

Es­ta­ble­cer jou­r­na­l­ctl a la salida estándar

En journalctl, la salida de registro se muestra por defecto usando un pager, por ejemplo less. Esto permite ver la salida paso a paso, lo que favorece navegar a través de archivos de registro más extensos. A veces, sin embargo, puede ser necesario mostrar los registros di­re­c­ta­me­n­te en la salida estándar. Para ello, hay que escribir lo siguiente:

journalctl --no-pager

Co­n­fi­gu­rar formatos de salida

Hay varias opciones di­s­po­ni­bles para pe­r­so­na­li­zar el formato de salida de los registros en journalctl. Para realizar esta co­n­fi­gu­ra­ción, se puede utilizar la opción -o con el ide­n­ti­fi­ca­dor de formato co­rre­s­po­n­die­n­te. Por ejemplo, para que las entradas de registro salgan en JSON:

journalctl -b -u nginx -o json
{ "__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635", "__REALTIME_TIMESTAMP" : "1422990364739502", "__MONOTONIC_TIMESTAMP" : "27200938", "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d", "PRIORITY" : "6", "_UID" : "0", "_GID" : "0", "_CAP_EFFECTIVE" : "3fffffffff", "_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee", "_HOSTNAME" : "desktop", "SYSLOG_FACILITY" : "3", "CODE_FILE" : "src/core/unit.c", "CODE_LINE" : "1402", "CODE_FUNCTION" :

Los formatos que se pueden es­pe­ci­fi­car en journalctl son:

• cat: muestra solo el campo del mensaje.
• export: este formato binario es adecuado para tra­n­s­fe­rir o guardar datos.
• json: utiliza el formato JSON estándar con una entrada por línea.
• json-pretty: JSON fo­r­ma­tea­do para una mejor le­gi­bi­li­dad.
• json-sse: salida con formato JSON en­ca­p­su­la­do que permite añadir eventos enviados por el servidor.
• short: salida estándar estilo syslog.
• short-iso: formato estándar para mostrar marcas de tiempo ISO-8601.
• short-monotonic: formato estándar con marcas de tiempo monótonas.
• short-precise: formato estándar con precisión de mi­cro­se­gu­n­dos.
• verbose: muestra todos los campos del journal di­s­po­ni­bles para la entrada co­rre­s­po­n­die­n­te.

Mo­ni­to­ri­zar procesos activos

Al mo­ni­to­ri­zar procesos con journalctl, se utiliza el programa de línea de comandos tail para rastrear los registros en tiempo real y tener acceso a las entradas más recientes. De este modo, es más sencillo hacer un se­gui­mie­n­to de los eventos del sistema en tiempo real y, en co­n­se­cue­n­cia, reac­cio­nar con rapidez a cualquier problema que surja.

Mostrar registros actuales

La opción -n sirve para acceder a un número es­pe­cí­fi­co de registros de datos. La opción funciona exac­ta­me­n­te igual que tail -n. Con el siguiente comando, se muestran por defecto los últimos 10 registros:

journalctl -n

El número de registros que se muestran se puede co­n­fi­gu­rar en cada caso. Con el siguiente comando, se pueden consultar, por ejemplo, 20:

journalctl -n 20