Configuración Avanzada de Nodos Validador

La configuración de un nodo validador en KodeChain va más allá de la instalación básica. Esta guía revela cómo el código en main.go y los módulos de configuración transforman un servidor común en un participante crítico de la red blockchain.

Arquitectura del Nodo

El Punto de Entrada: main.go

Cuando ejecutas ./kodechain-node-validator, el código en main.go inicia una secuencia compleja:

func main() {
    // Crear nueva instancia de aplicación
    application := app.NewApplication()

    // Inicializar aplicación (parse flags, crear config)
    if err := application.Initialize(); err != nil {
        fmt.Printf("❌ Error initializing application: %v\n", err)
        os.Exit(1)
    }

    // Ejecutar la aplicación
    if err := application.Run(); err != nil {
        fmt.Printf("❌ Error running application: %v\n", err)
        os.Exit(1)
    }
}

Esta función simple oculta una inicialización compleja que incluye:

• Parsing de argumentos de línea de comandos
• Carga de configuración desde archivos
• Inicialización de módulos (blockchain, P2P, consenso)
• Configuración de logging y monitoreo

Módulos Core del Nodo

1. Blockchain Engine

El módulo blockchain se inicializa con el estado génesis y configura:

blockchainInstance := blockchain.NewBlockchain(genesisFile, dataDir)
blockchainInstance.SetVMIntegration(vmIntegration)
blockchainInstance.SetP2PManager(p2pManager)

2. Sistema de Consenso

Dependiendo del tipo de consenso, se inicializa DPoS o PBFT:

if consensusType == "DPOS" {
    dpos := consensus.NewDPoS(stakingContract)
    dpos.SetBlockchainInstance(blockchainInstance)
    dpos.SetPassiveDelegationManager(passiveDelegationManager)
    consensusEngine = dpos
} else {
    pbft := consensus.NewPBFT(nodeID, validatorAddresses)
    consensusEngine = pbft
}

3. Red P2P con Hole Punching

La red peer-to-peer se configura con capacidades avanzadas de NAT traversal:

p2pManager := p2p.NewP2PManager(nodeID, privateKey)
p2pManager.SetHolePunchingManager(holePunchingManager)
p2pManager.SetUPnPManager(upnpManager)

4. API REST y WebSocket

El servidor HTTP expone endpoints para interacción:

apiServer := api.NewServer(blockchainInstance, consensusEngine, p2pManager)
apiServer.Start(port)

Configuración de Red

Puertos y Conectividad

Un nodo validador utiliza múltiples puertos para diferentes funciones:

Puerto	Protocolo	Función	Importancia
8080	HTTP	API REST	Crítico para operaciones
30303	TCP	P2P Connections	Esencial para consenso
30303	UDP	Discovery	Necesario para encontrar peers
9090	HTTP	Métricas Prometheus	Importante para monitoreo

Configuración de Firewall

Para máxima seguridad y funcionalidad:

# Ubuntu/Debian
sudo ufw allow 8080/tcp
sudo ufw allow 30303/tcp
sudo ufw allow 30303/udp
sudo ufw allow 9090/tcp

# Verificar configuración
sudo ufw status

UPnP y NAT Traversal

El sistema automáticamente configura port forwarding:

upnpManager := p2p.NewUPnPManager()
if err := upnpManager.DiscoverGateway(); err == nil {
    upnpManager.AddPortMapping(30303, "TCP", "KodeChain P2P")
    upnpManager.AddPortMapping(30303, "UDP", "KodeChain Discovery")
}

Configuración de Almacenamiento

Estructura de Directorios

~/.kodechain/
├── data/
│   ├── blockchain.db      # Base de datos LevelDB
│   ├── blocks/            # Archivos de bloques
│   └── state/             # Estado de contratos
├── keystore/              # Claves privadas encriptadas
├── logs/                  # Archivos de log
└── config.json            # Configuración del nodo

Optimización de LevelDB

{
  "leveldb": {
    "cache_size": 1024,
    "write_buffer_size": 64,
    "max_open_files": 1000,
    "compression": "snappy"
  }
}

Configuración de Consenso

Nodo DPoS

{
  "consensus": {
    "type": "dpos",
    "round_length": 21,
    "block_time": 3,
    "delegates": 21
  }
}

Nodo PBFT

{
  "consensus": {
    "type": "pbft",
    "view_change_timeout": 10000,
    "max_faulty_nodes": 1,
    "request_timeout": 5000
  }
}

Monitoreo y Logging

