I - Intro

Durante mi etapa laboral de help-desk, service-desk…y algo-desk, donde básicamente las tareas son intervenciones técnicas de gran variedad donde no hay clientes finales sino usuarios internos de una empresa; veía cómo los SysAdmin realizaban algunas de sus tareas, sobre servidores Windows o Linux. O incluso a veces me tocaba ejecutarlas a mí.

Quería aprender más sobre Linux. Me despertaba curiosidad saber cómo hacían para que sus propios programas corrieran como un servicio, por ejemplo.

Eso mismo haremos en este post: crear un servicio propio básico para obtener información y monitorear recursos del sistema.

II Planificación

Primero, hagamos un plan de acción con una lista de accionables tipo diagrama del laboratorio.

Luego, al desarrollar cada punto trabajaremos en los aspectos más granulares.

  1. Requisitos.

  2. El script.

  3. El servicio.

  4. Ejecución de todo el flujo de trabajo.

  5. Conclusión.

III Requisitos

  1. ¡Leer los posts anteriores! Ya que están completamente ligados a este tema, la idea es hacer un laboratorio práctico con los conceptos, términos y comandos aprendidos en:

  1. Contar con una distro de Linux con Systemd como administrador de servicios.

  2. Acceso a sudo.

IV El Script

¿Qué es un script y qué hace?

La traducción al español de script es guión. En cierta forma, es lo que hace un script en informática.

Un script informático es un programa que ejecuta comandos de forma secuencial, tal como un guión…primero un comando, luego otro, y así sucesivamente.

¿Cuál es la función del script en nuestro flujo de trabajo?

En nuestro caso de laboratorio, el script se encarga de recolectar información general y de recursos del sistema al momento de la ejecución.

Lo hace ejecutando múltiples comandos y mostrando la información que obtiene con ellos.

Este es un ejemplo de lo que mostrará cada vez que se ejecute:

***Inicio de ejecución***
***Fecha y hora actual: vie 18 oct 2025 09:23:47 CEST***

***Servicio de Monitoreo Básico***

***Datos Generales del Sistema:

Sistema Operativo: Ubuntu 24.04.1 LTS
Nombre del sistema: slimbook-dev
Versión del Kernel: 6.8.0-45-generic
Chassis: laptop 💻
Hardware Model: Slimbook Executive 14
Red: default via 192.168.0.1 dev wlp3s0 proto dhcp src 192.168.0.105 metric 600
IP pública : 2a02:c7e:3012:4800::1
***Recursos del Sistema:
Número de CPUs: 8
Modelo de CPU: Intel Core i7-1165G7 @ 2.80GHz
Memoria RAM total: 16Gi
Memoria RAM disponible: 9,2Gi
Memoria RAM utilizada: 4,8Gi
Espacio total en la partición /: 512G
Espacio disponible en /: 387G
Porcentaje utilizado en /: 24%
Tiempo de Actividad: up 3 hours, 42 minutes
Usuarios conectados: 1

***Fin de la ejecución***

  1. Observar que los comandos que ejecuta son variados sin embargo casi todos comienzan con echo. Echo es un comando que imprime en la terminal, es decir que “muestra en pantalla” texto. En nuestro caso de uso, estamos combinando echo junto a otros comandos.

    Recomiendo experimentar con estos comandos ejecutándolos sin el script, manualmente uno a la vez, y también modificar el script a gusto.

    La siguiente línea de código le especifica al programa que guarde el resultado de la ejecución, es decir la salida o output en el archivo /var/log/systemInfo.log:

    LOG_FILE="/var/log/systemInfo.log"

  2. Crear el siguiente archivo con tu editor de texto favorito -en mi caso utilicé vim:

    sudo vim /usr/local/bin/systemInfo_v1.sh

  3. Copiar y pegar el siguiente contenido, luego guardar los cambios:

    #!/bin/bash

#Publicado en **Proyecto LEETI***
#---> https://www.proyectoleeti.com <---

