Nodo Cardano II: Block Producer

Nodo Cardano II: Configuración del Block Producer

Este artículo documenta la configuración del block producer (cnode01) como parte de un stake pool de Cardano. El block producer es el nodo que firma y produce bloques — es el corazón del pool y requiere un nivel de seguridad mayor que el relay.

Info: La configuración del block producer parte de la base establecida en el Artículo 1 — Relay Node. Antes de continuar, asegúrate de haber completado ese artículo en cnode01 — la compilación del nodo, las dependencias y la estructura de directorios son idénticas.

Seguridad crítica: Las claves del pool nunca deben estar en el relay. El block producer no debe tener acceso directo a Internet — solo debe comunicarse con el relay home lab.

Índice

Prerequisitos
Arquitectura y topología del pool
Generar claves del stake pool
Preparar USB para transferencia de archivos
Crear el certificado operacional
Configurar topología del block producer
Script de inicio del block producer
Servicio systemd del block producer
Monitoreo del block producer con gLiveView
Variables y alias del block producer
Recursos adicionales

1. Prerequisitos

Antes de continuar, asegúrate de tener lo siguiente:

Software y configuración previa:

cnode02 configurado como relay node y sincronizado ( Artículo 1 — Relay Node)
cnode01 con Ubuntu 22.04.5 instalado
cardano-node compilado en cnode01 siguiendo las secciones 3 a 9 del Artículo 1
Una memoria USB para transferir archivos entre cnode01 y la máquina air-gapped

Info: Los pasos de preparación del sistema, instalación de dependencias y compilación del nodo son idénticos para el relay y el block producer. Sigue las secciones 3–9 del Artículo 1 en cnode01 antes de continuar.

2. Arquitectura y topología del pool

El block producer es el nodo que firma y produce bloques. A diferencia del relay, requiere claves criptográficas privadas y debe estar en un servidor separado, accesible únicamente desde el relay.

Seguridad crítica: Las claves del pool nunca deben estar en el relay. El block producer no debe tener acceso directo a Internet — solo debe comunicarse con el relay home lab.

Inventario de equipos

Rol	Hostname	IP	Ubicación
Block Producer	`cnode01`	`192.168.50.201`	Home Lab
Relay Home Lab	`cnode02`	`<IP_PUBLICA>`	Home Lab

Arquitectura de red

                        Internet
                            │
             ┌──────────────┘
             │ NIC 1: <IP_PUBLICA>
   ┌─────────┴───────────┐
   │  Relay Home Lab     │
   │  cnode02            │
   │  puerto 3003        │
   └─────────┬───────────┘
             │ NIC 2: 192.168.50.202 (red local)
   ┌─────────┴───────────┐
   │  Block Producer     │
   │  cnode01            │
   │  192.168.50.201     │
   │  puerto 3000        │
   │  sin acceso Internet│
   └─────────────────────┘

Reglas de firewall

cnode01 — Block Producer

# Permitir SSH solo desde red local
sudo ufw allow from 192.168.50.0/24 to any port 22

# Permitir tráfico entrante del relay home lab
sudo ufw allow from 192.168.50.202 to any port 3000

# Bloquear todo tráfico saliente hacia Internet
sudo ufw default deny outgoing
sudo ufw allow out to 192.168.50.0/24

sudo ufw enable

cnode02 — Relay Home Lab

# Denegar todo tráfico entrante por defecto
sudo ufw default deny incoming

# Permitir SSH solo desde red local (NIC 2)
sudo ufw allow from 192.168.50.0/24 to any port 22

# Permitir tráfico Cardano entrante desde Internet (NIC 1)
sudo ufw allow 3003/tcp

sudo ufw enable

3. Generar claves del stake pool

Las claves se generan en el servidor block producer y se almacenan en el directorio keys de la red correspondiente. Nunca las copies al relay.

Claves KES (Key Evolving Signature)