Sistema de Logging Estructurado

logger := utils.NewLogger()
logger.SetLevel("info")
logger.SetOutputFile("~/.kodechain/logs/node.log")

// Logging contextual
logger.WithFields(map[string]interface{}{
    "node_id": nodeID,
    "height": blockchain.Height(),
}).Info("Block created")

Métricas Prometheus

metrics := monitoring.NewMetricsCollector()
metrics.RegisterGauge("blockchain_height", blockchain.Height)
metrics.RegisterCounter("transactions_processed", txCount)
metrics.RegisterHistogram("block_time", blockTimeDistribution)

Seguridad del Nodo

Gestión de Claves

# Crear directorio seguro para keystore
mkdir -p ~/.kodechain/keystore
chmod 700 ~/.kodechain/keystore

# Verificar permisos
ls -la ~/.kodechain/keystore/

Configuración SSL/TLS (Opcional)

{
  "api": {
    "ssl": {
      "enabled": true,
      "cert_file": "/path/to/cert.pem",
      "key_file": "/path/to/key.pem"
    }
  }
}

Optimización de Performance

Configuración de Go

export GOGC=50          # GC más frecuente
export GOMAXPROCS=4     # Usar 4 cores
export GODEBUG=gctrace=1 # Tracing de GC

Límites del Sistema

# Aumentar límites para producción
echo "* soft nofile 65536" >> /etc/security/limits.conf
echo "* hard nofile 65536" >> /etc/security/limits.conf

# Aplicar cambios
sysctl -p

Backup y Recuperación

Estrategia de Backup

#!/bin/bash
# Script de backup diario

BACKUP_DIR="/var/backups/kodechain"
DATE=$(date +%Y%m%d)

# Crear backup
tar -czf $BACKUP_DIR/node_$DATE.tar.gz ~/.kodechain/

# Mantener solo últimos 7 días
find $BACKUP_DIR -name "node_*.tar.gz" -mtime +7 -delete

Recuperación de Nodo

# Detener nodo
docker stop kodechain-validator

# Restaurar desde backup
tar -xzf /var/backups/kodechain/node_20241101.tar.gz -C /

# Reiniciar nodo
docker start kodechain-validator

Monitoreo Continuo

Health Checks

#!/bin/bash
# Health check script

# Verificar API
if curl -f http://localhost:8080/api/health > /dev/null; then
    echo "✅ API healthy"
else
    echo "❌ API unhealthy"
    exit 1
fi

# Verificar sincronización
HEIGHT=$(curl -s http://localhost:8080/api/blockchain/height)
if [ "$HEIGHT" -gt 0 ]; then
    echo "✅ Blockchain synced (height: $HEIGHT)"
else
    echo "❌ Blockchain not synced"
    exit 1
fi

# Verificar peers
PEERS=$(curl -s http://localhost:8080/api/p2p/peers | jq length)
if [ "$PEERS" -gt 0 ]; then
    echo "✅ Connected to $PEERS peers"
else
    echo "❌ No peers connected"
    exit 1
fi

Alertas Automáticas

# Configurar alertas por email
MAILTO=admin@yourdomain.com

# En crontab
*/5 * * * * /path/to/health-check.sh

Escalabilidad y Clustering

Configuración Multi-Nodo

{
  "cluster": {
    "enabled": true,
    "nodes": [
      {"id": "validator-1", "host": "10.0.0.1", "port": 8080},
      {"id": "validator-2", "host": "10.0.0.2", "port": 8080}
    ],
    "load_balancer": "nginx"
  }
}

Balanceo de Carga

upstream kodechain_nodes {
    server validator-1:8080;
    server validator-2:8080;
}

server {
    listen 80;
    location / {
        proxy_pass http://kodechain_nodes;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Troubleshooting Avanzado

Diagnóstico de Problemas de Red

# Verificar conectividad P2P
netstat -tlnp | grep 30303

# Verificar tabla de enrutamiento
curl http://localhost:8080/api/p2p/routing-table

# Test de latencia con peers
curl http://localhost:8080/api/p2p/ping

Análisis de Performance

# Perfilado de CPU
go tool pprof http://localhost:8080/debug/pprof/profile

# Análisis de memoria
go tool pprof http://localhost:8080/debug/pprof/heap

# Métricas detalladas
curl http://localhost:9090/metrics

Esta configuración avanzada transforma un nodo básico en un participante robusto y confiable de la red KodeChain, capaz de manejar alta carga mientras mantiene seguridad y estabilidad.