LOG_FILE="/var/log/systemInfo.log"
{
echo '***Inicio de ejecución***'
echo '***Fecha y hora actual:' $(date)'***'
echo ''
echo '***Servicio de Monitoreo Básico***'
echo ''
echo '***Datos Generales del Sistema:'
echo ''
source /etc/os-release
echo 'Sistema Operativo:' $PRETTY_NAME
echo 'Nombre del sistema:' $(hostname)
echo 'Versión del Kernel:' $(uname -r)
echo $(hostnamectl | grep 'Chassis')
echo $(hostnamectl | grep 'Hardware Model')
echo 'Red:' $(ip route | grep default)
echo 'IP pública :' $(curl -s ifconfig.me)
echo ''
echo '***Recursos del Sistema:'
echo ''
echo 'Número de CPUs:' $(nproc)
echo 'Modelo de CPU:' $(lscpu | grep 'Model name' | sed 's/Model name: *//')
echo 'Memoria RAM total:' $(free -h | grep Mem | awk '{print $2}')
echo 'Memoria RAM disponible:' $(free -h | grep Mem | awk '{print $7}')
echo 'Memoria RAM utilizada:' $(free -h | grep Mem | awk '{print $3}')
echo 'Espacio total en la partición /:' $(df -h / | tail -1 | awk '{print $2}')
echo 'Espacio disponible en /:' $(df -h / | tail -1 | awk '{print $4}')
echo 'Porcentaje utilizado en /:' $(df -h / | tail -1 | awk '{print $5}')
echo 'Tiempo de Actividad:' $(uptime -p)
echo 'Usuarios conectados:' $(who | wc -l)
echo ''
echo '***Fin de la ejecución***'
echo ''
} | tee -a "$LOG_FILE"

  4. Es necesario agregar el permiso de ejecución al archivo para poder, justamente, ejecutarlo:

    sudo chmod +x /usr/local/bin/systemInfo_v1.sh

  5. Probar el script, debería mostrar la información obtenida del sistema, al igual que el ejemplo mostrado al inicio de este capítulo IV.

    sudo /usr/local/bin/systemInfo_v1.sh

    O bien revisando el archivo con el output:

    cat /var/log/systemInfo.log

V El servicio

¿Cuál es la función del servicio en nuestro flujo de trabajo?

El servicio permitirá administrar nuestro script directamente con systemd, por lo que nos brindará las siguientes ventajas:

  • Fácil administración (iniciarlo, detenerlo, ver el estado).

  • Ejecutarlo de forma automatizada.

  • Registrar logs.

  • Practicar un flujo de programa propio típico de un entorno profesional.

  1. Como vimos en el post anterior, el archivo unit sirve al servicio de las configuraciones necesarias para su ejecución, en nuestro caso, crearemos el siguiente archivo unit, el nombre del archivo también le dará nombre al servicio:

    sudo vim /etc/systemd/system/systemInfo.service

  2. El servicio se ejecutará una sola vez al inicio del sistema (oneshot) y lo hará después de que carguen los servicios de red (network.online.target).

  3. Copiar y pegar el contenido:

    [Unit]
