Cómo usar Traefik como Proxy inverso para contenedores de Docker en Ubuntu 18.04

El autor seleccionó Girls Who Code para recibir una donación como parte del programa Write for DOnations.

Introducción

Docker puede ser una alternativa eficaz para ejecutar aplicaciones web en producción, pero es posible que desee ejecutar varias aplicaciones en el mismo host de Docker. En esta situación, deberá configurar un proxy inverso debido a que solo le convendrá exponer los puertos 80 y 443 al resto del mundo.

Traefik es un proxy inverso compatible con Docker que incluye su propio panel de supervisión. A través de este tutorial, usará Traefik para dirigir solicitudes a dos contenedores diferentes de aplicaciones web: WordPress y Adminer, cada uno en comunicación con una base de datos MySQL. Configurará Traefik para presentar todo a través de HTTPS usando Let´s Encrypt.

Requisitos previos

Para este tutorial, necesitará lo siguiente:

Paso 1: Configurar y ejecutar Traefik

El proyecto Traefik tiene una imagen de Docker oficial, por lo que la usaremos para ejecutar Traefik en un contenedor de Docker.

Sin embargo, antes de preparar nuestro contenedor de Traefik, debemos crear un archivo de configuración y establecer una contraseña cifrada para poder acceder al panel de supervisión.

Usaremos la utilidad htpasswd para crear esta contraseña cifrada. Primero, instale la utilidad, que se incluye en el paquete apache2-utils:

  • sudo apt-get install apache2-utils

Luego, genere la contraseña con htpasswd. Sustituya secure_password por la contraseña que desee usar para el usuario de administración Traefik:

  • htpasswd -nb admin secure_password

El resultado del programa tendrá el siguiente aspecto:

Output
admin:$apr1$ruca84Hq$mbjdMZBAG.KWn7vfN/SNK/

Usará este resultado en el archivo de configuración de Traefik para definir la autenticación HTTP básica para el control de estado y el panel de supervisión de Traefik. Copie la línea de resultado completa para poder pegarla posteriormente.

Para configurar el servidor de Traefik, crearemos un nuevo archivo de configuración llamado traefik.toml usando el formato TOML. TOML es un lenguaje de configuración que se asemeja a los archivos INI, pero está estandarizado. Este archivo nos permite configurar el servidor Traefik y varias integraciones, o proveedores, que nos convendrá usar. Para este tutorial, usaremos tres de los proveedores disponibles de Traefik: api, docker y acme, que se utiliza para ofrecer compatibilidad con TLS usando Let´s Encrypt.

Abra su nuevo archivo en nano o en su editor de texto favorito:

  • nano traefik.toml

Primero, añada dos puntos de entrada con nombre, http y https, a los que todos los backend tendrán acceso de forma predeterminada:

traefik.toml
defaultEntryPoints = ["http", "https"]

Configuraremos los puntos de entrada http y https posteriormente en este archivo.

A continuación, configure el proveedor api, que le proporciona acceso a una interfaz de panel de control. Aquí es donde pegará el resultado del comando htpasswd:

traefik.toml
...
[entryPoints]
  [entryPoints.dashboard]
    address = ":8080"
    [entryPoints.dashboard.auth]
      [entryPoints.dashboard.auth.basic]
        users = ["admin:your_encrypted_password"]

[api]
entrypoint="dashboard"

El panel es una aplicación web independiente que se ejecutará en el contenedor Traefik. Configuraremos el panel para que se ejecute en el puerto 8080.

La sección entrypoints.dashboard establece la forma en que estableceremos la conexión con el proveedor api y la sección entrypoints.dashboard.auth.basic la autenticación básica HTTP para el panel. Use el resultado del comando htpasswd que acaba de ejecutar para el valor de la entrada users. Podría especificar inicios de sesión adicionales separándolos con comas.

Hemos definido nuestro primer entryPoint, pero deberemos definir otros para la comunicación HTTP y HTTPS estándar que no se dirija al proveedor api. La sección entryPoints configura las direcciones en las que Traefik y los contenedores proxy pueden escuchar. Añada estas líneas al archivo bajo el encabezado entryPoints:

