Controlar Servicios en Red Hat Enterprise Linux

Red Hat Enterprise LinuxBeginner
Practicar Ahora

Introducción

En este laboratorio, obtendrá experiencia práctica en la gestión de servicios del sistema en RHEL utilizando el comando systemctl. Aprenderá a ver todos los servicios cargados y activos, verificar el estado de servicios específicos y controlar su comportamiento en tiempo de ejecución iniciándolos, deteniéndolos y reiniciándolos. Además, explorará cómo recargar las configuraciones de los servicios, habilitar o deshabilitar servicios para el inicio automático al arrancar, y comprenderá los conceptos avanzados de enmascarar (masking) y desenmascarar (unmasking) servicios para evitar su activación.

Esta guía práctica le proporcionará habilidades esenciales para la administración del sistema, permitiéndole monitorear y gestionar eficazmente el ciclo de vida de los servicios cruciales para el funcionamiento de su sistema RHEL.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 90%. Ha recibido una tasa de reseñas positivas del 99% por parte de los estudiantes.

Ver todos los servicios cargados y activos con systemctl

En este paso, aprenderá a identificar los procesos del sistema que se inician automáticamente utilizando el comando systemctl. systemctl es la herramienta principal para gestionar los servicios de systemd en Red Hat Enterprise Linux.

Primero, exploremos cómo listar todas las unidades de servicio actualmente cargadas y activas. El comando systemctl list-units --type=service se utiliza para este propósito. Este comando muestra las unidades de servicio que el demonio systemd ha analizado y cargado correctamente en memoria, y que están actualmente activas.

Abra su terminal en el entorno RHEL. Ya ha iniciado sesión como usuario labex, y su directorio actual es ~/project.

Ejecute el siguiente comando para listar todas las unidades de servicio cargadas y activas:

systemctl list-units --type=service

Verá una salida similar a esta, mostrando varios servicios y sus estados:

UNIT                  LOAD    ACTIVE  SUB      DESCRIPTION
atd.service           loaded  active  running  Job spooling tools
auditd.service        loaded  active  running  Security Auditing Service
chronyd.service       loaded  active  running  NTP client/server
crond.service         loaded  active  running  Command Scheduler
dbus-broker.service   loaded  active  running  D-Bus System Message Bus
...output omitted...

Analicemos las columnas de la salida:

  • UNIT: Este es el nombre de la unidad de servicio, que normalmente termina en .service.
  • LOAD: Indica si el demonio systemd analizó correctamente la configuración de la unidad y la cargó en memoria. loaded significa que fue exitoso.
  • ACTIVE: Este es el estado de activación de alto nivel de la unidad. active generalmente significa que la unidad se inició correctamente.
  • SUB: Este es el estado de activación de bajo nivel, que proporciona información más detallada. Para los servicios en ejecución, running es común.
  • DESCRIPTION: Una breve descripción de lo que hace el servicio.

Presione q para salir del comando.

A continuación, puede usar la opción --all con systemctl list-units --type=service para listar todas las unidades de servicio independientemente de sus estados de activación (activo, inactivo, fallido, etc.). Esto puede ser útil para ver los servicios que están instalados pero no se están ejecutando actualmente.

Ejecute el siguiente comando:

systemctl list-units --type=service --all

La salida incluirá servicios que están inactive o en otros estados, proporcionando una vista más completa:

UNIT                          LOAD      ACTIVE   SUB     DESCRIPTION
  atd.service                 loaded    active   running Job spooling tools
  auditd.service              loaded    active   running Security Auditing ...
  auth-rpcgss-module.service  loaded    inactive dead    Kernel Module ...
  chronyd.service             loaded    active   running NTP client/server
  cpupower.service            loaded    inactive dead    Configure CPU power ...
  crond.service               loaded    active   running Command Scheduler
  dbus-broker.service         loaded    active   running  D-Bus System Message Bus
● display-manager.service     not-found inactive dead    display-manager.service
...output omitted...

Finalmente, para ver el estado de todos los archivos de unidad instalados, incluidos aquellos que no están cargados o activos, puede usar systemctl list-unit-files --type=service. Este comando muestra si un servicio está enabled (se inicia al arrancar), disabled (no se inicia al arrancar), static (no se puede habilitar directamente pero puede ser iniciado por otra unidad) o masked (se le impide iniciarse).

Ejecute el siguiente comando:

systemctl list-unit-files --type=service

