Entradas Mensuales

Síguenos en:

Canal Oficial Telegram de elhacker.NET Grupo Facebook elhacker.NET Twitter elhacker.NET Canal Youtube elhacker.NET Comunidad Steam: Grupo elhacker.NET Mastodon

Entradas populares

PostHeaderIcon Balanceador de carga con nginx


El balanceo de carga de NGINX distribuye el tráfico entrante entre múltiples servidores backend para mejorar el rendimiento, la fiabilidad y la escalabilidad. Esta guía completa abarca desde el algoritmo básico round-robin hasta algoritmos avanzados como el hash consistente y el poder de dos opciones (Power of Two Choices).




Balanceo de carga en NGINX: Guía completa de algoritmos y configuración


A diferencia de muchos tutoriales que copian y pegan configuraciones a ciegas, examinaremos lo que ocurre realmente internamente analizando el código fuente de NGINX. Comprender su funcionamiento interno te ayudará a tomar decisiones informadas sobre qué método de balanceo de carga se adapta mejor a tu carga de trabajo.


¿Qué es el balanceo de carga en NGINX?

El balanceo de carga es el proceso de distribuir el tráfico de red entre múltiples servidores. Cuando configuras el balanceo de carga en NGINX, este actúa como un proxy inverso, aceptando las peticiones de los clientes y reenviándolas a los servidores backend según un algoritmo configurado.

Entre sus beneficios se incluyen:

  • Alta disponibilidad: si un servidor falla, el tráfico se redirige a los servidores operativos
  • Escalabilidad horizontal: añade más servidores para gestionar el aumento de carga
  • Mejor aprovechamiento de los recursos: reparte el trabajo de manera uniforme en toda la infraestructura
  • Menor latencia: dirige a los usuarios al servidor disponible más rápido
  • Despliegues sin tiempo de inactividad: retira servidores de la rotación durante las actualizaciones

NGINX gestiona el balanceo de carga mediante la directiva de bloque upstream. Aquí tienes un ejemplo mínimo:

upstream backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

server {
    listen 80;
    location / {
        proxy_pass http://backend;
    }
}

Esta configuración distribuye las peticiones entre tres servidores backend utilizando el algoritmo round-robin predeterminado.

Instalación de NGINX con soporte para balanceo de carga

En Rocky Linux, AlmaLinux u otras distribuciones compatibles con RHEL, instala NGINX desde EPEL:

dnf install -y epel-release
dnf install -y nginx

Verifica la instalación y comprueba los módulos disponibles:

nginx -V

El paquete estándar de NGINX incluye todos los módulos de balanceo de carga. No se requiere ninguna compilación adicional.

Algoritmos de balanceo de carga de NGINX

NGINX ofrece seis algoritmos para distribuir el tráfico. Cada uno tiene casos de uso específicos y ventajas o desventajas. Elegir el adecuado depende de las características de tu aplicación.

Round-Robin (predeterminado)

Cuando no se especifica ningún algoritmo, NGINX utiliza round-robin ponderado. Las peticiones rotan por los servidores en orden, y cada servidor recibe tráfico proporcional a su peso.

upstream backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX mantiene tres valores de peso para cada servidor: weight, effective_weight y current_weight. El algoritmo selecciona el servidor con el mayor current_weight y luego reduce ese peso según el peso total de todos los servidores. Esto garantiza una distribución perfecta a lo largo del tiempo.

Cuándo usar round-robin:

  • Aplicaciones sin estado (stateless) donde cualquier servidor puede atender cualquier petición
  • Entornos de servidores homogéneos con capacidad similar
  • Despliegues sencillos sin requisitos complejos de sesión

Round-Robin ponderado

Asigna diferentes pesos a los servidores según su capacidad. Un servidor con weight=5 recibe cinco veces más tráfico que un servidor con weight=1.

upstream backend {
    server 192.168.1.10:8080 weight=5;  # 50% del tráfico
    server 192.168.1.11:8080 weight=3;  # 30% del tráfico
    server 192.168.1.12:8080 weight=2;  # 20% del tráfico
}

Cálculo de pesos: basa los pesos en la capacidad real del servidor. Si el servidor A tiene 16 núcleos de CPU y el servidor B tiene 8 núcleos, asigna weight=2 y weight=1 respectivamente.

Cuándo usar round-robin ponderado:

  • Entornos de hardware mixtos con servidores de diferentes capacidades
  • Transferencia gradual de tráfico durante migraciones
  • Despliegues canary donde las nuevas versiones reciben tráfico limitado

