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