Verá una salida similar a esta, indicando el STATE y VENDOR PRESET para cada archivo de unidad de servicio:

UNIT FILE                         STATE       VENDOR PRESET
arp-ethers.service                disabled    disabled
atd.service                       enabled     enabled
auditd.service                    enabled     enabled
auth-rpcgss-module.service        static      -
autovt@.service                   alias       -
blk-availability.service          disabled    disabled
...output omitted...

Este comando es particularmente útil para comprender qué servicios están configurados para iniciarse automáticamente cuando el sistema arranca.

Comprobar el estado de un servicio específico con systemctl status

En este paso, aprenderá a comprobar el estado detallado de un servicio específico utilizando el comando systemctl status. Este comando proporciona información completa sobre un servicio, incluyendo si se está ejecutando, su ID de proceso, uso de memoria y entradas de registro recientes.

Utilizaremos crond.service (el demonio cron) como ejemplo. El demonio cron es un servicio común que maneja tareas programadas.

Abra su terminal en el entorno RHEL. Asegúrese de estar en su directorio ~/project.

Ejecute el siguiente comando para comprobar el estado de crond.service:

systemctl status crond.service

Verá una salida detallada similar a esta:

● crond.service - Command Scheduler
     Loaded: loaded (/usr/lib/systemd/system/crond.service; enabled; preset: enabled)
     Active: active (running) since Mon 2022-03-14 05:38:10 EDT; 25min ago
   Main PID: 1089 (crond)
      Tasks: 1 (limit: 35578)
     Memory: 1.2M
        CPU: 12ms
     CGroup: /system.slice/crond.service
             └─1089 /usr/sbin/crond -n

Mar 14 05:38:10 workstation systemd[1]: Started Command Scheduler.
Warning: some journal files were not opened due to insufficient permissions.

Examinemos los campos clave de la salida:

  • Loaded: Esta línea le indica si el archivo de configuración de la unidad de servicio ha sido procesado. También muestra la ruta al archivo de unidad (/usr/lib/systemd/system/crond.service) y su estado de habilitación (enabled significa que está configurado para iniciarse al arrancar).
  • Active: Esto es crucial. Indica el estado actual del servicio. active (running) significa que el servicio está activo actualmente y sus procesos se están ejecutando. También muestra cuánto tiempo ha estado activo. Otros estados podrían ser inactive (no en ejecución), active (exited) (completó una tarea única) o failed (encontró un error).
  • Main PID: El ID de Proceso (PID) del proceso principal asociado con el servicio, junto con el nombre del comando.
  • Tasks: El número de tareas (hilos) que el servicio está utilizando actualmente.
  • Memory: La cantidad de memoria que está consumiendo el servicio.
  • CPU: El tiempo de CPU consumido por el servicio.
  • CGroup: Información sobre el grupo de control al que pertenece el servicio, que se utiliza para la gestión de recursos.
  • Las líneas debajo de CGroup muestran entradas de registro recientes relacionadas con el servicio, proporcionando información sobre su inicio y actividades en curso.

Además de systemctl status, existen comandos más sencillos para comprobar rápidamente aspectos específicos del estado de un servicio:

  • Para comprobar si un servicio está activo:

    systemctl is-active crond.service

    Salida esperada:

    active
  • Para comprobar si un servicio está habilitado (configurado para iniciarse al arrancar):

    systemctl is-enabled crond.service

    Salida esperada:

    enabled
  • Para comprobar si un servicio ha fallado:

    systemctl is-failed crond.service

    Salida esperada (si se ejecuta correctamente):

    active

    Si un servicio tuvo problemas al iniciarse o ejecutarse, este comando devolvería failed.

Estos comandos son útiles para la creación de scripts o comprobaciones rápidas cuando no necesita la salida detallada completa de systemctl status.

Iniciar, detener y reiniciar un servicio con systemctl

En este paso, aprenderá a gestionar el ciclo de vida de los servicios del sistema utilizando los comandos systemctl. Practicará el inicio, la detención y el reinicio de un servicio. Para este ejercicio, utilizaremos un servicio ficticio que crearemos. Este enfoque garantiza que podamos manipular un servicio de forma segura sin afectar las funciones críticas del sistema.

Primero, creemos un archivo de unidad de servicio simple. Este archivo definirá un servicio que simplemente escribe una marca de tiempo en un archivo de registro cada pocos segundos.

Cree un nuevo archivo de unidad de servicio llamado mytest.service directamente en el directorio del sistema systemd usando nano:

