Cómo configurar el balanceador de carga Traefik con Docker en Ubuntu 20.04

Traefik es un moderno proxy inverso y servidor de equilibrio de carga que admite el equilibrio de carga de capa 4 (TCP) y capa 7 (HTTP). Su configuración se puede definir en formato JSON, YML o TOML. Consta de punto de entrada (frontend), servicio (backend), enrutador (reglas), middleware (características opcionales).

Este artículo demostrará cómo usar el balanceador de carga de Traefik en el modo de capa 7 (HTTP).

Requisitos

1. Docker y docker-compose instalados
2. Conexión a Internet para descargar imágenes acoplables.
3. Un registro de DNS asignado a su dominio para obtener el certificado Let's Encrypt (p. ej., traefik.sudominio.com)

Configuración

Ejecutaré dos servidores backend (contenedor nginx) y un contenedor Traefik en la misma zona de red de Docker. Estoy usando traefik.yourdomain.com para la explicación. Necesitas tener tu propio dominio.

Comencemos por crear un directorio en su ubicación de inicio.

$ mkdir traefik && cd traefik

Ahora cree una red docker usando el siguiente comando. Esto ayuda a llegar al contenedor desde su nombre.

$ docker network create web_zone

Configuración de Traefik.yaml

En primer lugar, cree un archivo llamado traefik.yaml:

$ vim traefik.yaml

y pega el siguiente contenido.

# Static configuration
entryPoints:
    unsecure:
        address: :80
    secure:
        address: :443

certificatesResolvers:
    myresolver:
        acme:
            email: [email protected]
            storage: acme.json
            httpChallenge:
                entryPoint: unsecure
            
providers:
      file:
      filename: tls.yaml
      watch: true

Explicación

• Los puntos de entrada son como puertos y servicios de listado frontal.
• certificatesResolvers es usar un certificado de letsencrypt bajo demanda.
• Los proveedores son el archivo para definir enrutadores/middlewares y servicios

Configuración del proveedor de archivos

Ahora, en el mismo directorio crea otro archivo que hemos definido en la sección del proveedor:

$ vim tls.yaml

y pegue la siguiente configuración de yaml.

http:
    routers:
        http_router:
            rule: "Host(`traefik.yourdomain.com`)"
            service: allbackend
        https_router:
            rule: "Host(`traefik.yourdomain.com`)"
            service: allbackend
            tls:
                certResolver: myresolver
                options: tlsoptions
    services:
        allbackend:
            loadBalancer:
                servers:
                    - url: "http://myserver1/"
                    - url: "http://myserver2/"
           
tls:
    options:
        tlsoptions:
            minVersion: VersionTLS12

Explicación

• La sección del enrutador es para definir la ruta. Tenemos dos rutas para http y https
• Los backends se definen en los servicios, también puede especificar algoritmos de equilibrio de carga.
• tls para definir la configuración y las opciones de TLS.

Como se define en el archivo, cree el siguiente archivo para almacenar el certificado Let's Encrypt.

$ touch acme.json

$ chmod 600 acme.json

Docker-compose para traefik

Voy a crear un contenedor usando docker compose y mapear el puerto 80, 443. Tú defines tu nombre de dominio. Cree un archivo docker-compse.yml:

$ vim docker-compose.yml

y pega la siguiente configuración:

version: '3'

services:

  traefik:
    image: traefik:latest
    command: --docker --docker.domain=yourdomain.com
    ports:
      - 80:80
      - 443:443
    networks:
      - web_zone
    volumes:
      - /run/docker.sock:/run/docker.sock
      - ./traefik.yaml:/traefik.yaml
      - ./tls.yaml:/tls.yaml
      - ./acme.json:/acme.json
    container_name: traefik
    restart: always
networks:
  web_zone:
      external: true

Servidor back-end

Ahora ejecutemos dos servidores back-end usando la imagen nginx. Haz un directorio primero,

$ mkdir ~/traefik/backend && cd ~/traefik/backend/

Cree dos archivos de índice como se muestra a continuación.

echo "<h1> Hello server 1</h1>" > index-server1.html

echo "<h1> Hello server 2</h1>" > index-server2.html

Archivo de redacción de Docker para ejecutar dos servidores backend nginx

El siguiente es el archivo de composición simple que crea dos contenedores nginx. Cree el archivo docker-compse.yml:

$ vim docker-compose.yml

y pega la siguiente configuración:

version: '3'
services:
  myserver1:
    image: nginx
    container_name: nginx1
    restart: always
    volumes:
      - ./index-server1.html:/usr/share/nginx/html/index.html
    networks:
      - web_zone
  myserver2:
    image: nginx
    container_name: nginx2
    restart: always
    volumes:
      - ./index-server2.html:/usr/share/nginx/html/index.html
    networks:
      - web_zone
networks:
  web_zone:
        external: true

Iniciar los contenedores Docker

Ahora ejecute el contenedor. Primero suba el contenedor de back-end de nginx usando el siguiente comando.

$:~/traefik/backend$ docker compose up -d

Deben estar funcionando dos contenedores. Confírmelo ejecutando el siguiente comando.

[email protected]:~/traefik/backend$ docker ps

Ahora, regrese al directorio y ejecute el siguiente comando para ejecutar el balanceador de carga traefik.

$:~/traefik$ docker compose up -d

Asegúrese de que el contenedor traefik esté funcionando.

$:~/traefik$ docker ps

Navegar por el sitio

Abra un navegador y escriba su nombre de dominio http://traefik.yourdomain.com. Obtendrá la respuesta a continuación.

Además, si actualiza la página, será redirigido al segundo backend. Este es el algoritmo de enrutamiento predeterminado en traefik.

También puede verificar que el certificado sea emitido por letsencrypt mientras el contenedor está activo. Simplemente navegue a https://traefik.yourdomain.com

Conclusión

Aprende a usar traefik como balanceador de carga para su contenedor docker. Puede explorar más visitando el sitio oficial https://doc.traefik.io/traefik/. Gracias.