Las claves KES se usan para firmar bloques y deben rotarse cada 90 días (62 épocas en Preview):

cnode01 — Block Producer

# Preview
cardano-cli node key-gen-KES \
    --verification-key-file $HOME/cardano-my-node/preview/keys/kes.vkey \
    --signing-key-file $HOME/cardano-my-node/preview/keys/kes.skey

chmod 400 $HOME/cardano-my-node/preview/keys/kes.skey

# Mainnet (para migración futura)
cardano-cli node key-gen-KES \
    --verification-key-file $HOME/cardano-my-node/mainnet/keys/kes.vkey \
    --signing-key-file $HOME/cardano-my-node/mainnet/keys/kes.skey

chmod 400 $HOME/cardano-my-node/mainnet/keys/kes.skey

Claves VRF (Verifiable Random Function)

Las claves VRF determinan si el pool fue seleccionado para producir un bloque:

cnode01 — Block Producer

# Preview
cardano-cli node key-gen-VRF \
    --verification-key-file $HOME/cardano-my-node/preview/keys/vrf.vkey \
    --signing-key-file $HOME/cardano-my-node/preview/keys/vrf.skey

chmod 400 $HOME/cardano-my-node/preview/keys/vrf.skey

# Mainnet (para migración futura)
cardano-cli node key-gen-VRF \
    --verification-key-file $HOME/cardano-my-node/mainnet/keys/vrf.vkey \
    --signing-key-file $HOME/cardano-my-node/mainnet/keys/vrf.skey

chmod 400 $HOME/cardano-my-node/mainnet/keys/vrf.skey

Claves Cold (offline)

Crítico: Las claves cold deben generarse y mantenerse en una máquina air-gapped (sin conexión a Internet). Nunca las copies al servidor block producer.

air-gapped — Sin conexión a red

# Crear estructura de carpetas para todas las redes
mkdir -p $HOME/cold-keys/{mainnet,preview}
mkdir -p $HOME/keys/{mainnet,preview}
mkdir -p $HOME/cert/{mainnet,preview}

La estructura quedará así:

$HOME/
├── cold-keys/         ← solo *.skey (claves privadas)
│   ├── mainnet/
│   └── preview/
├── keys/              ← *.vkey y *.counter
│   ├── mainnet/
│   └── preview/
└── cert/              ← opcert y otros certificados
    ├── mainnet/
    └── preview/

# Preview
cardano-cli conway node key-gen \
    --cold-verification-key-file $HOME/keys/preview/cold.vkey \
    --cold-signing-key-file $HOME/cold-keys/preview/cold.skey \
    --operational-certificate-issue-counter-file $HOME/keys/preview/cold.counter

# Mainnet (para migración futura)
cardano-cli conway node key-gen \
    --cold-verification-key-file $HOME/keys/mainnet/cold.vkey \
    --cold-signing-key-file $HOME/cold-keys/mainnet/cold.skey \
    --operational-certificate-issue-counter-file $HOME/keys/mainnet/cold.counter

4. Preparar USB para transferencia de archivos

Toda transferencia de claves y certificados entre cnode01 y la máquina air-gapped se realiza físicamente vía USB. Este procedimiento aplica tanto a cnode01 como a la máquina air-gapped — ejecuta los mismos pasos en cada máquina cada vez que conectes el USB.

Identificar el dispositivo USB

lsblk -o NAME,SIZE,RM,MOUNTPOINT

Salida típica:

NAME   SIZE RM MOUNTPOINT
sda   238.5G  0 /
└─sda1 238.5G  0 /
sdb    14.9G  1            ← USB (RM=1 indica dispositivo removible)
└─sdb1 14.9G  0

El USB aparece como sdb o sdc — se identifica porque RM es 1. El número de partición (sdb1) es el que se usa para montar.

Crear el punto de montaje

sudo mkdir -p /mnt/usb

Montar el USB

sudo mount /dev/sdb1 /mnt/usb