sudo nano /etc/systemd/system/mytest.service

Pegue el siguiente contenido en el editor nano:

[Unit]
Description=My Test Service
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c 'while true; do echo "$(date): My Test Service is running." >> /tmp/mytest.log; sleep 5; done'
ExecStop=/bin/bash -c 'echo "$(date): My Test Service stopped." >> /tmp/mytest.log'
Restart=on-failure

[Install]
WantedBy=multi-user.target
  • [Unit]: Contiene información genérica sobre la unidad. Description proporciona un nombre legible por humanos, y After=network.target especifica que este servicio debe iniciarse después de que la red esté activa.
  • [Service]: Define el comportamiento del servicio.
    • Type=simple: Indica un tipo de servicio simple donde el comando ExecStart es el proceso principal.
    • ExecStart: El comando a ejecutar cuando el servicio se inicia. Aquí, es un bucle bash que escribe un mensaje con marca de tiempo en /tmp/mytest.log cada 5 segundos.
    • ExecStop: El comando a ejecutar cuando el servicio se detiene. Escribe un mensaje de detención en el registro.
    • Restart=on-failure: Configura el servicio para que se reinicie si sale con un estado distinto de cero.
  • [Install]: Contiene información sobre cómo se debe instalar el servicio. WantedBy=multi-user.target significa que este servicio debe iniciarse cuando el sistema alcance el nivel de ejecución multiusuario.

Guarde el archivo presionando Ctrl+X, luego Y para confirmar, y Enter para guardar el archivo.

Ahora, recargue el demonio systemd para que reconozca el nuevo archivo de servicio:

sudo systemctl daemon-reload

Inicio de un Servicio

Para iniciar un servicio, use el comando systemctl start.

Ejecute el siguiente comando para iniciar mytest.service. Tenga en cuenta que necesitamos usar sudo porque las operaciones de systemctl generalmente requieren privilegios de root.

sudo systemctl start mytest.service

No habrá una salida inmediata si el comando es exitoso.

Ahora, verifique que el servicio se está ejecutando comprobando su estado:

systemctl status mytest.service

Debería ver una salida que indique que el servicio está active (running):

● mytest.service - My Test Service
     Loaded: loaded (/etc/systemd/system/mytest.service; disabled; preset: disabled)
     Active: active (running) since ...
   Main PID: ... (bash)
      Tasks: 2 (limit: ...)
     Memory: ...
        CPU: ...
     CGroup: /system.slice/mytest.service
             ├─... /bin/bash -c "while true; do echo \"\$(date): My Test Service is running.\" >> /tmp/mytest.log; sleep 5; done"
             └─... sleep 5

...output omitted...

También puede comprobar el archivo de registro para ver si el servicio está escribiendo mensajes:

tail -f /tmp/mytest.log

Debería ver que aparecen nuevas líneas cada 5 segundos, similar a esto:

Tue Jul 22 09:15:09 AM CST 2025: My Test Service is running.
Tue Jul 22 09:15:14 AM CST 2025: My Test Service is running.

Presione Ctrl+C para salir de tail.

Detención de un Servicio

Para detener un servicio en ejecución, use el comando systemctl stop.

Ejecute el siguiente comando para detener mytest.service:

sudo systemctl stop mytest.service

Nuevamente, no habrá una salida inmediata.

Verifique que el servicio se ha detenido:

systemctl status mytest.service

La salida ahora debería mostrar Active: inactive (dead):

○ mytest.service - My Test Service
     Loaded: loaded (/etc/systemd/system/mytest.service; disabled; preset: disabled)
     Active: inactive (dead) since ...
...output omitted...

Compruebe nuevamente el archivo de registro /tmp/mytest.log. Debería ver el mensaje "My Test Service stopped." y no aparecerán nuevos mensajes de "running".

tail /tmp/mytest.log

La salida se verá similar a esto:

Tue Jul 22 09:15:24 AM CST 2025: My Test Service is running.
Tue Jul 22 09:15:28 AM CST 2025: My Test Service stopped.

Reinicio de un Servicio

Para reiniciar un servicio, use el comando systemctl restart. Este comando primero detiene el servicio y luego lo inicia de nuevo. Esto es útil cuando ha realizado cambios en la configuración de un servicio y necesita que surtan efecto.

Ejecute el siguiente comando para reiniciar mytest.service:

sudo systemctl restart mytest.service