traefik.toml
...
  [entryPoints.http]
    address = ":80"
      [entryPoints.http.redirect]
        entryPoint = "https"
  [entryPoints.https]
    address = ":443"
      [entryPoints.https.tls]
...

El punto de entrada http gestiona el puerto 80, mientras que el punto de entrada https utiliza el puerto 443 para TLS/SSL. Redireccionamos automáticamente todo el tráfico del puerto 80 al punto de entrada https a fin de forzar conexiones seguras para todas las solicitudes.

A continuación, añada esta sección para establecer la compatibilidad de certificados de Let´s Encrypt con Traefik:

traefik.toml
...
[acme]
email = "[email protected]_domain"
storage = "acme.json"
entryPoint = "https"
onHostRule = true
  [acme.httpChallenge]
  entryPoint = "http"

Esta sección se denomina acme, porque ACME es el nombre del protocolo usado para comunicarse con Let´s Encrypt y gestionar los certificados. El servicio Let´s Encrypt requiere registro con una dirección de correo electrónico válida. Por lo tanto, para que Traefik genere certificados para nuestros hosts, use su dirección de correo electrónico para definir la clave email. Luego debemos especificar que almacenaremos la información que recibiremos de Let´s Encrypt en un archivo JSON llamado acme.jason. La clave entryPoint deberá orientarse al puerto de gestión de puntos de entrada 443, que en nuestro caso es el punto de entrada https.

La clave onHostRule indica la forma en que Traefik debería generar certificados. Nuestra idea es obtener nuestros certificados no bien se creen nuestros contenedores con los hostnames especificados, eso es lo que hará el ajuste onHostRule.

La sección acme.httpChallenge nos permite especificar la forma en que Let´s Encrypt puede verificar que el certificado se genere. Lo configuraremos para presentar un archivo como parte del desafío a través del punto de entrada http.

Finalmente, configuraremos el proveedor docker añadiendo estas líneas al archivo:

traefik.toml
...
[docker]
domain = "your_domain"
watch = true
network = "web"

El proveedor docker permite a Traefik actuar como un proxy frente a los contenedores de Docker. Con esto, habremos configurado el proveedor para buscar nuevos contenedores en la red web (que crearemos pronto) y los expondremos como subdominios de your_domain.

En este momento, traefik.toml debería tener el siguiente contenido:

traefik.toml
defaultEntryPoints = ["http", "https"]

[entryPoints]
  [entryPoints.dashboard]
    address = ":8080"
    [entryPoints.dashboard.auth]
      [entryPoints.dashboard.auth.basic]
        users = ["admin:your_encrypted_password"]
  [entryPoints.http]
    address = ":80"
      [entryPoints.http.redirect]
        entryPoint = "https"
  [entryPoints.https]
    address = ":443"
      [entryPoints.https.tls]

[api]
entrypoint="dashboard"

[acme]
email = "[email protected]_domain"
storage = "acme.json"
entryPoint = "https"
onHostRule = true
  [acme.httpChallenge]
  entryPoint = "http"

[docker]
domain = "your_domain"
watch = true
network = "web"

Guarde el archivo y salga del editor. Una vez implementada toda esta configuración, podemos activar Traefik.

Paso 2: Ejecutar el contenedor de Traefik

A continuación, cree una red de Docker para que el proxy la comparta con los contenedores. La red de Docker es necesaria para que podamos usarla con aplicaciones que se ejecuten usando Docker Compose. Daremos a esta red el nombre web.

  • docker network create web

Cuando se inicie el contenedor Traefik, lo añadiremos a esta red. Luego podremos añadir a esta red contenedores, para los cuales Traefik actuará como proxy.

A continuación, cree un archivo vacío que contendrá nuestra información de Let´s Encrypt. Compartiremos este archivo en el contenedor para que Traefik pueda usarlo:

  • touch acme.json

