Lnx Distributed Setup

Hardware (3-node minimum)

• CPU: 8+ cores por nodo
• RAM: 32GB+ por nodo
• Storage: 500GB+ SSD por nodo
• Network: 10Gbps recomendado

Software

# Instalar LNX (cada nodo)
curl -sSL https://lnx.rs/install.sh | bash

# O con Docker
docker pull lnx/lnx:latest

# Verificar instalación
lnx --version

Network Requirements

• Puertos 9200 (API), 9300 (Cluster)
• Latencia baja entre nodos (<5ms)
• Firewall rules configurados

Instrucciones

1. Cluster Configuration

Node 1 (Leader candidate)

# /etc/lnx/node1.toml

[cluster]
node_id = "node1"
nodes = ["node1:9200", "node2:9200", "node3:9200"]
bind_address = "0.0.0.0:9200"

[raft]
# Election timeout (milliseconds)
election_timeout_ms = 300
heartbeat_interval_ms = 100
snapshot_interval = 1000
log_retention_count = 10000

[sharding]
strategy = "consistent_hash"
num_shards = 12  # Múltiplo del número de nodos
replication_factor = 3  # Cada shard en 3 nodos

[indices]
default_analyzer = "standard"
max_index_size_gb = 100

[performance]
search_threads = 8
indexing_threads = 4
cache_size_mb = 8192

Node 2

# /etc/lnx/node2.toml

[cluster]
node_id = "node2"
nodes = ["node1:9200", "node2:9200", "node3:9200"]
bind_address = "0.0.0.0:9200"

# Resto igual a node1
[raft]
election_timeout_ms = 300
heartbeat_interval_ms = 100
...

Node 3

# /etc/lnx/node3.toml

[cluster]
node_id = "node3"
nodes = ["node1:9200", "node2:9200", "node3:9200"]
bind_address = "0.0.0.0:9200"

[raft]
election_timeout_ms = 300
heartbeat_interval_ms = 100
...

2. Start Cluster

# Terminal 1 (node1)
lnx --config /etc/lnx/node1.toml

# Terminal 2 (node2)
lnx --config /etc/lnx/node2.toml

# Terminal 3 (node3)
lnx --config /etc/lnx/node3.toml

# Verificar cluster health
curl http://localhost:9200/_cluster/health

3. Rust Integration

// motores/text_search/lnx/lnx_engine.rs
use lnx_client::{Client, IndexSettings, SearchRequest};
use std::time::Duration;

pub struct LnxDistributedEngine {
    client: Client,
    cluster_nodes: Vec<String>,
}

impl LnxDistributedEngine {
    pub async fn new(nodes: Vec<String>) -> Result<Self, LnxError> {
        // Connect to cluster
        let client = Client::builder()
            .nodes(nodes.clone())
            .timeout(Duration::from_secs(5))
            .retry_on_failure(true)
            .max_retries(3)
            .build()?;
        
        Ok(LnxDistributedEngine {
            client,
            cluster_nodes: nodes,
        })
    }
    
    pub async fn create_distributed_index(
        &self,
        name: &str,
        settings: IndexSettings
    ) -> Result<(), LnxError> {
        // Create index with automatic sharding
        let settings = IndexSettings {
            shards: 12,
            replicas: 2,  // Each shard has 2 replicas
            analyzer: "standard".to_string(),
            ..settings
        };
        
        self.client.create_index(name, settings).await?;
        Ok(())
    }
    
    pub async fn distributed_search(
        &self,
        query: &str,
        indices: Vec<&str>
    ) -> Result<Vec<SearchResult>, LnxError> {
        let request = SearchRequest {
            query: query.to_string(),
            indices: indices.iter().map(|s| s.to_string()).collect(),
            size: 20,
            timeout: Duration::from_secs(5),
            distributed: true,  // Enable distributed search
        };
        
        // LNX handles:
        // - Query routing to appropriate shards
        // - Parallel search across nodes
        // - Result merging and ranking
        // - Automatic failover on node failure
        let results = self.client.search(request).await?;
        
        Ok(self.convert_results(results))
    }
    
    pub async fn check_cluster_health(&self) -> ClusterHealth {
        match self.client.cluster_health().await {
            Ok(health) => health,
            Err(e) => ClusterHealth::unhealthy(e.to_string())
        }
    }
    
    pub async fn get_shard_allocation(&self) -> ShardAllocation {
        // Visualize how shards are distributed
        self.client.get_shard_allocation().await.unwrap()
    }
}

// Failover handling
impl LnxDistributedEngine {
    pub async fn handle_node_failure(&self, failed_node: &str) -> Result<()> {
        // LNX automatically handles:
        // 1. Detect node failure via Raft heartbeats
        // 2. Elect new leader if needed
        // 3. Redistribute shards from failed node
        // 4. Update routing table
        
        // Wait for cluster to stabilize
        tokio::time::sleep(Duration::from_secs(5)).await;
        
        let health = self.check_cluster_health().await;
        
        if health.status == "green" {
            println!("✅ Cluster recovered from node failure");
            Ok(())
        } else {
            Err(LnxError::ClusterUnhealthy)
        }
    }
}

4. Docker Compose Deployment