Balanceo de carga HTTP

Introducción

En este laboratorio, aprenderá los fundamentos del balanceo de carga mediante HAProxy.

Imagine un banco con un solo cajero. La fila se hace muy larga y los clientes se enfadan. Para resolverlo, el banco abre varias ventanillas. Sin embargo, ahora necesita un encargado en la puerta que dirija a cada cliente hacia la siguiente ventanilla disponible.

En este escenario:

El encargado del banco es el balanceador de carga (HAProxy).
Los cajeros son los servidores backend (servidores web simulados).
Los clientes son el tráfico web.

Construirá esta configuración en Linux. Creará dos servidores web simulados y configurará HAProxy para repartir el tráfico entre ellos mediante round robin, uno de los algoritmos de balanceo más sencillos.

Round robin es un buen modelo mental inicial porque muestra el propósito básico de un balanceador de carga: distribuir las solicitudes sucesivas entre varios backends disponibles, en lugar de enviarlas todas a una sola máquina.

Al finalizar este laboratorio, podrá:

Ejecutar servidores web sencillos en Python.
Configurar HAProxy para aceptar tráfico (Frontend) y enviarlo a los servidores (Backend).
Observar el balanceo de carga en funcionamiento.

Preparar los terminales

Para probar un balanceador de carga, primero necesitamos algo que balancear. Debemos ejecutar dos servidores web independientes al mismo tiempo. Como un servidor en ejecución ocupa el terminal y permanece activo hasta que usted lo detenga, no podemos escribir comandos nuevos en la misma ventana.

Por eso, debemos abrir pestañas adicionales del terminal. Es como abrir varias pestañas en el navegador para consultar distintos sitios web al mismo tiempo.

Desde el punto de vista operativo, este paso separa las funciones del sistema. Los servidores Python simulan la capa de aplicación, mientras que el terminal principal sigue siendo el plano de control del propio balanceador de carga.

Actualmente tiene un terminal abierto (Terminal). Abra otros dos:

Busque el icono + (más) en la interfaz del terminal.
Haga clic en él dos veces para abrir Terminal 1 y Terminal 2.

Los usaremos de la siguiente manera:

Terminal: nuestro centro de control (para configurar HAProxy).
Terminal 1: ejecutará el Servidor 1.
Terminal 2: ejecutará el Servidor 2.

Iniciar el Servidor 1

Ahora iniciaremos nuestro primer «cajero» (Servidor 1). En lugar de instalar un software de servidor web pesado, usaremos una herramienta integrada en Python que convierte cualquier carpeta en un sitio web.

Cambie a Terminal 1.

Primero, vaya a la carpeta que preparamos para el Servidor 1.

cd ~/project/server1

Ahora, inicie el servidor. Le indicaremos que escuche en el puerto 8001. Piense en un puerto como si fuera el número de un apartamento. El equipo es el edificio y el puerto 8001 es la puerta específica donde vive el Servidor 1.

python3 -m http.server 8001

Verá un mensaje que indica Serving HTTP on 0.0.0.0 port 8001. Esto significa que el servidor está en ejecución y esperando visitantes. Este terminal está ahora «ocupado», así que no escriba nada más aquí.

Iniciar el Servidor 2

Iniciemos el segundo «cajero» (Servidor 2) para tener otro servidor que comparta el trabajo.

Cambie a Terminal 2.

Vaya a la carpeta del Servidor 2.

cd ~/project/server2

Inicie este servidor en un puerto diferente, el 8002. No podemos usar el 8001 porque el Servidor 1 ya lo está utilizando (dos familias no pueden vivir en el mismo apartamento 8001).

python3 -m http.server 8002

Ahora tiene dos servidores web independientes en ejecución. Uno muestra «Response from Server 1» (en el puerto 8001) y el otro muestra «Response from Server 2» (en el puerto 8002).

Configurar el frontend

Ahora que los servidores están listos, configuremos el «encargado del banco» (HAProxy) para dirigir el tráfico hacia ellos.

Aquí comienza la separación entre frontend y backend. Un frontend describe cómo llegan los clientes a HAProxy, mientras que un backend describe el grupo de servidores que realmente atenderá las solicitudes.

Vuelva a Terminal.

Empezaremos desde cero haciendo una copia de seguridad de la configuración anterior y creando una nueva.

sudo mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.bak
sudo nano /etc/haproxy/haproxy.cfg

Copie y pegue el texto siguiente en el editor. Esto define el Frontend. El frontend es la cara pública del balanceador de carga: es el lugar al que llegan los clientes (usuarios).