Traefik solo podrá usar este archivo si el usuario root dentro del contenedor tiene acceso exclusivo de lectura y escritura a este. Para hacer esto, bloquee los permisos en acme.json para que solo el propietario del archivo tenga permisos de lectura y escritura.

  • chmod 600 acme.json

Una vez que el archivo se transmita a Docker, el propietario pasará a ser de forma automática el usuario root dentro del contenedor.

Por último, cree el contenedor Traefik con este comando:

  • docker run -d
  • -v /var/run/docker.sock:/var/run/docker.sock
  • -v $PWD/traefik.toml:/traefik.toml
  • -v $PWD/acme.json:/acme.json
  • -p 80:80
  • -p 443:443
  • -l traefik.frontend.rule=Host:monitor.your_domain
  • -l traefik.port=8080
  • --network web
  • --name traefik
  • traefik:1.7.2-alpine

El comando es un poco extenso; por ello, lo dividiremos.

Usaremos el indicador -d para ejecutar el contenedor en segundo plano como un demonio. A continuación, compartiremos nuestro archivo docker.sock en el contenedor para que el proceso de Traefik pueda escuchar los cambios en los contenedores. También compartiremos el archivo de configuración traefik.toml y el archivo acme.json que creamos en el contenedor.

A continuación, asignaremos los puertos :80 y :443 de nuestro host de Docker a los mismos puertos en el contenedor Traefik para que Traefik reciba todo el tráfico HTTP y HTTPS enviado al servidor.

Luego configuraremos dos etiquetas de Docker para indicar a Traefik que dirija el tráfico de hostname monitor.your_domain al puerto :8080 dentro del contenedor de Traefik, lo cual expondrá el panel de supervisión.

Fijaremos la red del contenedor en web y daremos al contenedor el nombre traefik.

Finalmente, usaremos la imagen traefik:1.7.2-alpine para este contenedor, ya que es pequeña.

El ENTRYPOINT de una imagen de Docker es un comando que siempre se ejecuta cuando se crea un contenedor a partir de la imagen. En este caso, el comando es el binario traefik dentro del contenedor. Puede transmitir argumentos adicionales a ese comando al iniciar el contenedor, pero configuramos todos nuestros ajustes en el archivo traefik.toml.

Con el contenedor iniciado, ahora tiene un panel de control al que puede acceder para ver el estado de sus contenedores. También puede usar este panel de control para visualizar los frontends y los backends que Traefik registró. Acceda al panel de control apuntando su navegador hacia https://monitor.your_domain. Se le solicitará su nombre de usuario y contraseña, que son admin y la contraseña que configuró en el paso 1.

Una vez que inicie sesión, verá una interfaz similar a esta:

Panel de Traefik vacío

Aún no hay mucho que ver, pero si deja esta ventana abierta verá el cambio en el contenido a medida que añada contenedores con los que Traefik trabajará.

Ahora tenemos nuestro proxy de Traefik activo, configurado para que funcione con Docker, y listo para supervisar otros contendores de Docker. Vamos a iniciar algunos contenedores para los que Traefik actuará como proxy.

Paso 3: Registrar contenedores con Traefik

Con el contenedor Traefik activo, estará listo para ejecutar aplicaciones detrás de él. Iniciaremos los siguientes contenedores detrás de Traefik:

  1. Un blog que utilice la imagen oficial de WordPress.
  2. Un servidor de administración de bases de datos que utilice la imagen oficial de Adminer.

Administraremos estas aplicaciones con Docker Compose usando un archivo docker-compose.yml. Abra el archivo docker-compose.yml en su editor:

  • nano docker-compose.yml

Añada las siguientes líneas al archivo para especificar la versión y las redes que usaremos:

docker-compose.yml
version: "3"

networks:
  web:
    external: true
  internal:
    external: false

Usaremos Docker Compose 3 porque es la versión importante más reciente del formato de archivo Compose.

