Saltar al contenido

Lección 18 de 24 · Lectura y práctica

Patrones de Diseño para Sistemas Robustos

Concepto claveLos patrones de diseño para sistemas robustos son soluciones arquitectónicas probadas que garantizan fiabilidad, tolerancia a fallos y mantenibilidad en entornos críticos. En Rust, estos patrones aprovechan el.

Del concepto a la práctica

Taller de esta lección

El patrón typestate puede impedir que una operación se ejecute antes de validar una orden. Cada estado es un tipo distinto y el método de transición consume el estado anterior. Así, una orden Pendiente no expone directamente una función reservada para Validada.

Ejemplo resuelto

rust
struct Pendiente { id: u64 }
struct Validada { id: u64 }
impl Pendiente {
    fn validar(self) -> Result<Validada, &'static str> {
        if self.id == 0 { Err("id inválido") } else { Ok(Validada { id: self.id }) }
    }
}
fn main() { println!("{}", Pendiente { id: 4 }.validar().is_ok()); }

La salida es true; la transición consume Pendiente.

Pruébalo

  1. Crea una orden con id cero.

  2. Observa el error.

  3. Crea id cuatro.

  4. Conserva solo el estado validado para procesar.

Comprueba tu resultado

Error frecuente: añadir un booleano validada y permitir que cualquier código lo cambie. Corrección: encapsula la transición y expón métodos según el tipo.

Ejercicio: id 0 debe producir Err("id inválido"); id 4 debe producir Ok(Validada { id: 4 }) conceptualmente y no permitir reutilizar el estado pendiente.

El ejemplo no demuestra aún que solo Validada se procese. Añade un método procesar(self) únicamente al tipo Validada, mantén sus campos privados al módulo y prueba que Pendiente no ofrece ese método. No uses clone de la orden validada para saltarte una semántica de consumo único si hay efectos: idempotencia del almacén sigue siendo un requisito distinto.

Diagrama de decisión con ramas Sí y No y un bucle que procesa cada elemento de una lista.
CursaloMapa de práctica
Cómo avanza un programa

Una condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.

Ver la infografía en tamaño completo ↗
Fuentes para profundizar

Concepto clave

Los patrones de diseño para sistemas robustos son soluciones arquitectónicas probadas que garantizan fiabilidad, tolerancia a fallos y mantenibilidad en entornos críticos. En Rust, estos patrones aprovechan el sistema de tipos, ownership y lifetimes para prevenir errores en tiempo de compilación, eliminando clases enteras de bugs comunes en otros lenguajes. Piensa en ellos como los planos de un edificio antisísmico: no solo definen la estructura, sino cómo responde bajo estrés.

La robustez en sistemas de baja latencia y alta seguridad requiere un equilibrio entre performance y seguridad. Rust facilita este equilibrio mediante patrones como RAII (Resource Acquisition Is Initialization) y typestate programming, donde el estado del sistema se codifica en tipos, imposibilitando transiciones inválidas. Esto es crucial en sistemas financieros o de control industrial, donde un estado inconsistente puede causar pérdidas millonarias o riesgos de seguridad.

Cómo funciona en la práctica

Implementemos el patrón Builder con validación en tiempo de compilación para configurar una conexión segura. Este patrón garantiza que solo se puedan crear objetos en estados válidos, eliminando checks en runtime.

// Definimos estados como tipos vacíos (zero-sized types)
#[derive(Debug, Clone, Copy)]
struct Unconfigured;
#[derive(Debug, Clone, Copy)]
struct AddressSet(String);
#[derive(Debug, Clone, Copy)]
struct Authenticated(String, String); // usuario, token

// El builder usa tipos genéricos para representar estados
struct ConnectionBuilder {
    state: S,
    timeout_ms: Option,
}

impl ConnectionBuilder {
    fn new() -> Self {
        Self {
            state: Unconfigured,
            timeout_ms: None,
        }
    }
    
    fn set_address(self, addr: String) -> ConnectionBuilder {
        // Transición de estado: Unconfigured → AddressSet
        ConnectionBuilder {
            state: AddressSet(addr),
            timeout_ms: self.timeout_ms,
        }
    }
}

impl ConnectionBuilder {
    fn authenticate(self, user: String, token: String) -> ConnectionBuilder {
        // Solo se puede autenticar después de configurar la dirección
        ConnectionBuilder {
            state: Authenticated(user, token),
            timeout_ms: self.timeout_ms,
        }
    }
}

impl ConnectionBuilder {
    fn build(self) -> SecureConnection {
        // Solo construye desde el estado autenticado
        SecureConnection {
            addr: self.state.1, // Extraemos datos del estado
            user: self.state.0,
            timeout_ms: self.timeout_ms.unwrap_or(5000),
        }
    }
}

struct SecureConnection {
    addr: String,
    user: String,
    timeout_ms: u32,
}

