Creación y manejo de demonios

Creación y manejo de demonios

Es un proceso de Linux que da un comportamiento de servicio a un programa: es decir, que se ejecuta en segundo plano sin la interacción de un usuario.

• systemd : crea los demonios
• systemctl: gestiona los demonios

Para crear un demonio primero debes:

• Crear el script o unit file que usará de base tu demonio, esto puedes hacerlo con Python u otro lenguaje de scripting.

• Es importante crear el folder donde se alojará el unit file a nivel de root, de esta manera estará disponible para todos los usuarios.

• Crear la carpeta en donde alojaremos la información generada por nuestro unit file.

• ir a /etc/systemd/system y crear el script que beberá del primero para poder correr el demonio.

• reiniciamos los demonios con:

   systemctl daemons-reload
  

• Habilitamos con:

   systemctl enable loggerpython.service
  

• Activamos con:

   systemctl start loggerpython.service
  

mi aporte en ruby guardandolo en un archivo llamado poem

class File
  def self.my_open(filename, mode)
    file = self.new(filename, mode)
    return file unless block_given?
    begin
      yield file
    rescue Exception => e
      p e.message
    ensure
      file.close
    end
  end
end

File.my_open("poem.txt", "w") do |f|
  f.puts "Hello world"
  while true
   sleep(1)
   f.puts Time.now
  end
end

Intento con bash

#!/bin/bash
#
# datetime logger
#
# Usage:
# - First make it executable by running chmod +x ./logger.sh
# - Then run it with ./logger.sh
#
# If run from the right location (/scripts) and with the right privileges (root) it shouldn't produce errors but you can always redirect the stderr to a file or to /dev/null if you need to.
# that would be ./logger.sh 2> error.log or ./logger.sh 2>/dev/null

while true; do
        echo "Timestamp: $(date '+%Y-%m-%d %H:%M:%S')" >> /datelogs/timestamp.txt
        sleep 1
done

Esto ya lo había hecho en la universidad :0 pero no sabía que se llamaban “unit files” solo les conocia como scripts de arranque

IMPLEMENTACIÓN DE UN ARCHIVO DE UNIDAD DE SERVICIO (DAEMON)
.
La implementación de un archivo de unidad de servicio en systemd implica seguir una sintaxis específica y definir varias opciones de configuración. Aquí hay un ejemplo básico de cómo sería la implementación de un archivo de unidad de servicio:
.

1. Abre un editor de texto y crea un nuevo archivo con una extensión .service. Por ejemplo, puedes usar el comando sudo nano /etc/systemd/system/mi_servicio.service para crear y abrir el archivo con el editor de texto nano (asegúrate de tener privilegios de superusuario para realizar esta operación).
   .
2. En el archivo, define las siguientes secciones y opciones de configuración:

[Unit]
Description=Descripción de mi servicio
After=network.target   # Dependencias, si es necesario

[Service]
ExecStart=/ruta/al/comando-de-inicio   # Comando para iniciar el servicio
ExecStop=/ruta/al/comando-de-detencion   # Comando para detener el servicio, si es necesario
Restart=always   # Opciones de reinicio, si es necesario
User=nombre_de_usuario   # Usuario bajo el cual se ejecuta el servicio
Group=nombre_de_grupo   # Grupo asociado al servicio
WorkingDirectory=/ruta/al/directorio/de/trabajo   # Directorio de trabajo del servicio, si es necesario

[Install]
WantedBy=multi-user.target   # Objetivo en el que se habilitará el servicio

Reemplaza /ruta/al/comando-de-inicio con la ruta absoluta del comando que se utilizará para iniciar el servicio. Puede ser un script, un binario o cualquier otro comando necesario para iniciar tu servicio.
.
Opcionalmente, reemplaza /ruta/al/comando-de-detencion con la ruta absoluta del comando que se utilizará para detener el servicio, si es necesario. Si no se especifica, systemd intentará detener el servicio enviando una señal SIGTERM al proceso principal.
.
Opcionalmente, ajusta las otras opciones de configuración según las necesidades de tu servicio.
.
Guarda y cierra el archivo.
.
Ejecuta el comando sudo systemctl daemon-reload para que systemd reconozca el nuevo archivo de unidad de servicio.
.
Para iniciar el servicio, usa el comando sudo systemctl start mi_servicio (reemplaza mi_servicio con el nombre del archivo de unidad de servicio sin la extensión .service).
.
Para detener el servicio, usa el comando sudo systemctl stop mi_servicio.