Menor número de conexiones (Least Connections)

La directiva least_conn dirige cada petición al servidor con el menor número de conexiones activas. Este método funciona bien cuando los tiempos de procesamiento de las peticiones varían significativamente.

upstream backend {
    least_conn;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX rastrea las conexiones activas por servidor en el campo conns. La fórmula de selección tiene en cuenta los pesos: peer->conns * best->weight < best->conns * peer->weight. Cuando varios servidores tienen las mismas conexiones ponderadas, round-robin desempata.

Combinación con pesos:

upstream backend {
    least_conn;
    server 192.168.1.10:8080 weight=5;
    server 192.168.1.11:8080 weight=3;
    server 192.168.1.12:8080 weight=2;
}

La comparación ponderada garantiza que los servidores de mayor capacidad acepten proporcionalmente más conexiones.

Cuándo usar el menor número de conexiones:

  • Conexiones de larga duración como WebSockets
  • Peticiones con tiempos de procesamiento muy variables
  • Endpoints de API donde algunas llamadas tardan mucho más que otras

Hash de IP

La directiva ip_hash garantiza que las peticiones procedentes de la misma IP de cliente vayan siempre al mismo servidor, proporcionando persistencia de sesión sin necesidad de almacenamiento de sesiones a nivel de aplicación.

upstream backend {
    ip_hash;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX calcula un hash utilizando la fórmula hash = (hash * 113 + addr[i]) % 6271 con un valor de hash inicial de 89. Para IPv4, solo se utilizan los tres primeros octetos (la subred /24), por lo que los clientes de la misma subred se dirigen al mismo servidor. Para IPv6, se aplica el hash a los 16 bytes.

Limitación importante: si un servidor cae, los clientes dirigidos previamente a él se redistribuyen. Cuando el servidor vuelve a estar operativo, esos clientes regresan a él, lo que puede interrumpir las sesiones activas.

Cuándo usar hash de IP:

  • Aplicaciones con almacenamiento de sesiones en el lado del servidor
  • Sistemas heredados que no pueden compartir sesiones entre servidores
  • Escenarios donde se requieren sesiones persistentes (sticky sessions) pero las cookies no son viables

Hash genérico

La directiva hash calcula un hash a partir de una clave configurable. Esto ofrece mayor flexibilidad que el hash de IP.

upstream backend {
    hash $request_uri;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Puedes calcular el hash de cualquier combinación de variables de NGINX:

upstream backend {
    hash $scheme$host$request_uri;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX utiliza CRC32 para el cálculo del hash, con la expresión ((crc32([REHASH] KEY) >> 16) & 0x7fff) + PREV_HASH. Esto es compatible con Cache::Memcached, lo que resulta útil para escenarios de caché distribuida.

Cuándo usar hash genérico:

  • Enrutamiento basado en contenido (la misma URL siempre llega al mismo servidor de caché)
  • Enrutamiento basado en usuarios con identificadores de sesión personalizados
  • Caché distribuida donde importa la localidad de la caché

Hash consistente

Añade el parámetro consistent para habilitar el hash consistente, que minimiza la redistribución cuando se añaden o eliminan servidores de tu grupo upstream.

upstream backend {
    hash $request_uri consistent;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX crea 160 nodos virtuales por unidad de peso para cada servidor. Estos nodos se distribuyen alrededor de un anillo de hash. Cuando llega una petición, NGINX calcula el hash de la clave y encuentra el nodo virtual más cercano mediante búsqueda binaria.

Impacto de los cambios en los servidores: con el hash estándar, añadir o eliminar un servidor redistribuye la mayoría de las claves. Con el hash consistente, solo se ven afectadas las claves asignadas al servidor modificado, normalmente 1/n del total de claves, donde n es el número de servidores.

Cuándo usar hash consistente:

  • Caché distribuida donde la invalidación de la caché es costosa
  • Servicios con estado (stateful) donde la migración de sesiones tiene una alta sobrecarga
  • Cualquier escenario donde importe minimizar la redistribución durante el escalado

Aleatorio (Random)

La directiva random selecciona un servidor de forma aleatoria, ponderada según los pesos de los servidores.

upstream backend {
    random;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX utiliza ngx_random() % total_weight para seleccionar un servidor. Una búsqueda binaria determina qué rango de peso de servidor contiene el valor aleatorio.

Aleatorio con el poder de dos opciones (Power of Two Choices)

La configuración random two least_conn implementa el algoritmo del «poder de dos opciones» (Power of Two Choices), que proporciona una distribución de carga casi óptima con una sobrecarga mínima.

upstream backend {
    random two least_conn;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Cómo funciona internamente: NGINX selecciona aleatoriamente dos servidores candidatos y luego elige el que tiene menos conexiones activas (ponderadas por los pesos de los servidores). Esta sencilla estrategia reduce drásticamente el desequilibrio de carga en comparación con la selección puramente aleatoria.

Cuándo usar el poder de dos opciones:

  • Grandes grupos de servidores donde rastrear todas las conexiones resulta costoso
  • Entornos donde los servidores tienen capacidades variables
  • Como una alternativa más sencilla al menor número de conexiones con resultados similares

Más allá de los algoritmos integrados: NGINX Plus y Angie

Los algoritmos anteriores están disponibles en la versión de código abierto de NGINX. Existen dos extensiones notables:

  • NGINX Plus añade la directiva least_time, que enruta el tráfico basándose en la latencia de respuesta medida y las conexiones activas. Es la opción integrada más sofisticada, pero requiere una suscripción comercial.
  • Angie (una bifurcación o fork de NGINX) ha portado la directiva de persistencia de sesión sticky de NGINX Plus al código abierto, pero no ha añadido least_time.

Para un balanceo sensible a la carga sin NGINX Plus, el módulo de terceros fair (tratado más abajo) rastrea las peticiones activas en memoria compartida entre todos los procesos worker.

Parámetros del servidor

Cada servidor dentro de un bloque upstream acepta parámetros que controlan su comportamiento.

weight

Especifica la capacidad relativa de un servidor. El valor predeterminado es 1.

server 192.168.1.10:8080 weight=5;

max_conns

Limita el número máximo de conexiones simultáneas a un servidor. Cuando se alcanza el límite, las peticiones se ponen en cola o se redirigen a otros servidores.

server 192.168.1.10:8080 max_conns=100;

Esto evita sobrecargar un servidor durante picos de tráfico. Configúralo según la capacidad de tu servidor y los requisitos de la aplicación.

max_fails y fail_timeout

Estos parámetros controlan las comprobaciones pasivas de estado (health checks).

server 192.168.1.10:8080 max_fails=3 fail_timeout=30s;
  • max_fails – Número de intentos fallidos antes de marcar el servidor como no disponible (predeterminado: 1)
  • fail_timeout – Periodo de tiempo para contar los fallos y duración de la indisponibilidad (predeterminado: 10s)

Cuando un servidor falla max_fails veces dentro del intervalo fail_timeout, NGINX lo marca como no disponible durante el resto del periodo fail_timeout. Transcurrido ese tiempo, NGINX vuelve a intentarlo.

backup

Designa un servidor como respaldo (backup). NGINX solo utiliza los servidores de respaldo cuando todos los servidores principales no están disponibles.

upstream backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080 backup;
}

down

Marca permanentemente un servidor como no disponible. Úsalo para tareas de mantenimiento.

server 192.168.1.10:8080 down;

Optimización de conexiones persistentes (Keepalive)

De forma predeterminada, NGINX abre una nueva conexión con el backend para cada petición de cliente. En sitios con mucho tráfico, esto genera una sobrecarga considerable. El modo keepalive mantiene conexiones persistentes con los servidores backend.

upstream backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
    keepalive 32;
}

Configuración crítica para backends HTTP/1.1:

location /api/ {
    proxy_pass http://backend;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
}

Sin proxy_http_version 1.1 y sin limpiar la cabecera Connection, keepalive no funcionará. De forma predeterminada, NGINX usa HTTP/1.0 para las conexiones upstream, lo que cierra las conexiones después de cada respuesta.

Parámetros adicionales de keepalive:

upstream backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    keepalive 32;
    keepalive_requests 1000;
    keepalive_timeout 60s;
}
  • keepalive 32 – Número máximo de conexiones inactivas por proceso worker
  • keepalive_requests 1000 – Número máximo de peticiones por conexión antes de cerrarla
  • keepalive_timeout 60s – Tiempo de espera de inactividad para las conexiones keepalive


Comprobaciones de estado y conmutación por error (Failover)

NGINX ofrece múltiples mecanismos para gestionar los fallos de los servidores.

Comprobaciones de estado pasivas

Configúralas con max_fails y fail_timeout:

upstream backend {
    server 192.168.1.10:8080 max_fails=3 fail_timeout=30s;
    server 192.168.1.11:8080 max_fails=3 fail_timeout=30s;
    server 192.168.1.12:8080 max_fails=3 fail_timeout=30s;
}

Conmutación por error de peticiones

La directiva proxy_next_upstream controla cuándo NGINX reintenta una petición en otro servidor:

location /api/ {
    proxy_pass http://backend;
    proxy_next_upstream error timeout http_500 http_502 http_503 http_504;
    proxy_next_upstream_tries 3;
    proxy_next_upstream_timeout 10s;
}
  • proxy_next_upstream – Condiciones que activan la conmutación por error
  • proxy_next_upstream_tries – Número máximo de reintentos
  • proxy_next_upstream_timeout – Límite de tiempo total para los reintentos

Condiciones disponibles:

  • error – Error de conexión o ausencia de respuesta
  • timeout – Tiempo de espera agotado de conexión o de respuesta
  • invalid_header – Respuesta no válida del servidor
  • http_500, http_502, http_503, http_504 – Errores HTTP específicos
  • http_403, http_404, http_429 – Códigos de error HTTP adicionales
  • non_idempotent – Permite reintentar peticiones POST/PATCH/DELETE (deshabilitado de forma predeterminada)
  • off – Deshabilita por completo la conmutación por error

Tiempos de espera de conexión

Configura los tiempos de espera adecuados para tu aplicación:

location /api/ {
    proxy_pass http://backend;
    proxy_connect_timeout 10s;
    proxy_send_timeout 60s;
    proxy_read_timeout 60s;
}

Zonas de memoria compartida

En NGINX Plus o al utilizar determinados módulos de terceros, las zonas de memoria compartida permiten compartir el estado en tiempo de ejecución entre los procesos worker:

upstream backend {
    zone backend_zone 64k;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

La directiva zone asigna memoria compartida para:

  • Recuentos de conexiones precisos entre todos los procesos worker
  • Estado de las comprobaciones de estado
  • Cambios de configuración en tiempo de ejecución (NGINX Plus)

El tamaño (64k en este ejemplo) debe ajustarse a la cantidad de servidores que tengas. Cada entrada de servidor requiere aproximadamente 1 KB.

Módulos avanzados para balanceo de carga

El paquete estándar de NGINX cubre la mayoría de los casos de uso, pero los módulos de terceros amplían significativamente las capacidades de balanceo de carga. Estos módulos están disponibles como paquetes precompilados para distribuciones basadas en RHEL.

La directiva ip_hash tiene una limitación importante: los clientes detrás de NAT o proxies corporativos comparten la misma dirección IP, lo que provoca una distribución desigual. El módulo sticky resuelve esto utilizando cookies para la persistencia de sesión.

Instala el módulo:

dnf install -y https://extras.getpagespeed.com/release-latest.rpm
dnf install -y nginx-module-sticky

Habilítalo en /etc/nginx/nginx.conf:

load_module modules/ngx_http_sticky_module.so;

Configura las sesiones persistentes:

upstream backend {
    sticky name=route expires=1h domain=.example.com path=/ httponly secure;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Para mayor seguridad, utiliza cookies firmadas con HMAC:

upstream backend {
    sticky hmac=sha1 hmac_key=your_secret_key name=route;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
}

Cuándo usar cookies sticky:

  • Aplicaciones con sesiones en el lado del servidor detrás de balanceadores de carga
  • Entornos donde los clientes comparten direcciones IP (redes corporativas, operadores móviles)
  • Cuando necesitas afinidad de sesión criptográficamente segura


Balanceador de carga justo (Fair Load Balancer)

El módulo fair rastrea el número de peticiones activas en curso por backend en una zona de memoria compartida entre todos los procesos worker de NGINX. Esto le proporciona una visión global de la ocupación del servidor, a diferencia de least_conn, que solo ve las conexiones dentro de cada worker individual. Cuando llega una nueva petición, se dirige al backend con menos peticiones activas, enviando automáticamente más tráfico a los servidores más rápidos.

Instalación y habilitación:

dnf install -y nginx-module-upstream-fair
load_module modules/ngx_http_upstream_fair_module.so;

Configura el balanceo fair:

upstream backend {
    fair;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

El módulo también admite parámetros opcionales como weight_mode=peak (limita la concurrencia por backend a su valor de peso) y weight_mode=idle (prioriza los backends completamente inactivos).

Cuándo usar el balanceo fair:

  • Entornos backend heterogéneos con características de rendimiento variables
  • Aplicaciones donde los tiempos de respuesta del backend fluctúan significativamente
  • Despliegues con múltiples procesos worker de NGINX que necesitan un seguimiento preciso de la carga entre workers
  • Como alternativa de código abierto a la directiva least_time de NGINX Plus


Resolución dinámica de DNS

El NGINX estándar resuelve los nombres de host upstream únicamente al iniciarse o recargarse. Si la IP de un backend cambia —algo habitual en entornos en la nube, contenedores y autoescalado—, NGINX sigue enviando el tráfico a la dirección obsoleta hasta que recargues la configuración manualmente.

NGINX 1.28+ (recomendado): el parámetro nativo resolve en la directiva server resuelve este problema directamente. Vuelve a resolver los nombres de dominio en segundo plano según el TTL de DNS, sin necesidad de ningún módulo de terceros:

upstream backend {
    zone backend_zone 64k;
    resolver 8.8.8.8 valid=30s;
    server api.example.com:8080 resolve;
}


Versiones anteriores de NGINX (anteriores a 1.27.3): si no puedes actualizar a NGINX 1.28+, el módulo jdomain proporciona resolución DNS impulsada por peticiones como un módulo dinámico de terceros:

dnf install -y nginx-module-upstream-jdomain
load_module modules/ngx_http_upstream_jdomain_module.so;
resolver 8.8.8.8;

upstream backend {
    jdomain api.example.com port=8080 max_ips=10 interval=10;
}

Para entornos de autoescalado con recuperación ante fallos (failback):

upstream backend {
    server 127.0.0.2 backup;
    jdomain backend.internal.example.com port=8080 strict;
}


Cuándo usar DNS dinámico:

  • Kubernetes o plataformas de orquestación de contenedores
  • Grupos de autoescalado en entornos en la nube
  • Cualquier escenario donde las IP de los backends cambien sin recargar NGINX

Upstream dinámico mediante descubrimiento de servicios (Consul/etcd)

La re-resolución basada en DNS gestiona los cambios de direcciones IP, pero no puede añadir ni eliminar servidores completamente nuevos en tiempo de ejecución. En entornos de microservicios donde los backends se registran y dan de baja en un registro de servicios como Consul o etcd, se necesita una integración más profunda.

El módulo upsync consulta Consul o etcd a intervalos configurables y actualiza en memoria la lista de servidores upstream sin necesidad de recargar NGINX. Los servidores se añaden, eliminan o reconfiguran (weight, max_fails, fail_timeout) íntegramente en tiempo de ejecución. Un archivo de volcado local proporciona recuperación ante desastres si el registro de servicios deja de estar disponible.

Instalación y habilitación:

dnf install -y nginx-module-upsync
load_module modules/ngx_http_upsync_module.so;

Configuración con Consul:

upstream backend {
    upsync 127.0.0.1:8500/v1/kv/upstreams/backend upsync_timeout=6m upsync_interval=500ms upsync_type=consul strong_dependency=off;
    upsync_dump_path /etc/nginx/upsync/backend_dump.conf;
    upsync_lb least_conn;

    include /etc/nginx/upsync/backend_dump.conf;
}

El módulo es compatible con Consul (almacén KV, catálogo de servicios y API de estado) y etcd. Un módulo complementario para flujos (nginx-module-stream-upsync) proporciona la misma funcionalidad para el balanceo de carga TCP/UDP.

Cuándo usar upsync:

  • Microservicios con registro de servicios en Consul o etcd
  • Entornos que requieren cambios en los backends sin recargas (zero-reload)
  • Cuando la directiva nativa resolve de DNS es insuficiente porque los servidores no están en el archivo de configuración


Ejemplo de configuración en producción

Aquí tienes una configuración completa de balanceo de carga en NGINX lista para producción:

upstream backend_api {
    least_conn;
    zone backend_api 64k;

    server 192.168.1.10:8080 weight=5 max_fails=3 fail_timeout=30s max_conns=100;
    server 192.168.1.11:8080 weight=3 max_fails=3 fail_timeout=30s max_conns=100;
    server 192.168.1.12:8080 weight=2 max_fails=3 fail_timeout=30s max_conns=100;
    server 192.168.1.13:8080 backup;

    keepalive 32;
    keepalive_requests 1000;
    keepalive_timeout 60s;
}

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://backend_api;

        # HTTP/1.1 para keepalive
        proxy_http_version 1.1;
        proxy_set_header Connection "";

        # Cabeceras adecuadas
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Tiempos de espera
        proxy_connect_timeout 10s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;

        # Conmutación por error
        proxy_next_upstream error timeout http_500 http_502 http_503 http_504;
        proxy_next_upstream_tries 3;
        proxy_next_upstream_timeout 10s;

        # Almacenamiento en búfer
        proxy_buffering on;
        proxy_buffer_size 4k;
        proxy_buffers 8 16k;
        proxy_busy_buffers_size 32k;
    }
}


Prueba la configuración antes de aplicarla:

nginx -t

Recarga NGINX para aplicar los cambios:

systemctl reload nginx

Balanceo de carga TCP/UDP con el módulo Stream

NGINX también puede balancear tráfico TCP y UDP mediante el módulo stream:

stream {
    upstream mysql_backend {
        least_conn;
        server 192.168.1.10:3306 max_fails=3 fail_timeout=30s;
        server 192.168.1.11:3306 max_fails=3 fail_timeout=30s;
        server 192.168.1.12:3306 backup;
    }

    server {
        listen 3306;
        proxy_pass mysql_backend;
        proxy_connect_timeout 10s;
        proxy_timeout 300s;
    }
}

El bloque stream suele ubicarse en /etc/nginx/nginx.conf o en un archivo incluido desde allí.

Monitorización del rendimiento del balanceador de carga

Monitoriza tu balanceador de carga utilizando el módulo stub status de NGINX:

server {
    listen 127.0.0.1:8080;

    location /nginx_status {
        stub_status;
        allow 127.0.0.1;
        deny all;
    }
}

Accede a la página de estado:

curl http://127.0.0.1:8080/nginx_status

Esto muestra las conexiones activas, las peticiones por segundo y los estados de las conexiones.

Para obtener métricas detalladas de los upstream, considera NGINX Plus o soluciones de monitorización compatibles que analicen los registros de NGINX.

Solución de problemas comunes

Todos los servidores marcados como no disponibles

Si todos los servidores upstream fallan las comprobaciones de estado, NGINX devuelve un error 502 Bad Gateway. Comprueba:

  1. La accesibilidad de los servidores backend desde el host de NGINX
  2. Las reglas del cortafuegos (firewall) que permiten el tráfico en los puertos del backend
  3. El estado de salud de la aplicación backend

Distribución desigual de la carga

Con round-robin, verifica que todos los servidores estén recibiendo tráfico realmente:

  1. Comprueba los pesos de los servidores
  2. Asegúrate de que las conexiones keepalive no estén provocando persistencia (stickiness)
  3. Verifica que todos los servidores superen las comprobaciones de estado

Tiempos de espera de conexión agotados

Si los clientes experimentan tiempos de espera agotados:

  1. Comprueba proxy_connect_timeout para el establecimiento de la conexión
  2. Verifica que proxy_read_timeout sea suficiente para tus endpoints más lentos
  3. Monitoriza los tiempos de respuesta de los servidores backend

Problemas de persistencia de sesión

Si los usuarios pierden sus sesiones al cambiar de servidor:

  1. Usa hash de IP o hash consistente para la persistencia de sesión
  2. Implementa almacenamiento compartido de sesiones (Redis, Memcached)
  3. Considera el uso de tokens JWT para autenticación sin estado

Resumen

El balanceo de carga de NGINX ofrece una distribución de tráfico flexible y de alto rendimiento. Elige tu algoritmo en función de las necesidades de tu aplicación:

  • Round-robin para aplicaciones sin estado con servidores de capacidad similar
  • Menor número de conexiones (Least connections) para peticiones con tiempos de procesamiento variables
  • Hash de IP para persistencia de sesión sencilla
  • Hash consistente cuando importa minimizar la redistribución durante el escalado
  • Aleatorio con el poder de dos opciones para grandes grupos de servidores
  • Cookies sticky para una afinidad de sesión fiable detrás de NAT
  • Balanceo fair para una distribución consciente de la carga en backends heterogéneos
  • Upsync para el descubrimiento dinámico de servicios con Consul o etcd

Configura siempre comprobaciones de estado adecuadas, conexiones keepalive y comportamiento de conmutación por error para los despliegues en producción. Prueba tu configuración exhaustivamente antes de aplicar los cambios en sistemas en vivo.

Para más información, explora la documentación oficial de balanceo de carga de NGINX.