Verifique que el servicio se está ejecutando nuevamente:

systemctl status mytest.service

Debería ver Active: active (running) nuevamente, y el Main PID probablemente será un número nuevo, lo que indica que se ha iniciado un nuevo proceso.

● mytest.service - My Test Service
     Loaded: loaded (/etc/systemd/system/mytest.service; disabled; preset: disabled)
     Active: active (running) since ...
   Main PID: ... (bash)
      Tasks: 2 (limit: ...)
     Memory: ...
        CPU: ...
     CGroup: /system.slice/mytest.service
             ├─... /bin/bash -c "while true; do echo \"\$(date): My Test Service is running.\" >> /tmp/mytest.log; sleep 5; done"
             └─... sleep 5
...output omitted...

Compruebe el archivo de registro /tmp/mytest.log para confirmar que el servicio ha reanudado la escritura de mensajes de "running".

tail -f /tmp/mytest.log

Debería ver un mensaje de "stopped" seguido de nuevos mensajes de "running":

Tue Jul 22 09:15:28 AM CST 2025: My Test Service stopped.
Tue Jul 22 09:15:40 AM CST 2025: My Test Service is running.

Presione Ctrl+C para salir de tail.

Aplicar cambios de configuración a un servicio

En este paso, aprenderá sobre la recarga de configuraciones de servicios. Algunos servicios pueden aplicar cambios a sus archivos de configuración sin necesidad de un reinicio completo. Esto se conoce como "recargar" el servicio. La recarga generalmente se prefiere sobre el reinicio porque evita el tiempo de inactividad del servicio y preserva las conexiones o estados existentes. Cuando un servicio se recarga, su ID de Proceso (PID) típicamente permanece igual, a diferencia de un reinicio completo donde el PID cambia.

Continuaremos usando nuestro mytest.service del paso anterior. Modificaremos su comportamiento e intentaremos recargarlo para ver qué sucede.

Primero, asegúrese de que mytest.service se esté ejecutando. Si no es así, inícielo:

sudo systemctl start mytest.service

Verifique su estado y tome nota de su Main PID:

systemctl status mytest.service

Ahora, modifiquemos el archivo mytest.service para cambiar el mensaje que registra y el intervalo. Cambiaremos el mensaje de registro y la duración de sleep.

Abra /etc/systemd/system/mytest.service con nano:

sudo nano /etc/systemd/system/mytest.service

Cambie la línea ExecStart a la siguiente, modificando el mensaje y el tiempo de sleep de 5 a 2 segundos:

[Unit]
Description=My Test Service
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c 'while true; do echo "$(date): My Test Service (reloaded) is running." >> /tmp/mytest.log; sleep 2; done'
ExecStop=/bin/bash -c 'echo "$(date): My Test Service stopped." >> /tmp/mytest.log'
Restart=on-failure

[Install]
WantedBy=multi-user.target

Guarde el archivo presionando Ctrl+X, luego Y, y Enter.

Después de guardar los cambios, debe informar a systemd que la configuración del servicio ha cambiado.

sudo systemctl daemon-reload

Ahora, intentemos recargar el servicio para aplicar los cambios:

sudo systemctl reload mytest.service

Probablemente encontrará un error:

Failed to reload mytest.service: Job type reload is not applicable for unit mytest.service.

Este error ocurre porque nuestro servicio simple no está configurado para manejar una solicitud de recarga. Para que un servicio sea recargable, su archivo de unidad debe incluir una directiva ExecReload, que especifica el comando a ejecutar para recargar la configuración. Dado que nuestro mytest.service carece de esto, systemd no sabe cómo recargarlo.

En situaciones como esta, systemd proporciona un comando conveniente: reload-or-restart. Este comando intentará recargar el servicio, pero si la recarga no es compatible, recurrirá a reiniciar el servicio. Esta es a menudo una forma más segura y efectiva de aplicar cambios de configuración.

Usemos reload-or-restart ahora:

sudo systemctl reload-or-restart mytest.service

Este comando debería tener éxito. Ahora, verifique el estado del servicio nuevamente:

systemctl status mytest.service

Observe el Main PID. Dado que nuestro servicio se reinició (porque no se pudo recargar), notará que el Main PID es un número nuevo. Esto confirma que el proceso anterior se detuvo y se inició uno nuevo con la configuración actualizada.

Finalmente, revisemos el archivo /tmp/mytest.log para ver si los cambios han surtido efecto.