Para que Traefik reconozca nuestras aplicaciones, deben ser parte de la misma red. Debido a que la creamos manualmente, la introduciremos especificando el nombre de red de web y fijando external en true. Luego definiremos otra red para que podamos conectar nuestros contenedores expuestos a un contenedor de base de datos que no expondremos a través de Traefik. Llamaremos a esta red internal.

A continuación, definiremos nuestros services de a uno por vez. Comenzaremos con el contenedor blog, que basaremos en la imagen oficial de WordPress. Agregue esta configuración al archivo:

docker-compose.yml
version: "3"
...

services:
  blog:
    image: wordpress:4.9.8-apache
    environment:
      WORDPRESS_DB_PASSWORD:
    labels:
      - traefik.backend=blog
      - traefik.frontend.rule=Host:blog.your_domain
      - traefik.docker.network=web
      - traefik.port=80
    networks:
      - internal
      - web
    depends_on:
      - mysql

La clave environment le permite especificar las variables de entorno que se configurarán dentro del contenedor. Al no establecer un valor para WORDPRESS_DB_PASSWORD, indicaremos a Docker Compose que obtenga el valor de nuestro shell y lo transmita cuando creemos el contenedor. Definiremos esta variable de entorno en nuestro shell antes de iniciar los contenedores. De esta manera, no codificamos contraseñas de forma rígida en el archivo de configuración.

