# ¿Qué es journalctl y qué puede hacer? `journalctl` permite gestionar y analizar los registros del sistema en Linux. La herramienta ofrece funciones de supervisión de las actividades del sistema, solución de problemas o de seguimiento de registros en tiempo real, así como la visión detallada de los datos de registro. Además, `journalctl` resulta indispensable a la hora de diagnosticar los problemas del sistema. ## ¿Qué es journalctl? `journalctl` es una eficiente herramienta para **consultar y mostrar registros de eventos** o [ficheros log](https://www.ionos.es/digitalguide/online-marketing/analisis-web/el-log-el-archivo-de-registro-de-procesos-informaticos/) en [Linux](https://www.ionos.es/digitalguide/servidores/know-how/linux-una-alternativa-a-windows-de-bajo-coste/). `journalctl` se constituye como un componente clave de systemd, administrador de sistemas y servicios, que muchas distribuciones modernas de Linux, como Ubuntu, Fedora y Arch Linux, utilizan por defecto. El nombre “journalctl” se compone de “journal” (registro) y “ctl” (control), términos que hacen referencia a su función de herramienta de control y análisis de registros. `journalctl` permite el acceso al registro del sistema, gestionado por `systemd-journald`. El registro del sistema es una colección centralizada de mensajes y eventos que tienen lugar mientras el sistema Linux está en funcionamiento. A diferencia de los registros tradicionales basados en texto, `journalctl` ofrece una forma estructurada y eficiente de buscar, filtrar y mostrar **datos de registro en tiempo real**. Gracias a ello, es posible diagnosticar problemas o monitorizar 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 equivalente basado en texto. Esto permite, a pesar de la gran cantidad de datos registrados, las búsquedas rápidas de eventos específicos o de información. Además, la estructura y encriptación de este tipo de archivos ofrecen mayor seguridad, pues dificultan la manipulación de los datos de registro. ## Personalizar el espacio de almacenamiento de los archivos de registro `journalctl` puede utilizarse para limitar y configurar el espacio que ocupan los archivos de registro en el disco duro. Si se quiere llevar a cabo la citada configuración, hay que usar la **configuración del servicio systemd-journald**. Los ajustes de configuración se guardan en `/etc/systemd/journald.conf`, un archivo en el que se pueden ver las siguientes entradas: - `SystemMaxUse`: limita el espacio de almacenamiento para registros en el directorio del sistema. - `RuntimeMaxUse`: limita el espacio de almacenamiento para registros en el directorio temporal. Para establecer el límite de espacio de almacenamiento, puedes incluir las siguientes líneas, que puedes ir modificando según necesites: ```bash [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 configuración, hay que reiniciar systemd-journald para que los cambios se hagan efectivos: ```bash sudo systemctl restart systemd-journald ``` Aplicando los pasos anteriores, habrás configurado systemd-journald para limitar el espacio de almacenamiento de los archivos de registro. Asegúrate de que el límite establecido es suficiente para almacenar datos de registro necesarios, sin que ello consuma demasiado espacio en el disco duro. Ten en cuenta que **los registros más antiguos se borran automáticamente** cuando se llega al límite fijado. ### Determinar el uso del disco duro Antes de configurar el espacio de almacenamiento para los archivos de registro, puedes comprobar primero cuánto espacio de almacenamiento ocupa actualmente el “journal”. Para ello, hay que usar el argumento `--disk-usage`: ```bash 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 especificando un tamaño. En este caso, se van eliminando todas las entradas antiguas hasta que el Journal ocupe el tamaño deseado. ```bash sudo journalctl --vacuum-tamaño=1G ``` Como alternativa, se puede reducir el tamaño de Journal especificando un periodo de almacenamiento de archivos con la opción `--vacuum-time`. Todas las entradas anteriores al periodo especificado se eliminarán. Si deseas conservar las entradas de Journal del último año, por ejemplo, puedes introducir: ```bash sudo journalctl --vacuum-time=1years ``` ## ¿Para qué sirve journalctl? Una de las funciones más importantes de `journalctl` es el filtrado de **entradas de registro según distintos criterios**. Gracias a ella, se puede buscar información específica e identificar problemas con mayor rapidez. A continuación, te presentamos 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 cronológico inverso. Si introduces `journalctl -f` o `journalctl --follow`, podrás ver las entradas **en tiempo real**. Las nuevas entradas se muestran automáticamente en el orden en que llegan. La cantidad de datos que se te muestre puede resultar difícil de manejar (desde decenas a centenares de líneas), si bien depende del tiempo que lleve systemd ejecutándose en tu sistema. Para encontrar lo que estás buscando de forma eficiente, puedes filtrar los registros aún más utilizando otros [comandos de Linux](https://www.ionos.es/digitalguide/online-marketing/analisis-web/el-log-el-archivo-de-registro-de-procesos-informaticos/). ## Filtrar por tiempo journalctl se puede utilizar para filtrar los registros a partir de un periodo de tiempo específico, lo que permite obtener de forma más eficiente la información relevante. ### Filtrar por secuencias de arranque Filtrar los registros por procesos de arranque es especialmente útil si se quieren comprobar eventos específicos del sistema en un momento determinado o durante un escenario de arranque concreto. Esto facilita el diagnóstico de problemas, ya que las entradas de registro se pueden limitar a un estado de sistema específico o a una configuración del sistema. 1. **Arranque actual**: utiliza `journalctl -b` para mostrar todas las entradas de registro recopiladas desde el último arranque. 2. **Arranques anteriores**: utiliza la opción `-b` seguida de una cifra para mostrar las entradas de registro correspondientes a un arranque específico anterior. Por ejemplo, si introduces `journalctl -b 1`, se mostrará el arranque inmediatamente anterior. 3. **Lista de todas las secuencias de arranque disponibles**: el comando `journalctl --list-boots` muestra una lista de los procesos de arranque disponibles con sus respectivas identificaciones (ID). Puedes utilizar un ID específico para acceder a los registros asociados a un proceso de arranque concreto. Mientras que en algunas distribuciones de Linux el almacenamiento de procesos de arranque anteriores está activado por defecto, en otras debe **activarse manualmente**. Para ello, con el comando `sudo mkdir -p /var/log/journal`, puedes crear un directorio en el que se almacenarán los registros. Como alternativa, puedes editar el archivo de configuración del Journal con `sudo nano /etc/systemd/journald.conf`. A continuación, establece la opción `Storage=` en `persistent` para habilitar el registro persistente: ```bash . . . [Journal] Storage=persistent ``` ### Filtrar por ventanas de tiempo A veces puede ser necesario mostrar las entradas de registro de un periodo de tiempo específico. `journalctl` ofrece las opciones `--since` y `--until`, que pueden utilizarse para restringir 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: ```bash journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00" ``` La combinación de los dos comandos también puede usarse para filtrar un periodo de tiempo más corto: ```bash journalctl --since 09:00 --until "1 hour ago" ``` Como alternativa, se pueden omitir partes del formato anterior. Por ejemplo, se puede tener acceso a todas las entradas desde un momento determinado: ```bash 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 introducir lo siguiente: ```bash 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 extremadamente útil, ya que permite **buscar información relevante y centrarse en aspectos concretos de los registros del sistema**. De esta forma es posible, entre otras cosas, realizar un diagnóstico eficiente de errores, detectar los problemas de forma temprana y monitorizar el rendimiento rápidamente. ### Filtrar por prioridad Para filtrar los registros con `journalctl` según tus intereses específicos en los mensajes, puedes utilizar los **niveles de gravedad de los mensajes**. Para ello, puedes utilizar el nombre del nivel respectivo o su valor numérico correspondiente. Cuanto menor sea el número, más importante es el mensaje: - 0: emerg (emergencia) - 1: alert (alarma) - 2: crit (crítico) - 3: err (error) - 4: warning (advertencia) - 5: notice (nota) - 6: info (informació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: ```bash journalctl -p err ``` ### Filtrar por unidad Filtrar los registros por unidad con `journalctl` es especialmente ú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 introducir lo siguiente: ```bash journalctl -u apache2 ``` La búsqueda se puede refinar aún más utilizando los valores de tiempo relativo. Si, por ejemplo, quieres saber si se ha ejecutado algún servicio hoy, puedes introducir lo siguiente: ```bash journalctl -u apache2 --since today ``` Con `journalctl`, también puedes combinar registros de datos de diferentes unidades. Si tu proceso de Nginx está conectado a una unidad PHP-FPM, por ejemplo, se pueden combinar las entradas de ambos en orden cronológico. El comando sigue la sintaxis que se muestra: ```bash 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 información que deseas usando la opción `_PID`. Por ejemplo, si el PID es 8088, el comando tendría la sintaxis que se muestra: ```bash journalctl _PID=8088 ``` Si lo deseas, también puedes filtrar por `_UID` o `_GID` para tener acceso a las entradas que fueron registradas por un usuario o grupo específico. Para conocer tu nombre de usuario puedes utilizar el comando `id -u www-data`, que en este caso muestra la salida 33. ```bash id -u www-data 33 ``` A continuación, puedes filtrar por `_UID`, pues ya conoces el ID de usuario: ```bash 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”: ```bash journalctl -F _GID 32 99 102 133 81 84 100 0 124 87 ``` ### Filtrar por campo de componente Filtrar por el campo componente es sumamente útil para centrarse en aplicaciones, servicios o procesos específicos. El campo componente lo utilizan normalmente **distintos servicios o componentes de software** para identificar información específica en los registros. Este tipo de filtrado permite limitar las entradas de registro a un componente, aplicación o unidad de servicio concretos. Por ejemplo, para filtrar las entradas que contienen el archivo ejecutable `bash`, debes introducir el siguiente comando: ```bash journalctl /usr/bin/bash ``` ### Mostrar mensajes del kernel Filtrar entradas de registro por mensajes del kernel con `journalctl` es una forma efectiva de analizar información específica sobre el funcionamiento del kernel en un sistema Linux. Los mensajes del kernel pueden ofrecer **indicios sobre problemas de hardware, conflictos de controladores u otros eventos del sistema**. Los mensajes del kernel encontrados en `dmesg` también pueden filtrarse desde el journal. Pueden mostrarse con las opciones `-k` o `--dmesg`: ```bash 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 alternativo** 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: ```bash journalctl -k -b -5 ``` ## Cambiar la visualización del Journal en journalctl Personalizar la visualización en `journalctl` permite a los usuarios buscar en los registros de una forma más concreta y, de esta forma, encontrar la información deseada con mayor rapidez. Con la visualización de datos de registro en tiempo real o de un periodo concreto, se pueden reconocer rápidamente los errores y los problemas en el sistema. ### Acortar o ampliar la salida Además, es posible personalizar la forma en que `journalctl` muestra los datos. La salida puede acortarse o ampliarse. De forma predeterminada, `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`: ```bash journalctl --no-full ``` Puedes ampliar la visualización utilizando la opción `-a`: ```bash journalctl -a ``` ### Establecer journalctl 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 directamente en la salida estándar. Para ello, hay que escribir lo siguiente: ```bash journalctl --no-pager ``` ### Configurar formatos de salida Hay varias opciones disponibles para personalizar el formato de salida de los registros en `journalctl`. Para realizar esta configuración, se puede utilizar la opción `-o` con el identificador de formato correspondiente. Por ejemplo, para que las entradas de registro salgan en JSON: ```bash 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 especificar en `journalctl` son: - **cat**: muestra solo el campo del mensaje. - **export**: este formato binario es adecuado para transferir o guardar datos. - **json**: utiliza el formato JSON estándar con una entrada por línea. - **json-pretty**: JSON formateado para una mejor legibilidad. - **json-sse**: salida con formato JSON encapsulado 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 microsegundos. - **verbose**: muestra todos los campos del journal disponibles para la entrada correspondiente. ## Monitorizar procesos activos Al monitorizar 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 seguimiento de los eventos del sistema en tiempo real y, en consecuencia, reaccionar con rapidez a cualquier problema que surja. ## Mostrar registros actuales La opción `-n` sirve para acceder a un número específico de registros de datos. La opción funciona exactamente igual que `tail -n`. Con el siguiente comando, se muestran por defecto los últimos 10 registros: ```bash journalctl -n ``` El número de registros que se muestran se puede configurar en cada caso. Con el siguiente comando, se pueden consultar, por ejemplo, 20: ```bash journalctl -n 20 ``` This is a markdown version of: [https://www.ionos.es/digitalguide/servidores/herramientas/que-es-journalctl/](https://www.ionos.es/digitalguide/servidores/herramientas/que-es-journalctl/) for AI/LLM consumption.