Este código asegura que no se pueda crear una conexión sin autenticación, y el compilador rechaza secuencias inválidas como builder.authenticate() sin set_address() previo.

Caso de estudio

En un sistema de trading de alta frecuencia, procesamos órdenes con latencias menores a 10 microsegundos. Usamos el patrón actor model con canales sin bloqueo para aislar fallos y garantizar consistencia.

Dato clave: En 2023, un error en un sistema de trading causó pérdidas de 400M USD por un deadlock no detectado. Rust previene esto con canales que garantizan ownership único.

Implementamos un procesador de órdenes:

use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread;

struct Order {
    id: u64,
    symbol: String,
    quantity: i32,
    price: f64,
}

struct OrderProcessor {
    tx: Sender,
}

impl OrderProcessor {
    fn new() -> (Self, thread::JoinHandle<()>) {
        let (tx, rx): (Sender, Receiver) = channel();
        
        let handle = thread::spawn(move || {
            for order in rx {
                // Procesamiento seguro: cada orden es owned por el thread
                if !Self::validate(ℴ) {
                    eprintln!("Orden {} rechazada", order.id);
                    continue;
                }
                Self::execute(order);
            }
        });
        
        (Self { tx }, handle)
    }
    
    fn send(&self, order: Order) -> Result<(), String> {
        self.tx.send(order).map_err(|e| e.to_string())
    }
    
    fn validate(order: &Order) -> bool {
        order.quantity > 0 && order.price > 0.0
    }
    
    fn execute(order: Order) {
        // Simulación: latencia < 5μs
        println!("Ejecutando orden {} a {:.2}", order.id, order.price);
    }
}

Este diseño aísla fallos: si el thread de procesamiento crashea, no corrompe el estado del sistema principal, y las órdenes pendientes se manejan gracefulmente.

Errores comunes

  • Abusar de unwrap() en código crítico: En sistemas robustos, siempre maneja Result y Option explícitamente. Usa match o ? para propagar errores controladamente.
  • Ignorar backpressure en canales: En sistemas de alta carga, los canales pueden llenarse y causar bloqueos. Implementa límites de buffer y estrategias como try_send() o canales bounded.
  • No usar #[no_panic] en funciones críticas: En código donde el panic es inaceptable (ej. control de reactores), marca funciones con #[no_panic] y usa catch_unwind para contener fallos.
  • Subestimar el overhead de cloning: Clonar Arc o datos grandes afecta latencia. Usa referencias con lifetimes bien definidos o tipos como Rc en single-threaded.
  • No validar entradas en boundaries del sistema: Aunque Rust previene muchos errores, valida datos externos (red, archivos) inmediatamente con librerías como serde con esquemas estrictos.

Checklist de dominio

  1. ¿Puedes implementar un builder que garantice estados válidos en tiempo de compilación?
  2. ¿Sabes diseñar un sistema actor-based que aísle fallos sin perder mensajes?
  3. ¿Manejas errores sin unwrap() en todas las funciones críticas?
  4. ¿Has medido el overhead de tus estructuras de concurrencia con benchmarks reales?
  5. ¿Validas todas las entradas externas con esquemas estrictos?
  6. ¿Usas #[no_panic] o catch_unwind en componentes donde el panic es inaceptable?
  7. ¿Documentas los invariantes de tus tipos usando el sistema de tipos de Rust?

Implementa un sistema de cache con expiración y concurrencia segura

En este ejercicio, crearás una cache en memoria para un sistema de baja latencia que maneje 100k+ operaciones/segundo. La cache debe ser thread-safe, soportar expiración de entradas, y garantizar consistencia sin bloqueos globales.

  1. Define la estructura: Crea un struct SafeCache que use DashMap o RwLock para almacenar pares clave-valor con timestamp de inserción.
  2. Implementa inserción: Método insert(key: String, value: String, ttl_ms: u64) que guarda el valor con el timestamp actual + TTL.
  3. Implementa lectura con expiración: Método get(key: &str) -> Option que devuelve el valor solo si no ha expirado, y limpia entradas expiradas lazy.
  4. Añade cleanup periódico: Usa un thread background que cada 60 segundos elimine todas las entradas expiradas, sincronizado sin deadlocks.
  5. Benchmark: Mide el throughput con criterion para 4 threads concurrentes realizando 80% reads / 20% writes.

Entrega el código completo con tests que verifiquen: (1) thread safety bajo carga, (2) expiración precisa, (3) latencia promedio < 50μs por operación.

Pistas
  • Usa std::time::Instant para timestamps, evita SystemTime por overhead.
  • Considera DashMap de la crate dashmap para concurrencia lock-free.
  • Para el cleanup, usa un Mutex> compartido para recolectar claves expiradas sin bloquear la cache completa.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Rust para Trading: Concurrencia, Seguridad y Baja Latencia

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.