tail -f /tmp/mytest.log

Debería ver el nuevo mensaje de registro "My Test Service (reloaded) is running." apareciendo cada 2 segundos. Presione Ctrl+C para salir de tail.

Habilitar y deshabilitar servicios al arrancar con systemctl

En este paso, aprenderá a configurar servicios para que se inicien automáticamente al arrancar el sistema (habilitar) o para evitar que se inicien al arrancar (deshabilitar). Esto es crucial para gestionar los recursos del sistema y garantizar que los servicios necesarios estén disponibles cuando el sistema se inicia.

En un entorno systemd típico, habilitar un servicio crea enlaces simbólicos en los directorios de configuración de systemd apropiados (por ejemplo, /etc/systemd/system/multi-user.target.wants/) que apuntan al archivo de unidad del servicio. Deshabilitar un servicio elimina estos enlaces.

Dado que estamos en un entorno contenedorizado donde systemd podría no estar completamente operativo en el sentido tradicional, los comandos enable y disable podrían no crear enlaces simbólicos reales en el directorio /etc/systemd/system que persistan entre reinicios del contenedor. Sin embargo, systemctl aún procesa estos comandos y actualiza su estado interno, que es lo que observaremos.

Continuaremos usando nuestro mytest.service para esta demostración.

Primero, asegúrese de que mytest.service esté detenido del paso anterior:

sudo systemctl stop mytest.service

Habilitar un Servicio

Para habilitar un servicio, use el comando systemctl enable. Este comando configura el servicio para que se inicie automáticamente cuando el sistema arranca.

Ejecute el siguiente comando para habilitar mytest.service:

sudo systemctl enable mytest.service

Es posible que vea una salida similar a esta, que indica que se crearía un enlace simbólico en un entorno systemd completo:

Created symlink /etc/systemd/system/multi-user.target.wants/mytest.service → /etc/systemd/system/mytest.service.

Ahora, verifique que el servicio está habilitado usando systemctl is-enabled:

systemctl is-enabled mytest.service

Salida esperada:

enabled

Esto confirma que systemctl ahora considera que mytest.service está habilitado para el arranque.

También puede combinar el habilitar y el iniciar un servicio en un solo comando usando la opción --now. Esta es una forma conveniente de asegurarse de que un servicio se esté ejecutando inmediatamente y esté configurado para iniciarse en arranques futuros.

Primero, deshabilitémoslo para prepararnos para la demostración con --now:

sudo systemctl disable mytest.service

Ahora, habilítelo e inícielo simultáneamente:

sudo systemctl enable --now mytest.service

Verifique su estado y habilitación:

systemctl status mytest.service
systemctl is-enabled mytest.service

Debería ver Active: active (running) en el comando status y enabled en el comando is-enabled.

Deshabilitar un Servicio

Para deshabilitar un servicio, use el comando systemctl disable. Este comando elimina la configuración que hace que el servicio se inicie al arrancar el sistema.

Ejecute el siguiente comando para deshabilitar mytest.service:

sudo systemctl disable mytest.service

Es posible que vea una salida que indica la eliminación del enlace simbólico:

Removed /etc/systemd/system/multi-user.target.wants/mytest.service.

Ahora, verifique que el servicio está deshabilitado:

systemctl is-enabled mytest.service

Salida esperada:

disabled

De manera similar a habilitar, puede combinar la deshabilitación y la detención de un servicio usando la opción --now. Esto detendrá el servicio inmediatamente y evitará que se inicie en arranques futuros.

sudo systemctl disable --now mytest.service

Verifique su estado y habilitación:

systemctl status mytest.service
systemctl is-enabled mytest.service

Debería ver Active: inactive (dead) en el comando status y disabled en el comando is-enabled.

Esto concluye la demostración de habilitar y deshabilitar servicios. Recuerde que en un entorno systemd real, estos comandos manipulan directamente la configuración de arranque.

Enmascarar y desenmascarar servicios con systemctl

En este último paso, aprenderá sobre el enmascaramiento y desenmascaramiento de servicios. Enmascarar un servicio es una forma potente de evitar que se inicie, ya sea manualmente o automáticamente al arrancar.

Cuando enmascara un servicio, systemd crea un enlace simbólico desde /etc/systemd/system/<nombre-del-servicio>.service a /dev/null, haciendo que el archivo de unidad del servicio sea efectivamente inaccesible para systemd. Esta es una alternativa más robusta a disable.