Description=Servicio de Monitoreo Básico
Documentation=https://www.proyectoleeti.com
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/systemInfo_v1.sh
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

  4. Para probarlo, primero necesitamos recargar systemctl ya que hay un nuevo servicio que administrar:

    sudo systemctl daemon-reload

  5. Ahora sí, ya casi! Verificar primero el estado del servicio con sudo systemctl status systemInfo, mostrará una salida similar a la siguiente:

    sudo systemctl status systemInfo

  6. ○ systemInfo.service - Servicio de Monitoreo Básico
     Loaded: loaded (/etc/systemd/system/systemInfo.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
       Docs: https://www.proyectoleeti.com

  7. Luego iniciarlo con sudo systemctl start systemInfo:

    sudo systemctl start systemInfo

  8. En este punto, debió suceder lo siguiente:

    1. Iniciar el servicio systemInfo.

    2. Ejecutar el script /usr/local/bin/systemInfo_v1.sh.

    3. Escribir la información recolectada en el archivo /var/log/systemInfo.log.

    4. Detener el servicio systemInfo.

  9. ¿Cómo verificamos si se ejecutó bien? Tenemos más de una forma:

    1. Ejecutar sudo systemctl status systemInfo lo cual nos mostrará información valiosa como última fecha/hora de ejecución, ID de proceso y su estado de ejecución, como así también las últimas líneas del log:

      Active: inactive (dead) since Sun 2025-10-19 17:01:52 CEST; 3s ago
Main PID: 31006 (code=exited, status=0/SUCCESS)

oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: Memoria RAM disponible: 5,9Gi
oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: Memoria RAM utilizada: 6,8Gi
oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: Espacio total en la partición /: 476G

    2. Revisar los logs del servicio, a través de:

      sudo journalctl -u systemInfo.service

    3. Para mostrar más logs presionar la barra espaciadora hasta llegar al final del journal:

      1. sudo journalctl -u systemInfo 
oct 17 12:56:13 slimbook-dev systemd[1]: Starting systemInfo.service - Servicio de Monitoreo Básico...
oct 17 12:56:13 slimbook-dev systemInfo_v1.sh[21142]: ***Inicio de ejecución***
oct 17 12:56:13 slimbook-dev systemInfo_v1.sh[21142]: ***Servicio de Monitoreo Básico***
oct 17 12:56:13 slimbook-dev systemInfo_v1.sh[21142]: ***Datos Generales del Sistema:
oct 17 12:56:13 slimbook-dev systemInfo_v1.sh[21142]: Fecha y hora: vie 17 oct 2025 12:56:13 CEST
...
oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: Tiempo de Actividad: up 4 hours, 55 minutes
oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: Usuarios conectados: 3
oct 19 17:01:52 slimbook-dev systemInfo_v1.sh[31008]: ***Fin de la ejecución***
oct 19 17:01:52 slimbook-dev systemd[1]: systemInfo.service: Deactivated successfully.
oct 19 17:01:52 slimbook-dev systemd[1]: Finished systemInfo.service - Servicio de Monitoreo Básico.

    4. Verificar el archivo de log propio del script, revisar el contenido del archivo con comandos como cat, less o view:

      view /var/log/systemInfo.log

    5. Una vez confirmado que funciona, habilitar el servicio para que se inicie automáticamente en cada inicio del OS, es decir, cargado por init:

      sudo systemctl enable systemInfo

    6. Obtendremos una salida similar a la siguiente:

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

Galería de screenshots:

Habilitar el servicio, cargar systemctl nuevamente y reiniciar para ver los efectos. Ver el archivo de salida-output, uno de los métodos de verificación. Comprobar el estado del servicio y detalles como última ejecución y últimos logs del journal.

VI Ejecución de todo el flujo de trabajo

Para recrear una prueba completa, basta con reiniciar el sistema. El servicio debe haberse ejecutado junto al script, y finalizado tras escribir la información recolectada en el archivo de systemInfo.log.

Revisarlo con cualquiera de los tres métodos mostrados en el capítulo anterior V. Recordar que el script registra la fecha y hora de cada ejecución por un lado, y por otro lado, el journal hace lo propio con el servicio. Ambas ejecuciones deben coincidir.

Les comparto otro ejemplo del script, pero ejecutado en una VM (máquina virtual) con Ubuntu bajo Proxmox en un BMS (bare metal server):

***Inicio de ejecución***
***Fecha y hora actual: jue 23 oct 2025 09:31:54 UTC***

***Servicio de Monitoreo Básico***

***Datos Generales del Sistema:

Sistema Operativo: Ubuntu 22.04.5 LTS
Nombre del sistema: vm-dev-ubu-22-04
Versión del Kernel: 5.15.0-160-generic
Chassis: vm
Hardware Model: Standard PC _i440FX + PIIX, 1996_
Red: default via 10.0.0.1 dev ens18 proto static
IP pública : 43.70.61.121

***Recursos del Sistema:

Número de CPUs: 1
Modelo de CPU: QEMU Virtual CPU version 2.5+
Memoria RAM total: 1,9Gi
Memoria RAM disponible: 1,6Gi
Memoria RAM utilizada: 130Mi
Espacio total en la partición /: 15G
Espacio disponible en /: 6,9G
Porcentaje utilizado en /: 51%
Tiempo de Actividad: up 0 minutes
Usuarios conectados: 0

***Fin de la ejecución***

VII Conclusión

“Crear un servicio en Linux”, ¿suena complicado, cierto? Podemos ver que de hecho es bastante simple y directo.

Lo más importante es entender el funcionamiento y el potencial. Al ejecutar cada comando uno mismo, leer los archivos man de los comandos, hacer al menos una configuración de inicio a fin, podemos imaginarnos diferentes casos de uso y el potencial que tienen estas herramientas para aplicarlas en distintos escenarios personales y laborales.

🐧 Te aliento a probar tus propios scripts, romper, corregir, leer…seguir aprendiendo y compartir!

Hasta el siguiente post! 🐧