En la sección labels se especifican los valores de configuración para Traefik. Las etiquetas de Docker no hacen nada por sí mismas, pero Traefik las lee para el tratamiento de los contenedores. Aquí verá lo que hace cada una de estas etiquetas:

  • traefik.backend especifica el nombre del servicio de backend en Traefik (que apunta al contenedor real de blog.
  • traefik.frontend.rule=Host:blog.your_domain indica a Traefik que examine el host solicitado y si coincide con el patrón de blog.your_domain debería dirigir el tráfico al contenedor blog.
  • traefik.docker.network=web especifica la red en la que se debe buscar para que Traefik encuentre el IP interno de este contenedor. Debido a que nuestro contenedor de Traefik tiene acceso a toda la información de Docker, potencialmente tomaría el IP para la red internal si no especificamos esto.
  • traefik.port especifica el puerto expuesto que Traefik debería usar para dirigir el tráfico hacia este contenedor.

Con esta configuración, todo el tráfico enviado al puerto 80 de nuestro host de Docker se dirigirá al contenedor blog.

Asignaremos este contenedor a dos redes diferentes para que Traefik pueda encontrarlo a través de la red web y comunicarse con el contenedor de base de datos a través de la red internal.

Finalmente, la clave depends_on indica a Docker Compose que este contenedor debe iniciarse una vez que sus dependencias estén en ejecución. Ya que WordPress necesita una base de datos para ejecutarse, debemos ejecutar nuestro contenedor mysql antes de iniciar nuestro contenedor blog.

A continuación, configure el servicio de MySQL agregando esta configuración a su archivo:

docker-compose.yml
services:
...
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD:
    networks:
      - internal
    labels:
      - traefik.enable=false

Usaremos la imagen oficial de MySQL 5.7 para este contenedor. Observará que una vez más usaremos un elemento environment sin un valor. Las variables MySQL_ROOT_PASSWORD y MYSQL_ROOT_PASSWORD deberán fijarse en el mismo valor para garantizar que nuestro contenedor de WordPress pueda comunicarse con MySQL. No nos convendrá exponer el contenedor mysql a Traefik o al mundo exterior, por lo que solo asignaremos este contenedor a la red internal. Dado que Traefik tiene acceso al socket de Docker, el proceso seguirá exponiendo un frontend para el contenedor mysql por defecto, de forma que añadiremos la etiqueta traefik.enable=false para especificar que Traefik no debería exponer este contenedor.

Finalmente, añada esta configuración para definir el contenedor Adminer:

docker-compose.yml
services:
...
  adminer:
    image: adminer:4.6.3-standalone
    labels:
      - traefik.backend=adminer
      - traefik.frontend.rule=Host:db-admin.your_domain
      - traefik.docker.network=web
      - traefik.port=8080
    networks:
      - internal
      - web
    depends_on:
      - mysql

Este contenedor se basa en la imagen oficial de Adminer. La configuración de network y depends_on para este contenedor coinciden exactamente con lo que usamos para el contenedor blog.

Sin embargo, ya que dirigiremos todo el tráfico del puerto 80 de nuestro host de Docker directamente al contenedor blog, debemos configurar este contenedor de forma diferente para que el tráfico llegue a nuestro contenedor adminer. La línea traefik.frontend.rule=Host:db-admin.your_domain indica a Traefik que examine el host solicitado. Si coincide con el patrón de db-admin.your_domain, Traefik dirigirá el tráfico al contenedor adminer.

En este momento, docker-compose.yml debería tener el siguiente contenido:

docker-compose.yml
version: "3"

networks:
  web:
    external: true
  internal:
    external: false

services:
  blog:
    image: wordpress:4.9.8-apache
    environment:
      WORDPRESS_DB_PASSWORD:
    labels:
      - traefik.backend=blog
      - traefik.frontend.rule=Host:blog.your_domain
      - traefik.docker.network=web
      - traefik.port=80
    networks:
      - internal
      - web
    depends_on:
      - mysql
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD:
    networks:
      - internal
    labels:
      - traefik.enable=false
  adminer:
    image: adminer:4.6.3-standalone
    labels:
      - traefik.backend=adminer
      - traefik.frontend.rule=Host:db-admin.your_domain
      - traefik.docker.network=web
      - traefik.port=8080
    networks:
      - internal
      - web
    depends_on:
      - mysql

Guarde el archivo y salga del editor de texto.

A continuación, establezca valores en su shell para las variables WORDPRESS_DB_PASSWORD y MySQL_ROOT_PASSWORD antes de iniciar sus contenedores:

  • export WORDPRESS_DB_PASSWORD=secure_database_password
  • export MYSQL_ROOT_PASSWORD=secure_database_password

Sustituya secure_database_password por su contraseña de base de datos deseada. Recuerde usar la misma contraseña tanto para WORDPRESS_DB_PASSWORD como para MySQL_ROOT_PASSWORD.

Una vez configuradas estas variables, ejecute los contenedores usando docker-compose:

  • docker-compose up -d

Ahora, observe de nuevo el panel de administración de Traefik. Verá que hay un backend y un frontend para los dos servidores expuestos:

Panel de Traefik con contenido

Diríjase a blog.your_domain y sustituya your_domain por su dominio. Accederá a una conexión TLS y podrá completar la configuración de WordPress:

Pantalla configuración de WordPress

Ahora, acceda a Adminer visitando db-admin.your_domain en su navegador y vuelva a sustituir your_domain por su dominio. El contenedor mysql no está expuesto al mundo exterior, pero el contenedor adminer tiene acceso a él a través de la red internal de Docker que comparten usando el nombre de contenedor de mysql como nombre de host.

En la pantalla de inicio de sesión de Adminer, utilice el nombre de usuario root, mysql para el servidor y el valor que fijó para MySQL_ROOT_PASSWORD para la contraseña. Una vez que inicie sesión, verá la interfaz de usuario de Adminer:

Adminer conectado a la base de datos de MySQL

Ahora ambos sitios funcionan y puede usar el panel en monitor.your_domain para controlar sus aplicaciones.

Conclusión

A través de este tutorial, configuró Traefik para solicitudes de proxy a otras aplicaciones en contenedores de Docker.

La configuración declarativa de Traefik en el nivel de contenedor de la aplicación hace que sea fácil configurar más servicios, y no será necesario reiniciar el contenedor traefik cuando añada nuevas aplicaciones para aplicar proxy al tráfico, ya que Traefik advierte los cambios de inmediato a través del archivo de socket de Docker que controla.

Para obtener más información sobre lo que puede hacer con Traefik, consulte la documentación oficial de Traefik.

Originally posted on DigitalOcean Community Tutorials
Author: DigitalOcean

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *