En el ecosistema de Rust, Actix Web destaca por su alto rendimiento y arquitectura basada en actores. Sin embargo, ante picos de tráfico inesperados o fallos en dependencias externas, la velocidad no es suficiente; se requiere una estrategia de degradación de servicios (service degradation). Implementar estas tácticas permite que una aplicación siga operando de forma limitada en lugar de colapsar por completo.

Fundamentos de la degradación de servicios

La degradación consiste en sacrificar funcionalidades no críticas para proteger el núcleo del sistema. En entornos de alta concurrencia, esto previene el efecto dominó o "cascada de fallos", donde el agotamiento de recursos en un microsevricio tumba toda la infraestructura.

Implementación de Fallbacks con el extractor Either

Actix Web facilita la gestión de tipos alternativos mediante el extractor Either. Esta herramienta es ideal para definir una fuente de datos primaria y una secundaria (fallback) en caso de que la primera no cumpla con los requisitos o falle.

use actix_web::{get, web, Responder, Result};
use actix_web::web::Either;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct PreferenciasUsuario {
    tema: String,
}

#[get("/configuracion")]
async fn obtener_config(
    payload: Either<web::Json<PreferenciasUsuario>, web::Query<PreferenciasUsuario>>
) -> impl Responder {
    match payload {
        Either::Left(json) => format!("Cargando desde JSON: {:?}", json.tema),
        Either::Right(query) => format!("Degradado a Query String: {:?}", query.tema),
    }
}

En este ejemplo, el sistema intenta procesar un cuerpo JSON. Si el payload es incorrecto o el servicio de parsing falla, el sistema puede degradar la comunicación a parámetros de consulta (Query Strings), asegurando que la petición se procese.

Resiliencia en la entrega de activos estáticos

Al servir contenido estático, es común que falten archivos de índice. Actix Web permite configurar un comportamiento de rertoceso para evitar errores 404 innecesarios, permitiendo listar directorios o redirigir a archivos base si el recurso principal no está disponible.

use actix_files as fs;
use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(
                fs::Files::new("/recursos", "./public")
                    .index_file("home.html")
                    .show_files_listing() // Fallback si home.html no existe
            )
    })
    .bind("127.0.0.1:8000")?
    .run()
    .await
}

Gestión inteligente de carga mediante Middleware

Un enfoque avanzado de degradación implica el uso de middleware para monitorizar la salud del sistema. Si la latencia aumenta o los recursos son escasos, el middleware puede interceptar las peticiones y retornar respuestas preconfiguradas (respuestas "estáticas" o de error controlado) antes de que lleguen a la lógica de negocio pesada.

use std::future::{ready, Ready};
use actix_web::{
    dev::{self, Service, ServiceRequest, ServiceResponse, Transform},
    Error, HttpResponse,
};
use futures_util::future::LocalBoxFuture;

pub struct ControlDeCarga;

impl<S, B> Transform<S, ServiceRequest> for ControlDeCarga
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = MiddlewareDeCarga<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(MiddlewareDeCarga { service }))
    }
}

pub struct MiddlewareDeCarga<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for MiddlewareDeCarga<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&self, cx: &mut std::task::Context<'_>) -> std::task::Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&self, req: ServiceRequest) -> Self::Future {
        // Simulación de una condición de alta carga (ej. saturación de CPU)
        let sistema_saturado = false; 

        if sistema_saturado {
            let (request, _pl) = req.into_parts();
            let response = HttpResponse::ServiceUnavailable()
                .body("Servicio en modo de mantenimiento preventivo")
                .into_body();
            
            return Box::pin(async move { 
                Ok(ServiceResponse::new(request, response)) 
            });
        }

        let fut = self.service.call(req);
        Box::pin(async move {
            let res = fut.await?;
            Ok(res)
        })
    }
}

Buenas prácticas para la estabilidad del sistema

1. Identificación de rutas críticas: No todas las rutas deben degradarse igual. Las APIs de pago o autenticación requieren mayor protección que las de métricas o recomendaciones.
2. Timeouts agresivos: Configurar tiempos de espera cortos para servicios externos evita que los hilos de ejecución de Actix se bloqueen esperando una respuesta que no llegará.
3. Monitoreo de umbrales: Utilizar métricas de sistema (uso de RAM, descriptores de archivos) para activar de forma automática el modo de degradación.
4. Respuestas amigables: En lugar de un error 500 genérico, retornar datos cacheados o una explicación clara al cliente mejora la experiencia de usuario durante la crisis.