Este mecanismo funciona mejor para servicios que están definidos en /usr/lib/systemd/system, que es donde los paquetes instalan sus archivos de servicio. El comando mask crea un archivo "vacío" de anulación en /etc/systemd/system. Sin embargo, como ha descubierto, si intenta enmascarar un servicio que creó directamente en /etc/systemd/system (como nuestro mytest.service), el comando puede fallar porque está diseñado para no sobrescribir un archivo de configuración existente, lo que causaría pérdida de datos.

Para demostrar el enmascaramiento correctamente, utilizaremos un servicio preexistente, atd.service.

Primero, verifiquemos el estado actual de atd.service. Debería estar activo y habilitado.

systemctl status atd.service

La salida será similar a esta, mostrando que el servicio está activo y en ejecución:

● atd.service - Deferred execution scheduler
     Loaded: loaded (/usr/lib/systemd/system/atd.service; enabled; preset: enabled)
     Active: active (running) since Tue 2025-07-22 09:13:06 CST; 22min ago
       Docs: man:atd(8)
   Main PID: 1222 (atd)
      Tasks: 1 (limit: 22509)
     Memory: 900.0K
        CPU: 5ms
     CGroup: /system.slice/atd.service
             └─1222 /usr/sbin/atd -f

Enmascarar un Servicio

Es una buena práctica detener un servicio antes de enmascararlo.

sudo systemctl stop atd.service

Ahora, ejecute el siguiente comando para enmascarar atd.service:

sudo systemctl mask atd.service

Verá una salida que indica la creación de un enlace simbólico a /dev/null:

Created symlink /etc/systemd/system/atd.service → /dev/null.

Ahora, intente iniciar el servicio enmascarado:

sudo systemctl start atd.service

Recibirá un mensaje de error, que indica que el servicio está enmascarado:

Failed to start atd.service: Unit atd.service is masked.

También puede verificar el estado del servicio usando systemctl list-unit-files:

systemctl list-unit-files --type=service | grep atd.service

La salida debería mostrar masked para atd.service:

atd.service                            masked      enabled

Esto confirma que el servicio está ahora enmascarado y no se puede iniciar.

Desenmascarar un Servicio

Para desenmascarar un servicio, use el comando systemctl unmask. Este comando elimina el enlace simbólico a /dev/null, restaurando el archivo de servicio original de /usr/lib/systemd/system.

Ejecute el siguiente comando para desenmascarar atd.service:

sudo systemctl unmask atd.service

Verá una salida que indica la eliminación del enlace simbólico:

Removed "/etc/systemd/system/atd.service".

Ahora, verifique el estado del servicio usando systemctl status atd.service nuevamente:

systemctl status atd.service

Debería ver Active: active (running), similar a esto:

● atd.service - Deferred execution scheduler
     Loaded: loaded (/usr/lib/systemd/system/atd.service; enabled; preset: enabled)
     Active: active (running) since Tue 2025-07-22 09:36:10 CST; 2s ago
       Docs: man:atd(8)
   Main PID: 7372 (atd)
      Tasks: 1 (limit: 22509)
     Memory: 868.0K
        CPU: 6ms
     CGroup: /system.slice/atd.service
             └─7372 /usr/sbin/atd -f

Esto concluye el laboratorio sobre el control de servicios y demonios. Ha aprendido a ver, iniciar, detener, reiniciar, recargar, habilitar, deshabilitar, enmascarar y desenmascarar servicios usando systemctl.

Resumen

En este laboratorio, adquirimos experiencia práctica en la gestión de servicios del sistema de control utilizando el comando systemctl, incluso dentro de un entorno contenedorizado donde systemd podría no ser el sistema de inicialización principal. Aprendimos a listar todas las unidades de servicio cargadas y activas usando systemctl list-units --type=service, comprendiendo las columnas UNIT, LOAD, ACTIVE y SUB para interpretar los estados de los servicios.

Además, exploramos operaciones esenciales de gestión de servicios: verificar el estado de un servicio específico con systemctl status, y controlar el ciclo de vida del servicio iniciando, deteniendo y reiniciando servicios. También cubrimos cómo recargar las configuraciones de los servicios, habilitar y deshabilitar servicios para controlar su comportamiento al arrancar, y los conceptos avanzados de enmascarar y desenmascarar servicios para evitar que se inicien. Este conjunto integral de habilidades proporciona una base sólida para gestionar servicios en sistemas RHEL.