Info: Reemplaza sdb1 con el nombre de partición que identificaste en el paso anterior.

Verifica que el montaje fue exitoso:

lsblk -o NAME,SIZE,RM,MOUNTPOINT | grep /mnt/usb
# Salida esperada:
# sdb1  14.9G  0 /mnt/usb

Crear la estructura de carpetas en el USB

Una vez montado el USB, crea la estructura de directorios que se usará durante todo el proceso:

mkdir -p /mnt/usb/{keys,metadata}
mkdir -p /mnt/usb/preview/{keys,cert,addresses}
mkdir -p /mnt/usb/mainnet/{keys,cert,addresses}

La estructura queda así:

/mnt/usb/
├── keys/               ← cold.vkey, payment.vkey, stake.vkey  (compartidas entre redes)
├── metadata/           ← pool-metadata.json, pool-metadata.hash
├── preview/
│   ├── keys/           ← kes.vkey, cold.counter
│   ├── cert/           ← opcert.cert, pool-registration.cert, stake-registration.cert
│   └── addresses/      ← payment.addr, stake.addr
└── mainnet/
    ├── keys/
    ├── cert/
    └── addresses/

Seguridad crítica: Las claves privadas (*.skey) nunca deben copiarse al USB. Solo se transfieren claves públicas (*.vkey), contadores y certificados.

Desmontar el USB

Siempre desmonta el USB de forma segura antes de retirarlo:

sudo umount /mnt/usb

5. Crear el certificado operacional

El certificado operacional (opcert) vincula las claves KES con las claves cold y tiene una validez limitada.

Primero obtén el número de período KES actual desde el relay sincronizado:

cnode02 — Relay Home Lab

# Preview
export CARDANO_NODE_SOCKET_PATH="${HOME}/cardano-my-node/preview/socket/node.socket"
slotsPerKESPeriod=$(cat $HOME/cardano-my-node/preview/config/shelley-genesis.json | jq -r '.slotsPerKESPeriod')
echo slotsPerKESPeriod: ${slotsPerKESPeriod}
slotNo=$(cardano-cli conway query tip --testnet-magic 2 | jq -r '.slot')
echo slotNo: ${slotNo}
kesPeriod=$((${slotNo} / ${slotsPerKESPeriod}))
echo kesPeriod: ${kesPeriod}

# Mainnet (para migración futura)
export CARDANO_NODE_SOCKET_PATH="${HOME}/cardano-my-node/mainnet/socket/node.socket"
slotsPerKESPeriod=$(cat $HOME/cardano-my-node/mainnet/config/shelley-genesis.json | jq -r '.slotsPerKESPeriod')
echo slotsPerKESPeriod: ${slotsPerKESPeriod}
slotNo=$(cardano-cli conway query tip --mainnet | jq -r '.slot')
echo slotNo: ${slotNo}
kesPeriod=$((${slotNo} / ${slotsPerKESPeriod}))
echo kesPeriod: ${kesPeriod}

Info: Anota el valor de kesPeriod de la red correspondiente — lo necesitarás en el siguiente paso para generar el opcert.

Aviso: Toda transferencia entre cnode01 y la máquina air-gapped es siempre física (USB). Nunca conectes la máquina air-gapped a la red.

cnode01 — Block Producer — Paso 1: copiar kes.vkey al USB

cp $HOME/cardano-my-node/preview/keys/kes.vkey /mnt/usb/preview/keys/kes.vkey

# Mainnet (para migración futura)
cp $HOME/cardano-my-node/mainnet/keys/kes.vkey /mnt/usb/mainnet/keys/kes.vkey

air-gapped — Paso 2: copiar desde USB y generar el opcert

# Copiar kes.vkey desde USB
cp /mnt/usb/preview/keys/kes.vkey $HOME/keys/preview/kes.vkey

# Mainnet (para migración futura)
cp /mnt/usb/mainnet/keys/kes.vkey $HOME/keys/mainnet/kes.vkey

