48 - Microservicios en Rust - una introducción

¡Bienvenidos de nuevo a Rustaceo.es! Hoy exploraremos los microservicios en Rust, un enfoque arquitectónico moderno que permite construir aplicaciones escalables, modulares y eficientes. Rust, con su modelo de concurrencia seguro y su alto rendimiento, se convierte en una opción ideal para desarrollar microservicios robustos.

🚀 ¿Qué son los microservicios? #

Los microservicios son una arquitectura de software en la que una aplicación se divide en múltiples servicios pequeños e independientes, cada uno enfocado en una funcionalidad específica y comunicándose entre sí mediante APIs.

✔ Escalabilidad: Se pueden desplegar y escalar de forma independiente. ✔ Resiliencia: Un fallo en un servicio no afecta a toda la aplicación. ✔ Modularidad: Facilita el mantenimiento y la evolución del sistema.

🏗 ¿Por qué Rust para microservicios? #

Rust ofrece ventajas clave para el desarrollo de microservicios: ✔ Rendimiento y eficiencia en memoria. ✔ Seguridad en concurrencia sin condiciones de carrera. ✔ Ejecutables livianos sin necesidad de garbage collector. ✔ Compatibilidad con WebAssembly y cloud-native environments.

🌐 Construyendo un microservicio en Rust con actix-web #

📌 1️⃣ Configuración del proyecto #

Creamos un nuevo proyecto en Rust:

cargo new microservicio-Rust --bin
cd microservicio-Rust

Editamos Cargo.toml para añadir las dependencias necesarias:

[dependencies]
actix-web = "4"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.6", features = ["postgres", "runtime-tokio-native-tls"] }

🌍 Implementando un microservicio básico #

📌 2️⃣ Creación del servidor con actix-web #

use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn status() -> impl Responder {
    HttpResponse::Ok().json({ "status": "Microservicio en ejecución" })
}

#[Actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/status", web::get().to(status))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

✔ /status: Ruta para verificar el estado del microservicio. ✔ HttpServer::new(): Configura el servidor HTTP en el puerto 8080. ✔ actix_web::main: Ejecuta el servicio en un runtime asíncrono.

🛠 Comunicación entre microservicios #

Para que los microservicios interactúen, usaremos reqwest para realizar peticiones HTTP a otros servicios.

📌 3️⃣ Consumiendo un api desde otro microservicio #

use reqwest;

#[Tokio::main]
async fn main() {
    let respuesta = reqwest::get("http://127.0.0.1:8080/status")
        .await.unwrap()
        .text()
        .await.unwrap();
    
    println!("Respuesta del servicio: {}", respuesta);
}

✔ Comunicación entre microservicios usando HTTP. ✔ Uso de reqwest::get() para consumir APIs. ✔ Manejo de respuestas asíncronas con await.

📦 Implementando persistencia con sqlx #

Para almacenar y recuperar datos, conectamos nuestro microservicio a una base de datos PostgreSQL usando SQLx.

📌 4️⃣ Configuración de base de datos #

DATABASE_URL=postgres://rustaceo:password@localhost/microservicio_db

📌 5️⃣ Integración de sqlx #

use sqlx::PgPool;
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn obtener_datos(pool: web::Data<PgPool>) -> impl Responder {
    let datos = sqlx::query!("SELECT * FROM datos")
        .fetch_all(pool.get_ref())
        .await;
    
    match datos {
        Ok(datos) => HttpResponse::Ok().json(datos),
        Err(_) => HttpResponse::InternalServerError().finish(),
    }
}

✔ Conexión a PostgreSQL con SQLx. ✔ Consulta segura con query!() evitando inyecciones SQL. ✔ Uso de Data<PgPool> para compartir la conexión.

🛡 Seguridad y autenticación en microservicios #

Para asegurar nuestras APIs, podemos implementar autenticación con JWT usando el crate jsonwebtoken.

📌 6️⃣ Ejemplo de Validación con JWT

use jsonwebtoken::{decode, encode, Header, Validation, EncodingKey, DecodingKey};

#[Derive(serde::serialize, serde::deserialize)]
struct Claims {
    sub: String,
    exp: usize,
}

✔ Protección contra accesos no autorizados. ✔ Generación y validación de tokens JWT.

🏆 Conclusión #

Hemos construido un microservicio en Rust desde cero y explorado los conceptos clave:

🎯 Resumen de lo aprendido: ✔ Creación de un microservicio con Actix-Web. ✔ Comunicación entre microservicios con reqwest. ✔ Persistencia con SQLx y PostgreSQL. ✔ Seguridad con JWT para autenticación.

🔮 Próximo paso: Implementar monitoreo, logging y despliegue en Kubernetes.

¡Nos vemos en la próxima entrega, Rustaceos!