global
    log /dev/log    local0
    log /dev/log    local1 notice
    daemon

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    timeout connect 5000
    timeout client  50000
    timeout server  50000

frontend http_front
    bind *:80
    default_backend http_back

Aspectos clave:

bind *:80: indica a HAProxy que escuche en el puerto 80. El puerto 80 es la puerta estándar del tráfico web (HTTP). Cuando escribe el nombre de un sitio web sin indicar un puerto, el navegador utiliza el puerto 80.
default_backend http_back: indica a HAProxy: «Cuando lleguen clientes aquí, envíelos al grupo llamado http_back».

Los nombres son importantes porque la configuración de HAProxy es, en esencia, un mapa del tráfico. Los frontends reciben las conexiones y los backends representan los posibles destinos de esas conexiones.

Guarde el archivo (Ctrl+O, Enter). Puede dejarlo abierto si lo desea, aunque es preferible guardarlo y salir (Ctrl+X) para verificar el progreso paso a paso.

Configurar el backend

Ahora debemos definir ese grupo de trabajadores, el Backend.

Vuelva a abrir el archivo de configuración si lo cerró:

sudo nano /etc/haproxy/haproxy.cfg

Añada las líneas siguientes al final del archivo:

backend http_back
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

¿Qué acabamos de hacer?

backend http_back: creamos el grupo llamado http_back.
server server1 ...: registramos nuestro primer trabajador (Servidor 1) en la dirección 127.0.0.1:8001 (el puerto local 8001).
server server2 ...: registramos nuestro segundo trabajador (Servidor 2) en 127.0.0.1:8002.
check: esta opción es fundamental. Indica al encargado que compruebe periódicamente si el trabajador está disponible (saludable). Si un servidor falla, HAProxy dejará de enviarle clientes.

Guarde el archivo (Ctrl+O, Enter) y salga (Ctrl+X).

Verificar el balanceo

¿Cómo debe decidir el encargado quién recibe al siguiente cliente? La forma más habitual es Round Robin. En pocas palabras, consiste en «alternar los turnos».

Cliente 1 -> Servidor 1
Cliente 2 -> Servidor 2
Cliente 3 -> Servidor 1
...y así sucesivamente.

Hagamos explícita esta configuración. Abra el archivo de configuración por última vez:

sudo nano /etc/haproxy/haproxy.cfg

Busque la sección backend http_back que acaba de añadir e inserte la directiva balance para que quede así:

backend http_back
    balance roundrobin
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

Nota: la sangría (los espacios al principio de la línea) es importante para facilitar la lectura, aunque HAProxy es flexible al respecto. Procure mantener el archivo ordenado.

Guarde el archivo (Ctrl+O, Enter) y salga (Ctrl+X).

Recargar HAProxy y realizar una prueba

La configuración está lista, pero HAProxy todavía no la conoce. Debemos reiniciar el servicio para aplicar los cambios.

sudo service haproxy restart

Ahora llega el momento de la verdad. Usaremos un comando llamado curl. Piense en curl como un navegador web sin interfaz gráfica. Obtiene una página web y muestra su código de texto en la pantalla.

Nos conectaremos a localhost (nuestro equipo) mediante el puerto predeterminado 80, donde HAProxy está escuchando.

Ejecute este comando varias veces:

curl localhost

Debería ver «Response from Server 1». Ejecútelo de nuevo.

curl localhost

Ahora debería ver «Response from Server 2».

Si quiere observarlo rápidamente, puede ejecutar este bucle, que consulta el servidor 4 veces seguidas:

for i in {1..4}; do
  curl localhost
  echo
done

Debería ver que la salida se alterna perfectamente: 1, 2, 1, 2.

Esto demuestra que el balanceador de carga funciona. Está recibiendo las solicitudes en el puerto 80 y repartiendo equitativamente el trabajo entre los puertos 8001 y 8002.

Resumen

En este laboratorio, ha creado correctamente un clúster web con balanceo de carga.

Esto es lo que ha conseguido:

Backends simulados: utilizó Python para crear dos servidores web funcionales en puertos diferentes (8001 y 8002).
Frontend configurado: indicó a HAProxy que escuchara en el puerto web estándar (80).
Backend configurado: registró los dos servidores como el grupo de trabajadores.
Round Robin: configuró una política de «alternancia de turnos» para distribuir el tráfico.

Esta es exactamente la misma arquitectura que utilizan los sitios web de gran escala para atender a millones de usuarios, aunque aquí se aplica a una escala menor.