# Generar opcert — Preview
cardano-cli conway node issue-op-cert \
    --kes-verification-key-file $HOME/keys/preview/kes.vkey \
    --cold-signing-key-file $HOME/cold-keys/preview/cold.skey \
    --operational-certificate-issue-counter $HOME/keys/preview/cold.counter \
    --kes-period <PERIODO_KES_PREVIEW> \
    --out-file $HOME/cert/preview/opcert.cert

# Generar opcert — Mainnet (para migración futura)
cardano-cli conway node issue-op-cert \
    --kes-verification-key-file $HOME/keys/mainnet/kes.vkey \
    --cold-signing-key-file $HOME/cold-keys/mainnet/cold.skey \
    --operational-certificate-issue-counter $HOME/keys/mainnet/cold.counter \
    --kes-period <PERIODO_KES_MAINNET> \
    --out-file $HOME/cert/mainnet/opcert.cert

air-gapped — Paso 3: copiar certificados al USB

cp $HOME/cert/preview/opcert.cert /mnt/usb/preview/cert/opcert.cert

# Mainnet (para migración futura)
cp $HOME/cert/mainnet/opcert.cert /mnt/usb/mainnet/cert/opcert.cert

cnode01 — Block Producer — Paso 4: copiar certificados desde USB

cp /mnt/usb/preview/cert/opcert.cert $HOME/cardano-my-node/preview/keys/opcert.cert

# Mainnet (para migración futura)
cp /mnt/usb/mainnet/cert/opcert.cert $HOME/cardano-my-node/mainnet/keys/opcert.cert

6. Configurar topología del block producer

Topología de tres nodos: relay cloud (cnode03), relay home lab (cnode02) y block producer (cnode01). El BP solo se comunica con el relay home lab, nunca directamente con Internet.

Internet → cnode02 (Relay Home Lab, <IP_PUBLICA>) → cnode01 (Block Producer, 192.168.50.201)

Block Producer — cnode01 (192.168.50.201)

cnode01 — Block Producer

cat > $HOME/cardano-my-node/preview/config/topology.json << 'EOF'
{
  "bootstrapPeers": [],
  "localRoots": [
    {
      "accessPoints": [
        {
          "address": "192.168.50.202",
          "port": 3003
        }
      ],
      "advertise": false,
      "trustable": true,
      "valency": 1
    }
  ],
  "publicRoots": [],
  "useLedgerAfterSlot": -1
}
EOF

Info: useLedgerAfterSlot: -1 deshabilita el descubrimiento de peers por ledger. El block producer solo se conecta al relay home lab cnode02.

Relay Home Lab — cnode02 (<IP_PUBLICA>)

cnode02 — Relay Home Lab

cat > $HOME/cardano-my-node/preview/config/topology.json << 'EOF'
{
  "bootstrapPeers": [
    {
      "address": "preview-node.world.dev.cardano.org",
      "port": 30002
    }
  ],
  "localRoots": [
    {
      "accessPoints": [
        {
          "address": "192.168.50.201",
          "port": 3000
        }
      ],
      "advertise": false,
      "trustable": true,
      "valency": 1
    }
  ],
  "publicRoots": [
    {
      "accessPoints": [
        {
          "address": "preview-node.world.dev.cardano.org",
          "port": 30002
        }
      ],
      "advertise": false,
      "trustable": true
    }
  ],
  "useLedgerAfterSlot": 0
}
EOF

sudo systemctl restart cardano-node-preview

7. Script de inicio del block producer

cnode01 — Block Producer

