Admin-Sistemas ·

HAProxy: cola prioritaria por backend con stick-tables y límites de concurrencia

El problema: cuando todo llega al mismo tiempo

En entornos de producción, no todo el tráfico tiene la misma importancia. Una API de pagos, un endpoint de autenticación o un servicio de colas interno pueden necesitar prioridad absoluta sobre peticiones de análisis, reportes o scraping. Si todos los request compiten por los mismos recursos del backend, los críticos pueden sufrir latencia o timeouts en momentos de pico. La solución clásica es escalar, pero eso no siempre es posible ni económico. La alternativa técnica y elegante es usar HAProxy no solo como balanceador, sino como colas priorizadas a nivel de backend, combinando su poderoso sistema de stick-tables con límites de concurrencia y ACLs.

HAProxy permite limitar el número de conexiones simultáneas por backend (maxconn), pero eso solo rechaza el exceso. Lo que necesitamos es que, cuando el backend esté saturado, el tráfico de baja prioridad espere o sea rechazado, mientras que el tráfico crítico pase inmediatamente. Esto se logra con una arquitectura de dos capas: un frontend que clasifica el tráfico, y un backend con maxconn ajustado. Pero la clave está en usar stick-tables para contar conexiones activas por cliente o por tipo de petición, y así decidir dinámicamente.

Fundamentos: stick-tables y concurrencia

Una stick-table en HAProxy es una tabla en memoria que guarda contadores y métricas por clave (IP, cookie, header, etc.). Se usa típicamente para persistencia de sesión, pero también para rate limiting y control de concurrencia. La directiva clave es stick-table type ip size 50k expire 30s store gpc0,conn_cur. Aquí conn_cur almacena el número de conexiones actuales para esa IP. Combinado con http-request track-sc0 src podemos leer y actualizar esos contadores en cada petición.

El límite de concurrencia por backend se define con maxconn. Por ejemplo, backend api_critica con maxconn 50 y backend api_normal con maxconn 20. Pero esto no es suficiente para una cola prioritaria. Necesitamos que un mismo backend físico (digamos, el servidor de aplicaciones) reciba el tráfico, pero con lógica de prioridad. La idea es definir dos backends que apunten al mismo servidor, pero con maxconn diferente, y usar ACLs para enrutar el tráfico crítico al backend con mayor límite, y el resto al de menor límite.

Implementación práctica

Supongamos un escenario: un servidor web que puede manejar 100 conexiones concurrentes como máximo. Queremos que el tráfico a /api/pagos tenga prioridad (hasta 80 conexiones) y el resto (reportes, exportaciones) solo tenga 20. Pero si el tráfico de pagos no usa sus 80, el resto podría usar más. Con HAProxy no hay una cola dinámica real, pero podemos simularla con stick-tables por IP y maxconn por backend.

global
    maxconn 4096

defaults
    mode http
    timeout connect 5s
    timeout client 30s
    timeout server 30s

frontend http_in
    bind *:80
    # Tabla para contar conexiones por IP
    stick-table type ip size 50k expire 30s store conn_cur,gpc0
    http-request track-sc0 src

    # ACL para tráfico prioritario
    acl es_pagos path_beg /api/pagos
    acl es_auth path_beg /api/auth

    # Regla: si ya hay muchas conexiones de esta IP y no es prioritario, rechazar
    http-request deny if !es_pagos !es_auth { sc0_conn_cur gt 10 }

    # Enrutamiento
    use_backend bk_pagos if es_pagos
    use_backend bk_auth if es_auth
    default_backend bk_normal

backend bk_pagos
    server app1 127.0.0.1:8080 maxconn 80

backend bk_auth
    server app1 127.0.0.1:8080 maxconn 40

backend bk_normal
    server app1 127.0.0.1:8080 maxconn 20

En este ejemplo, bk_pagos puede tener hasta 80 conexiones al mismo servidor. bk_normal solo 20. Pero hay un problema: HAProxy abre conexiones al servidor por cada backend, y los maxconn se calculan por backend, no globalmente. Si llegan 80 de pagos y 20 de normal, el servidor recibe 100. Eso está bien si el servidor aguanta 100. Pero si queremos un límite global, necesitamos usar maxconn a nivel de servidor con maxconn en la línea del server y no en el backend. Sin embargo, eso rompe la prioridad porque el servidor se llena con los primeros que llegan.

Solución con stick-tables como semáforo

La técnica más robusta es usar la stick-table para contar el total de conexiones activas hacia el servidor, y decidir en el frontend si aceptar o esperar. HAProxy no tiene una instrucción de "espera" nativa, pero podemos simularla con http-request tarpit o con http-request set-var y delay (en versiones recientes). Mejor aún, podemos redirigir a una página de espera o devolver un 503 con Retry-After para clientes que puedan reintentar.

Pero para una cola real, la opción es usar http-request track-sc0 y luego una ACL que compare sc0_conn_cur con un umbral. Si el tráfico no es prioritario y el contador supera el umbral, se rechaza (o se envía a un backend especial que hace de cola). Para el tráfico prioritario, se le da un umbral más alto.

frontend http_in
    bind *:80
    stick-table type ip size 50k expire 30s store conn_cur
    http-request track-sc0 src

    acl es_prioritario path_beg /api/pagos
    acl es_permitido_prioritario sc0_conn_cur lt 80
    acl es_permitido_normal sc0_conn_cur lt 20

    http-request set-var(txn.prioridad) int(0)
    http-request set-var(txn.prioridad) int(1) if es_prioritario

    # Si es prioritario y hay menos de 80 conexiones de esa IP, pasar
    http-request allow if es_prioritario es_permitido_prioritario
    # Si no es prioritario y hay menos de 20, pasar
    http-request allow if !es_prioritario es_permitido_normal
    # Resto: enviar a backend de espera (cola)
    use_backend bk_cola if !es_prioritario !es_permitido_normal
    use_backend bk_cola_prior if es_prioritario !es_permitido_prioritario
    default_backend bk_app

Claro, esto cuenta por IP, no global. Para un contador global, necesitamos una stick-table de tipo integer con una clave fija (por ejemplo, 0.0.0.0). Pero cuidado: las stick-tables solo pueden contarse por clave, y usar una clave global es hacky. Otra opción es usar backend con maxconn y aceptar que el exceso se rechace. La verdadera cola se hace con haproxy + queue que es una característica nativa de los backends HTTP.

La cola nativa de HAProxy

HAProxy tiene un sistema de cola integrado por backend. Cuando el backend alcanza maxconn, las peticiones adicionales se ponen en espera (cola) hasta que una conexión se libere. Esto es exactamente una cola FIFO. La prioridad se puede implementar asignando diferentes maxconn a diferentes backends que apuntan al mismo servidor. El tráfico prioritario tendrá un maxconn alto y por tanto menos probabilidad de hacer cola, mientras que el normal tendrá un maxconn bajo y hará cola rápidamente.

Ejemplo con cola real:

backend bk_prioritario
    server app1 127.0.0.1:8080 maxconn 90
    timeout queue 10s

backend bk_normal
    server app1 127.0.0.1:8080 maxconn 10
    timeout queue 30s

En este caso, si el tráfico normal usa sus 10 conexiones, el resto espera en cola hasta 30 segundos. El prioritario tiene 90, así que rara vez espera. El límite global es 100 (90+10). Pero si el prioritario usa solo 50, el normal podría usar más, pero no puede porque su maxconn está fijado en 10. Para hacerlo dinámico, necesitamos ajustar maxconn en caliente con la socket de