Programación de redes en Rust: escribiendo un servidor TCP rápido y seguro

¿Por qué Rust es el nuevo rey de la programación de redes?

¿Alguna vez ha escrito un servidor de red en C o C++ y ha tenido un segmentation fault debido a un mutex olvidado? ¿O ha lidiado con condiciones de carrera en Go, tratando de entender por qué una gorutina se «colgó»? Rust resuelve estos problemas de una vez por todas. Su sistema de propiedad (ownership) y su modelo de concurrencia «sin miedo» (fearless concurrency) hacen que la programación de redes en Rust no solo sea segura, sino también increíblemente eficiente.

En este artículo, analizaremos cómo crear servidores TCP y UDP en Rust, utilizando tanto la biblioteca estándar (std::net) como el stack async moderno basado en Tokio. Verá que Rust no es solo un lenguaje para programación de sistemas, sino también una excelente herramienta para escribir servicios de red de alta carga.

Fundamentos: std::net — Servidor TCP echo en 5 minutos

Empecemos con lo clásico: un servidor echo. Acepta una conexión TCP, lee datos y los envía de vuelta al cliente. En Rust, esto se hace de manera sorprendentemente concisa.

use std::io::{Read, Write};\nuse std::net::{TcpListener, TcpStream};\nuse std::thread;\n\nfn handle_client(mut stream: TcpStream) {\n    let mut buffer = [0; 1024];\n    loop {\n        match stream.read(&mut buffer) {\n            Ok(0) => {\n                println!("Cliente desconectado");\n                break;\n            }\n            Ok(n) => {\n                if let Err(e) = stream.write_all(&buffer[..n]) {\n                    eprintln!("Error de escritura: {}", e);\n                    break;\n                }\n            }\n            Err(e) => {\n                eprintln!("Error de lectura: {}", e);\n                break;\n            }\n        }\n    }\n}\n\nfn main() -> std::io::Result<()> {\n    let listener = TcpListener::bind("127.0.0.1:7878")?;\n    println!("Servidor iniciado en el puerto 7878");\n\n    for stream in listener.incoming() {\n        match stream {\n            Ok(stream) => {\n                thread::spawn(|| handle_client(stream));\n            }\n            Err(e) => {\n                eprintln!("Error de conexión: {}", e);\n            }\n        }\n    }\n    Ok(())\n}\n

¿Qué sucede aquí? TcpListener::bind crea un socket de escucha. El método incoming() devuelve un iterador sobre las conexiones entrantes. Para cada nuevo cliente, iniciamos un hilo separado — thread::spawn. Dentro de handle_client, leemos datos en un búfer y los enviamos de vuelta a través de write_all.

Importante: Rust garantiza que TcpStream no se usará accidentalmente desde dos hilos simultáneamente — el compilador simplemente no lo permitirá. Esto es lo que se llama fearless concurrency.

Problemas de este enfoque

\n
• Escalabilidad: cada cliente es un hilo separado. Con 10 000 clientes, el sistema operativo simplemente colapsará.
\n
• Recursos: la pila de hilos por defecto es de 2 MB. 10 000 clientes = 20 GB de memoria.
\n

Aquí es donde la programación asíncrona viene al rescate.

Revolución Async: Tokio y async/await

Rust no tiene un entorno de ejecución asíncrono incorporado (como Go o Node.js). En su lugar, proporciona los traits Future y las palabras clave async/await, y la elección del runtime depende de usted. El más popular es Tokio. No es solo una biblioteca, es todo un ecosistema: TCP/UDP, E/S de archivos, temporizadores, canales e incluso su propio planificador.

Reescribamos nuestro servidor echo con Tokio.

Servidor echo con Tokio

Agregue a Cargo.toml:

[dependencies]\ntokio = { version = "1", features = ["full"] }

Ahora el código:

use tokio::io::{AsyncReadExt, AsyncWriteExt};\nuse tokio::net::TcpListener;\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n