```bash
cat > $HOME/cardano-my-node/preview/start-node.sh << 'EOF'
#!/usr/bin/env bash

export PATH="/usr/local/bin:$PATH"

NODE_DIR="${HOME}/cardano-my-node/preview"
export CARDANO_NODE_SOCKET_PATH="${NODE_DIR}/socket/node.socket"

/usr/local/bin/cardano-node run \
  --topology      "${NODE_DIR}/config/topology.json" \
  --database-path "${NODE_DIR}/db" \
  --socket-path   "${CARDANO_NODE_SOCKET_PATH}" \
  --config        "${NODE_DIR}/config/config.json" \
  --shelley-kes-key        "${NODE_DIR}/keys/kes.skey" \
  --shelley-vrf-key        "${NODE_DIR}/keys/vrf.skey" \
  --shelley-operational-certificate "${NODE_DIR}/keys/opcert.cert" \
  --port          3000
EOF
chmod +x $HOME/cardano-my-node/preview/start-node.sh

# Mainnet (para migración futura)
cat > $HOME/cardano-my-node/mainnet/start-node.sh << 'EOF'
#!/usr/bin/env bash

export PATH="/usr/local/bin:$PATH"

NODE_DIR="${HOME}/cardano-my-node/mainnet"
export CARDANO_NODE_SOCKET_PATH="${NODE_DIR}/socket/node.socket"

/usr/local/bin/cardano-node run \
  --topology      "${NODE_DIR}/config/topology.json" \
  --database-path "${NODE_DIR}/db" \
  --socket-path   "${CARDANO_NODE_SOCKET_PATH}" \
  --config        "${NODE_DIR}/config/config.json" \
  --shelley-kes-key        "${NODE_DIR}/keys/kes.skey" \
  --shelley-vrf-key        "${NODE_DIR}/keys/vrf.skey" \
  --shelley-operational-certificate "${NODE_DIR}/keys/opcert.cert" \
  --port          3000
EOF
chmod +x $HOME/cardano-my-node/mainnet/start-node.sh

Info: A diferencia del relay, el script del block producer incluye las rutas de las claves KES, VRF y el certificado operacional. Sin estas, el nodo arranca como relay, no como core.

8. Servicio systemd del block producer

cnode01 — Block Producer

sudo tee /etc/systemd/system/cardano-node-preview-bp.service > /dev/null << 'EOF'
# The Cardano Block Producer service (part of systemd)
# file: /etc/systemd/system/cardano-node-preview-bp.service

[Unit]
Description       = Cardano Block Producer Service - Preview
Wants             = network-online.target
After             = network-online.target

[Service]
User              = cardano
Type              = simple
WorkingDirectory  = /home/cardano/cardano-my-node/preview
ExecStart         = /bin/bash -c '/home/cardano/cardano-my-node/preview/start-node.sh'
KillSignal        = SIGINT
RestartKillSignal = SIGINT
TimeoutStopSec    = 300
LimitNOFILE       = 32768
Restart           = always
RestartSec        = 5
SyslogIdentifier  = cardano-node-preview-bp

[Install]
WantedBy          = multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable cardano-node-preview-bp
sudo systemctl start cardano-node-preview-bp
sudo systemctl status cardano-node-preview-bp

Info: El block producer corre exclusivamente en Preview durante la fase inicial. El servicio de Mainnet se configurará al momento de la migración, siguiendo el mismo procedimiento.

Deshabilitar el servicio relay en cnode01

Si cnode01 estaba corriendo previamente como relay (servicio cardano-node-preview), detén y deshabilita ese servicio — ambos no deben correr al mismo tiempo.

cnode01 — Block Producer

sudo systemctl stop cardano-node-preview
sudo systemctl disable cardano-node-preview
sudo systemctl status cardano-node-preview

Verifica que quedó inactivo:

● cardano-node-preview.service
   Loaded: loaded (/etc/systemd/system/cardano-node-preview.service; disabled)
   Active: inactive (dead)

Comandos útiles del block producer

cnode01 — Block Producer

# Ver estado
sudo systemctl status cardano-node-preview-bp

# Ver logs en tiempo real
journalctl -fu cardano-node-preview-bp

# Detener / reiniciar
sudo systemctl stop cardano-node-preview-bp
sudo systemctl restart cardano-node-preview-bp

9. Monitoreo del block producer con gLiveView

La configuración de gLiveView para el block producer difiere del relay en dos aspectos: el puerto (3000) y las rutas de las claves criptográficas (KES, VRF, CERT). Con estas variables configuradas, gLiveView detecta automáticamente que el nodo es un core y muestra información adicional como el período KES actual, los períodos restantes antes de expirar y el estado del opcert.

Info: gLiveView carga siempre el archivo env del mismo directorio donde está el script. Se instala una copia independiente por red.

Info: Si completaste el Artículo 1 en cnode01, gLiveView ya está instalado en $HOME/scripts/{mainnet,preview}/. Esta sección solo cubre la configuración adicional específica del block producer: las rutas de las claves KES, VRF y CERT que permiten a gLiveView detectar que el nodo es un core.

Configurar el archivo env por red

cnode01 — Block Producer

# Preview
sed -i \
  -e 's|^#\?CNODE_HOME=.*|CNODE_HOME="${HOME}/cardano-my-node/preview"|' \
  -e 's|^#\?CNODE_PORT=.*|CNODE_PORT=3000|' \
  -e 's|^#\?CONFIG=.*|CONFIG="${HOME}/cardano-my-node/preview/config/config.json"|' \
  -e 's|^#\?SOCKET=.*|SOCKET="${HOME}/cardano-my-node/preview/socket/node.socket"|' \
  -e 's|^#\?TOPOLOGY=.*|TOPOLOGY="${HOME}/cardano-my-node/preview/config/topology.json"|' \
  -e 's|^#\?LOG_DIR=.*|LOG_DIR="${HOME}/cardano-my-node/preview/logs"|' \
  -e 's|^#\?DB_DIR=.*|DB_DIR="${HOME}/cardano-my-node/preview/db"|' \
  $HOME/scripts/preview/env

# Deshabilitar check de actualizaciones (cnode01 no tiene acceso a Internet)
sed -i 's|^#\?UPDATE_CHECK=.*|UPDATE_CHECK="N"|' $HOME/scripts/preview/env

# Agregar rutas de claves al final del archivo env — Preview
cat >> $HOME/scripts/preview/env << 'EOF'
KES="${HOME}/cardano-my-node/preview/keys/kes.skey"
VRF="${HOME}/cardano-my-node/preview/keys/vrf.skey"
CERT="${HOME}/cardano-my-node/preview/keys/opcert.cert"
EOF

# Block Producer — Mainnet (para migración futura)
sed -i \
  -e 's|^#\?CNODE_HOME=.*|CNODE_HOME="${HOME}/cardano-my-node/mainnet"|' \
  -e 's|^#\?CNODE_PORT=.*|CNODE_PORT=3000|' \
  -e 's|^#\?CONFIG=.*|CONFIG="${HOME}/cardano-my-node/mainnet/config/config.json"|' \
  -e 's|^#\?SOCKET=.*|SOCKET="${HOME}/cardano-my-node/mainnet/socket/node.socket"|' \
  -e 's|^#\?TOPOLOGY=.*|TOPOLOGY="${HOME}/cardano-my-node/mainnet/config/topology.json"|' \
  -e 's|^#\?LOG_DIR=.*|LOG_DIR="${HOME}/cardano-my-node/mainnet/logs"|' \
  -e 's|^#\?DB_DIR=.*|DB_DIR="${HOME}/cardano-my-node/mainnet/db"|' \
  $HOME/scripts/mainnet/env

sed -i 's|^#\?UPDATE_CHECK=.*|UPDATE_CHECK="N"|' $HOME/scripts/mainnet/env

cat >> $HOME/scripts/mainnet/env << 'EOF'
KES="${HOME}/cardano-my-node/mainnet/keys/kes.skey"
VRF="${HOME}/cardano-my-node/mainnet/keys/vrf.skey"
CERT="${HOME}/cardano-my-node/mainnet/keys/opcert.cert"
EOF

Info: Las variables KES, VRF y CERT no existen en el archivo env original — se agregan al final con cat >>. Las demás variables se descomentan y actualizan con sed sin modificar el resto del archivo.

Info: UPDATE_CHECK="N" es necesario en el block producer porque cnode01 no tiene acceso a Internet por diseño (firewall). Sin esta configuración, gLiveView termina inmediatamente al intentar verificar actualizaciones en GitHub.

Ejecutar gLiveView

cnode01 — Block Producer

# Preview
cd $HOME/scripts/preview && ./gLiveView.sh

# Mainnet (para migración futura)
cd $HOME/scripts/mainnet && ./gLiveView.sh

Presiona q para salir.

Info: La estructura final en $HOME/scripts/ queda así:

$HOME/scripts/
├── mainnet/
│   ├── gLiveView.sh
│   └── env          ← CNODE_PORT=3000, con KES/VRF/CERT
└── preview/
    ├── gLiveView.sh
    └── env          ← CNODE_PORT=3000, con KES/VRF/CERT

10. Variables y alias del block producer

El artículo 1 definió aliases apuntando al servicio del relay (cardano-node-preview). En el block producer el servicio se llama cardano-node-preview-bp — hay que actualizarlos.

cnode01 — Block Producer

cat >> $HOME/.bashrc << 'EOF'

# Cardano Node - funciones por red
preview()  { export CARDANO_NODE_SOCKET_PATH="${HOME}/cardano-my-node/preview/socket/node.socket"; }
mainnet()  { export CARDANO_NODE_SOCKET_PATH="${HOME}/cardano-my-node/mainnet/socket/node.socket"; }

# Alias de consulta
alias tip-preview='preview && cardano-cli query tip --testnet-magic 2'
alias tip-mainnet='mainnet && cardano-cli query tip --mainnet'

# Alias de logs — Block Producer
alias log-preview='journalctl -fu cardano-node-preview-bp'
alias log-mainnet='journalctl -fu cardano-node-mainnet-bp'

# Alias de control — Block Producer
alias start-preview='sudo systemctl start cardano-node-preview-bp'
alias stop-preview='sudo systemctl stop cardano-node-preview-bp'
alias restart-preview='sudo systemctl restart cardano-node-preview-bp'
alias status-preview='sudo systemctl status cardano-node-preview-bp'

# Mainnet (para migración futura)
alias start-mainnet='sudo systemctl start cardano-node-mainnet-bp'
alias stop-mainnet='sudo systemctl stop cardano-node-mainnet-bp'
alias restart-mainnet='sudo systemctl restart cardano-node-mainnet-bp'
alias status-mainnet='sudo systemctl status cardano-node-mainnet-bp'

# Scripts (mithril-client y otros binarios locales)
export PATH="$HOME/scripts:$PATH"
EOF

source $HOME/.bashrc

Info: Si ejecutaste el Artículo 1 en cnode01, puede que ya existan algunas entradas en .bashrc. Revisa duplicados con grep alias $HOME/.bashrc antes de aplicar.

Resumen

Al completar todos los pasos deberías tener:

cnode01 corriendo como block producer con KES, VRF y opcert cargados correctamente
El BP conectado exclusivamente al relay home lab cnode02
gLiveView mostrando el período KES activo y los períodos restantes antes de expirar
Las reglas de firewall bloqueando todo tráfico saliente de cnode01 hacia Internet

El siguiente artículo cubre el registro del stake pool en la blockchain: Artículo 3 — Registrar el Stake Pool.

11. Recursos adicionales

Recurso	URL
Repositorio cardano-node	https://github.com/IntersectMBO/cardano-node
Release 10.6.2	https://github.com/IntersectMBO/cardano-node/releases/tag/10.6.2
Archivos de configuración (Cardano Book)	https://book.world.dev.cardano.org
Documentación técnica	https://docs.cardano.org

₳ ¡Bienvenido a la red Cardano! ₳