Para habilitar que el servicio se inicie automáticamente en el arranque del sistema, usa el comando sudo systemctl enable mi_servicio.
.
Con estos pasos, has implementado un archivo de unidad de servicio básico en systemd. Recuerda que puedes ajustar y personalizar las opciones de configuración según las necesidades específicas de tu servicio.
.
Fuente:ChatGPT.

si dice que el directorio no existe pongan solo dos puntos a la ruta, recuerden que python aveces o dependiendo su configuracion siempre hace referencia desde el punto donde esta y no desde el /home

import time
from datetime import datetime


while True:
    with open("../datelogs/tiempoAhora.txt","a") as file:
        file.write("\ntiempo ahora: {}".format(datetime.now()))
        file.close()
    time.sleep(1)

Código transformado a TypeScript y con comentarios agregados

import * as fs from 'fs';
import * as path from 'path';
import { promisify } from 'util';

const sleep = promisify(setTimeout);

async function writeTimestamp(): Promise<void> {
  const filePath = '/datelogs/timestamp.txt';

  while (true) {
    // Open the file in append mode
    const fileHandle = await fs.promises.open(filePath, 'a');
    
    try {
      // Get the current timestamp
      const timestamp = new Date().toISOString();
      
      // Append the timestamp to the file
      await fileHandle.appendFile(`\nTimestamp: ${timestamp}`);
    } finally {
      // Close the file handle
      await fileHandle.close();
    }
    
    // Wait for 1 second
    await sleep(1000);
  }
}

writeTimestamp().catch(console.error);

Vemos estado con:

<systemctl status loggerpython.service> 

Habilitamos con:

<systemctl enable loggerpython.service> 

Activamos con:

< systemctl start loggerpython.service> 

Detenemos con

< systemctl stop loggerpython.service> 

Desahabilitamos con

< systemctl disable loggerpython.service> 

Estoy impresionado con lo que pueden hacer los demonios y como son creados a ser ejecutados sin ningun problema. Aprendi mucho de crearlos y manejarlos. Esta fue una gra clase que no olvidare. A seguir

UNIT FILES

Los “unit files” son archivos de configuración utilizados por systemd, el administrador de sistema y servicios en los sistemas operativos Linux. Estos archivos definen cómo systemd administra y controla varios servicios del sistema, objetivos, dispositivos, sockets y otras unidades. Por lo general, se almacenan en el directorio /etc/systemd/system/ o en directorios dentro de /lib/systemd/system/.
_
Existen varios tipos de archivos de unidades, cada uno con un propósito específico:

Archivos de unidad de servicio (*.service): Estos archivos definen servicios del sistema, que son procesos en ejecución continua. Especifican los comandos para iniciar, detener y administrar el servicio. Las unidades de servicio también pueden definir dependencias con otras unidades.
_
Archivos de unidad de objetivo (*.target): Las unidades de objetivo representan grupos de servicios que deben iniciarse o detenerse juntos. Actúan como puntos de sincronización para iniciar o detener varios servicios simultáneamente.
_
Archivos de unidad de socket (*.socket): Las unidades de socket definen sockets de comunicación entre procesos (IPC). Especifican el tipo de socket, la dirección de escucha y otros parámetros.
_
Archivos de unidad de dispositivo (*.device): Las unidades de dispositivo representan dispositivos del kernel, como dispositivos de hardware o dispositivos virtuales. Permiten que systemd administre operaciones específicas del dispositivo, como la creación de nodos de dispositivo o la carga de módulos.
_
Archivos de unidad de montaje (*.mount): Las unidades de montaje controlan el montaje y desmontaje de sistemas de archivos. Especifican el punto de montaje, el tipo de sistema de archivos y las opciones.
_
Archivos de unidad de temporizador (*.timer): Las unidades de temporizador definen temporizadores que activan la ejecución de otras unidades en intervalos específicos o en momentos específicos.

Estos son algunos de los tipos de archivos de unidad comúnmente utilizados en systemd. Cada archivo de unidad sigue una sintaxis específica e incluye varias opciones de configuración específicas de su tipo. Al crear o modificar estos archivos de unidad, los administradores del sistema pueden controlar cómo systemd administra e inicia varios componentes del sistema.

Fuente: ChatGPT.