> For the complete documentation index, see [llms.txt](https://es-kb.topopool.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://es-kb.topopool.com/primeros-pasos/ejecutar-servicio.md).

# Ejecutar como un servicio

Vamos a configurar los nodos como servicios de systemd. Así se inician automáticamente al arrancar el servidor y los gestionamos con `systemctl` como cualquier otro servicio del sistema.

***

## Variables de entorno

Cada nodo necesita saber dónde están sus archivos y qué puertos usar. En lugar de meter todo en el archivo de servicio, usamos archivos de entorno separados — es más limpio y fácil de cambiar sin tocar el servicio.

{% hint style="info" %}
En los ejemplos usamos `TU_USUARIO` como placeholder. Reemplázalo con tu nombre de usuario real (puedes verificarlo con `whoami`).
{% endhint %}

### Crear el directorio de configuración

```bash
sudo mkdir -p /etc/cardano
```

### Archivo de entorno — Relay

```bash
sudo nano /etc/cardano/relay.env
```

```bash
CARDANO_NODE_SOCKET_PATH=/home/TU_USUARIO/cardano/relay/db/node.socket
CONFIG=/home/TU_USUARIO/cardano/relay/config/config.json
TOPOLOGY=/home/TU_USUARIO/cardano/relay/config/topology.json
DB_PATH=/home/TU_USUARIO/cardano/relay/db
HOST_ADDR=0.0.0.0
PORT=3000
```

### Archivo de entorno — Block Producer

```bash
sudo nano /etc/cardano/bp.env
```

```bash
CARDANO_NODE_SOCKET_PATH=/home/TU_USUARIO/cardano/bp/db/node.socket
CONFIG=/home/TU_USUARIO/cardano/bp/config/config.json
TOPOLOGY=/home/TU_USUARIO/cardano/bp/config/topology.json
DB_PATH=/home/TU_USUARIO/cardano/bp/db
HOST_ADDR=0.0.0.0
PORT=3000
KES_KEY=/home/TU_USUARIO/cardano/bp/keys/kes.skey
VRF_KEY=/home/TU_USUARIO/cardano/bp/keys/vrf.skey
CERT=/home/TU_USUARIO/cardano/bp/keys/node.cert
```

***

## Servicio systemd — Relay

```bash
sudo nano /etc/systemd/system/RELAY.service
```

```ini
[Unit]
Description=Cardano Relay Node
After=network.target

[Service]
Type=simple
User=TU_USUARIO
EnvironmentFile=/etc/cardano/relay.env
ExecStart=/usr/local/bin/cardano-node run \
  --config $CONFIG \
  --topology $TOPOLOGY \
  --database-path $DB_PATH \
  --socket-path $CARDANO_NODE_SOCKET_PATH \
  --host-addr $HOST_ADDR \
  --port $PORT \
  +RTS -N -RTS
KillSignal=SIGINT
RestartKillSignal=SIGINT
StandardOutput=journal
StandardError=journal
SyslogIdentifier=RELAY
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```

{% hint style="info" %}
`+RTS -N -RTS` le dice al runtime de Haskell que use todos los cores disponibles. En servidores dedicados está bien dejarlo así. Si el servidor comparte carga con otros procesos, puedes limitarlo con `-N2` o `-N4`.
{% endhint %}

***

## Servicio systemd — Block Producer

Arranca primero con la variante sin claves para verificar que el nodo sincroniza y conecta bien con los relays. Solo después activamos la forja de bloques.

```bash
sudo nano /etc/systemd/system/BP.service
```

{% tabs %}
{% tab title="BP — Con claves (producción)" %}

```ini
[Unit]
Description=Cardano Block Producer
After=network.target

[Service]
Type=simple
User=TU_USUARIO
EnvironmentFile=/etc/cardano/bp.env
ExecStart=/usr/local/bin/cardano-node run \
  --config $CONFIG \
  --topology $TOPOLOGY \
  --database-path $DB_PATH \
  --socket-path $CARDANO_NODE_SOCKET_PATH \
  --host-addr $HOST_ADDR \
  --port $PORT \
  --shelley-kes-key $KES_KEY \
  --shelley-vrf-key $VRF_KEY \
  --shelley-operational-certificate $CERT \
  +RTS -N -RTS
KillSignal=SIGINT
RestartKillSignal=SIGINT
StandardOutput=journal
StandardError=journal
SyslogIdentifier=BP
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```

{% endtab %}

{% tab title="BP — Sin claves (verificación inicial)" %}

```ini
[Unit]
Description=Cardano Block Producer (sin claves)
After=network.target

[Service]
Type=simple
User=TU_USUARIO
EnvironmentFile=/etc/cardano/bp.env
ExecStart=/usr/local/bin/cardano-node run \
  --config $CONFIG \
  --topology $TOPOLOGY \
  --database-path $DB_PATH \
  --socket-path $CARDANO_NODE_SOCKET_PATH \
  --host-addr $HOST_ADDR \
  --port $PORT \
  +RTS -N -RTS
KillSignal=SIGINT
RestartKillSignal=SIGINT
StandardOutput=journal
StandardError=journal
SyslogIdentifier=BP
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
Arranca primero con la variante sin claves. Confirma que el nodo sincroniza y que los peers del relay aparecen conectados. Solo entonces pasamos a la versión con claves.
{% endhint %}

***

## Activar y arrancar los servicios

Cada vez que creamos o modificamos un archivo `.service`, recargamos systemd:

```bash
sudo systemctl daemon-reload
```

Habilitamos el arranque automático y levantamos los servicios:

```bash
# Relay
sudo systemctl enable RELAY
sudo systemctl start RELAY

# Block Producer
sudo systemctl enable BP
sudo systemctl start BP
```

{% hint style="info" %}
`enable` hace que el servicio arranque al iniciar el servidor. `start` lo levanta ahora mismo sin necesidad de reiniciar.
{% endhint %}

***

## Ver los logs

Para seguir los logs en tiempo real usamos `journalctl`:

```bash
# Relay — logs en tiempo real
journalctl -fu RELAY

# Block Producer — logs en tiempo real
journalctl -fu BP
```

Últimas 100 líneas sin seguimiento continuo:

```bash
journalctl -u RELAY -n 100
```

Filtrar por fecha o errores:

```bash
journalctl -u RELAY --since "2024-01-15 10:00:00"
journalctl -u RELAY -p err
```

***

## Comandos de gestión habituales

```bash
# Estado del servicio
sudo systemctl status RELAY
sudo systemctl status BP

# Reiniciar (por ejemplo, tras cambiar la topología)
sudo systemctl restart RELAY

# Parar
sudo systemctl stop RELAY

# Recargar configuración de systemd tras modificar el .service
sudo systemctl daemon-reload
```

{% hint style="danger" %}
Antes de parar el BP para mantenimiento, confirma que el relay sigue activo y conectado. Si paras ambos a la vez, tu pool deja de ser visible en la red.
{% endhint %}

***

## Verificar que el socket existe

Una vez arrancado el nodo, verificamos que está funcionando:

```bash
ls -la $HOME/cardano/relay/db/node.socket

export CARDANO_NODE_SOCKET_PATH=$HOME/cardano/relay/db/node.socket
cardano-cli query tip --mainnet
```

Si `cardano-cli query tip` devuelve el slot actual de la cadena, el nodo está sincronizando correctamente.