One place for hosting & domains

      Traefik

      How To Use Traefik as a Reverse Proxy for Docker Containers on Ubuntu 20.04


      The author selected Girls Who Code to receive a donation as part of the Write for DOnations program.

      Introduction

      Docker can be an efficient way to run web applications in production, but you may want to run multiple applications on the same Docker host. In this situation, you’ll need to set up a reverse proxy since you only want to expose ports 80 and 443 to the rest of the world.

      Traefik is a Docker-aware reverse proxy that includes its own monitoring dashboard. In this tutorial, you’ll use Traefik to route requests to two different web application containers: a WordPress container and an Adminer container, each talking to a MySQL database. You’ll configure Traefik to serve everything over HTTPS using Let’s Encrypt.

      Prerequisites

      To follow this tutorial, you will need the following:

      Step 1 — Configuring and Running Traefik

      The Traefik project has an official Docker image, so we will use that to run Traefik in a Docker container.

      But before we get our Traefik container up and running, we need to create a configuration file and set up an encrypted password so we can access the monitoring dashboard.

      We’ll use the htpasswd utility to create this encrypted password. First, install the utility, which is included in the apache2-utils package:

      • sudo apt-get install apache2-utils

      Then generate the password with htpasswd. Substitute secure_password with the password you’d like to use for the Traefik admin user:

      • htpasswd -nb admin secure_password

      The output from the program will look like this:

      Output

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

      You’ll use your unique output in the Traefik configuration file to set up HTTP Basic Authentication for the Traefik health check and monitoring dashboard. Copy your entire output line so you can paste it later. Do not use the example output.

      To configure the Traefik server, we’ll create a new configuration file called traefik.toml using the TOML format. TOML is a configuration language similar to INI files, but standardized. This file lets us configure the Traefik server and various integrations, or providers, that we want to use. In this tutorial, we will use three of Traefik’s available providers: api, docker, and acme. The last of these, acme supports TLS certificates using Let’s Encrypt.

      Open up your new file in nano or your favorite text editor:

      First, add two named entry points, http and https, which all backends will have access to by default:

      traefik.toml

      defaultEntryPoints = ["http", "https"]
      

      We’ll configure the http and https entry points later in this file.

      Next, configure the api provider, which gives you access to a dashboard interface. This is where you’ll paste the output from the htpasswd command:

      traefik.toml

      ...
      [entryPoints]
        [entryPoints.dashboard]
          address = ":8080"
          [entryPoints.dashboard.auth]
            [entryPoints.dashboard.auth.basic]
              users = ["admin:your_encrypted_password"]
      
      [api]
      entrypoint="dashboard"
      

      The dashboard is a separate web application that will run within the Traefik container. We set the dashboard to run on port 8080.

      The entrypoints.dashboard section configures how we’ll be connecting with the api provider, and the entrypoints.dashboard.auth.basic section configures HTTP Basic Authentication for the dashboard. Use the output from the htpasswd command you just ran for the value of the users entry. You could specify additional logins by separating them with commas.

      We’ve defined our first entryPoint, but we’ll need to define others for standard HTTP and HTTPS communication that isn’t directed towards the api provider. The entryPoints section configures the addresses that Traefik and the proxied containers can listen on. Add these lines to the file underneath the entryPoints heading:

      traefik.toml

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

      The http entry point handles port 80, while the https entry point uses port 443 for TLS/SSL. We automatically redirect all of the traffic on port 80 to the https entry point to force secure connections for all requests.

      Next, add this section to configure Let’s Encrypt certificate support for Traefik:

      traefik.toml

      ...
      [acme]
      email = "your_email@your_domain"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      

      This section is called acme because ACME is the name of the protocol used to communicate with Let’s Encrypt to manage certificates. The Let’s Encrypt service requires registration with a valid email address, so in order to have Traefik generate certificates for our hosts, set the email key to your email address. We then specify that we will store the information that we will receive from Let’s Encrypt in a JSON file called acme.json. The entryPoint key needs to point to the entry point handling port 443, which in our case is the https entry point.

      The key onHostRule dictates how Traefik should go about generating certificates. We want to fetch our certificates as soon as our containers with specified hostnames are created, and that’s what the onHostRule setting will do.

      The acme.httpChallenge section allows us to specify how Let’s Encrypt can verify that the certificate should be generated. We’re configuring it to serve a file as part of the challenge through the http entrypoint.

      Finally, let’s configure the docker provider by adding these lines to the file:

      traefik.toml

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

      The docker provider enables Traefik to act as a proxy in front of Docker containers. We’ve configured the provider to watch for new containers on the web network, which we’ll create soon, and expose them as subdomains of your_domain.

      At this point, traefik.toml should have the following contents:

      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 = "your_email@your_domain"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      
      [docker]
      domain = "your_domain"
      watch = true
      network = "web"
      

      Save the file and exit the editor. With these configurations in place, we can initialize Traefik.

      Step 2 — Running the Traefik Container

      Next, create a Docker network for the proxy to share with containers. The Docker network is necessary so that we can use it with applications that are run using Docker Compose. Let’s call this network web:

      • docker network create web

      When the Traefik container starts, we will add it to this network. Then we can add additional containers to this network later for Traefik to proxy to.

      Next, create an empty file that will hold our Let’s Encrypt information. We’ll share this into the container so Traefik can use it:

      Traefik will only be able to use this file if the root user inside of the container has unique read and write access to it. To do this, lock down the permissions on acme.json so that only the owner of the file has read and write permission:

      Once the file gets passed to Docker, the owner will automatically change to the root user inside the container.

      Finally, create the Traefik container with this command:

      • 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-alpine

      The command is a little long so let’s break it down.

      We use the -d flag to run the container in the background as a daemon. We then share our docker.sock file into the container so that the Traefik process can listen for changes to containers. We also share the traefik.toml configuration file and the acme.json file we created into the container.

      Next, we map ports :80 and :443 of our Docker host to the same ports in the Traefik container so Traefik receives all HTTP and HTTPS traffic to the server.

      Then we set up two Docker labels that tell Traefik to direct traffic to the hostname monitor.your_domain to port :8080 within the Traefik container, which will expose the monitoring dashboard.

      We set the network of the container to web, and we name the container traefik.

      Finally, we use the traefik:1.7-alpine image for this container, because it’s small.

      A Docker image’s ENTRYPOINT is a command that always runs when a container is created from the image. In this case, the command is the traefik binary within the container. You can pass additional arguments to that command when you launch the container, but we’ve configured all of our settings in the traefik.toml file.

      With the container started, you now have a dashboard you can access to see the health of your containers. You can also use this dashboard to visualize the frontends and backends that Traefik has registered. Access the monitoring dashboard by pointing your browser to https://monitor.your_domain. You will be prompted for your username and password, which are admin and the password you configured in Step 1.

      Once logged in, you’ll see an interface similar to this:

      Empty Traefik dashboard

      There isn’t much to see just yet, but leave this window open, and you will see the contents change as you add containers for Traefik to manage.

      We now have our Traefik proxy running, configured to work with Docker, and ready to monitor other Docker containers. Let’s add some containers for Traefik to proxy.

      Step 3 — Registering Containers with Traefik

      With the Traefik container running, you’re ready to run applications behind it. Let’s launch the following containers behind Traefik:

      1. A blog using the official WordPress image.
      2. A database management server using the official Adminer image.

      We’ll manage both of these applications with Docker Compose using a docker-compose.yml file.

      Create and open the docker-compose.yml file in your editor:

      Add the following lines to the file to specify the version and the networks we’ll use:

      docker-compose.yml

      version: "3"
      
      networks:
        web:
          external: true
        internal:
          external: false
      

      We use Docker Compose version 3 because it’s the newest major version of the Compose file format.

      For Traefik to recognize our applications, they must be part of the same network, and since we created the network manually, we pull it in by specifying the network name of web and setting external to true. Then we define another network so that we can connect our exposed containers to a database container that we won’t expose through Traefik. We’ll call this network internal.

      Next, we’ll define each of our services, one at a time. Let’s start with the blog container, which we’ll base on the official WordPress image. Add this configuration to the bottom of your file:

      docker-compose.yml

      ...
      
      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
      

      The environment key lets you specify environment variables that will be set inside of the container. By not setting a value for WORDPRESS_DB_PASSWORD, we’re telling Docker Compose to get the value from our shell and pass it through when we create the container. We will define this environment variable in our shell before starting the containers. This way we don’t hard-code passwords into the configuration file.

      The labels section is where you specify configuration values for Traefik. Docker labels don’t do anything by themselves, but Traefik reads these so it knows how to treat containers. Here’s what each of these labels does:

      • traefik.backend specifies the name of the backend service in Traefik (which points to the actual blog container).
      • traefik.frontend.rule=Host:blog.your_domain tells Traefik to examine the host requested and if it matches the pattern of blog.your_domain it should route the traffic to the blog container.
      • traefik.docker.network=web specifies which network to look under for Traefik to find the internal IP for this container. Since our Traefik container has access to all of the Docker info, it would potentially take the IP for the internal network if we didn’t specify this.
      • traefik.port specifies the exposed port that Traefik should use to route traffic to this container.

      With this configuration, all traffic sent to our Docker host’s port 80 will be routed to the blog container.

      We assign this container to two different networks so that Traefik can find it via the web network and it can communicate with the database container through the internal network.

      Lastly, the depends_on key tells Docker Compose that this container needs to start after its dependencies are running. Since WordPress needs a database to run, we must run our mysql container before starting our blog container.

      Next, configure the MySQL service by adding this configuration to the bottom of your file:

      docker-compose.yml

      ...
        mysql:
          image: mysql:5.7
          environment:
            MYSQL_ROOT_PASSWORD:
          networks:
            - internal
          labels:
            - traefik.enable=false
      

      We’re using the official MySQL 5.7 image for this container. You’ll notice that we’re once again using an environment item without a value. The MYSQL_ROOT_PASSWORD and WORDPRESS_DB_PASSWORD variables will need to be set to the same value to make sure that our WordPress container can communicate with the MySQL. We don’t want to expose the mysql container to Traefik or the outside world, so we’re only assigning this container to the internal network. Since Traefik has access to the Docker socket, the process will still expose a frontend for the mysql container by default, so we’ll add the label traefik.enable=false to specify that Traefik should not expose this container.

      Finally, add this configuration to the bottom of your file to define the Adminer container:

      docker-compose.yml

      ...
        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
      

      This container is based on the official Adminer image. The network and depends_on configuration for this container exactly match what we’re using for the blog container.

      However, since we’re directing all of the traffic to port 80 on our Docker host directly to the blog container, we need to configure this container differently in order for traffic to make it to our adminer container. The line traefik.frontend.rule=Host:db-admin.your_domain tells Traefik to examine the host requested. If it matches the pattern of db-admin.your_domain, Traefik will route the traffic to the adminer container.

      At this point, docker-compose.yml should have the following contents:

      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
      

      Save the file and exit the text editor.

      Next, set values in your shell for the WORDPRESS_DB_PASSWORD and MYSQL_ROOT_PASSWORD variables before you start your containers:

      • export WORDPRESS_DB_PASSWORD=secure_database_password
      • export MYSQL_ROOT_PASSWORD=secure_database_password

      Substitute secure_database_password with your desired database password. Remember to use the same password for both WORDPRESS_DB_PASSWORD and MYSQL_ROOT_PASSWORD.

      With these variables set, run the containers using docker-compose:

      Now take another look at the Traefik admin dashboard. You’ll see that there is now a backend and a frontend for the two exposed servers:

      Populated Traefik dashboard

      Navigate to blog.your_domain. You’ll be redirected to a TLS connection and can now complete the WordPress setup:

      WordPress setup screen

      Now access Adminer by visiting db-admin.your_domain in your browser, again substituting your_domain with your domain. The mysql container isn’t exposed to the outside world, but the adminer container has access to it through the internal Docker network that they share using the mysql container name as a hostname.

      On the Adminer login screen, set the System dropdown menu to MySQL. Now enter mysql for the Server, enter root for the username, and enter the value you set for MYSQL_ROOT_PASSWORD for Password. Leave Database empty. Now press Login.

      Once logged in, you’ll see the Adminer user interface:

      Adminer connected to the MySQL database

      Both sites are now working, and you can use the dashboard at monitor.your_domain to keep an eye on your applications.

      Conclusion

      In this tutorial, you configured Traefik to proxy requests to other applications in Docker containers.

      Traefik’s declarative configuration at the application container level makes it easy to configure more services, and there’s no need to restart the traefik container when you add new applications to proxy traffic because Traefik notices the changes immediately through the Docker socket file that it’s monitoring.

      To learn more about what you can do with Traefik, head over to the official Traefik documentation.



      Source link

      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:

      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 = "your_email@your_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 = "your_email@your_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:

      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.

      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:

      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:

      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.



      Source link

      Использование Traefik в качестве обратного прокси для контейнеров Docker в Ubuntu 18.04


      Автор выбрал Girls Who Code для получения пожертвования в рамках программы Write for DOnations.

      Введение

      Docker может эффективно запускать веб-приложения в производственном среде, но бывает так, что вам нужно запустить несколько приложений на одном хосте Docker. В этой ситуации вам нужно настроить обратный прокси, поскольку вы хотите открывать для мира только порты 80 и 443.

      Traefik — это обратный прокси с поддержкой Docker, имеющий собственную панель мониторинга. В этом обучающем модуле вы используете Traefik для перенаправления запросов двух разных контейнеров веб-приложений: контейнера WordPress и контейнера Adminer, каждый из которых взаимодействует с базой данных MySQL. Вы настроите Traefik для обслуживания соединений через HTTPS с помощью Let’s Encrypt.

      Предварительные требования

      Для выполнения этого обучающего модуля вам потребуется следующее:

      Шаг 1 — Настройка и запуск Traefik

      Проект Traefik имеет официальный образ Docker, так что мы будем использовать его для запуска Traefik в контейнере Docker.

      Однако прежде чем мы запустим наш контейнер Traefik, нам нужно будет создать файл конфигурации и настроить шифрованный пароль для доступа к информационной панели мониторинга.

      Для создания шифрованного пароля мы используем утилиту htpasswd. Вначале следует установить эту утилиту, которая входит в пакет apache2-utils:

      • sudo apt-get install apache2-utils

      Затем нужно сгенерировать пароль с помощью htpasswd. Замените secure_password паролем, который вы хотите использовать для административного пользователя Traefik:

      • htpasswd -nb admin secure_password

      Программа выдаст следующий результат:

      Output

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

      Используйте этот результат в файле конфигурации Traefik для настройки базовой аутентификации HTTP для проверки состояния Traefik и информационной панели мониторинга. Скопируйте всю строку результатов, чтобы ее можно было вставить.

      Для настройки сервера Traefik мы создадим новый файл конфигурации с именем traefik.toml в формате TOML. TOML — это язык конфигурации, похожий на используемый в файлах INI, но при этом стандартизированный. Этот файл позволит нам настроить сервер Traefik и различные интеграции или провайдеров, которых мы хотим использовать. В этом обучающем модуле мы будем использовать три из числа доступных провайдеров Traefik: api, docker и acme, который используется для поддержки TLS при использовании Let’s Encrypt.

      Откройте новый файл в nano или в другом предпочитаемом текстовом редакторе:

      Добавьте две точки входа с именами http и https, которые будут по умолчанию доступны всем серверным компонентам:

      traefik.toml

      defaultEntryPoints = ["http", "https"]
      

      Мы настроим точки входа http и https в следующих шагах.

      Затем настройте провайдер api, который дает доступ к интерфейсу информационной панели. Здесь вам нужно вставить результат выполнения команды htpasswd:

      traefik.toml

      ...
      [entryPoints]
        [entryPoints.dashboard]
          address = ":8080"
          [entryPoints.dashboard.auth]
            [entryPoints.dashboard.auth.basic]
              users = ["admin:your_encrypted_password"]
      
      [api]
      entrypoint="dashboard"
      

      Информационная панель — это отдельное веб-приложение, работающее в контейнере Traefik. Мы настроим информационную панель для запуска на порту 8080.

      Раздел entrypoints.dashboard настраивает способ подключения с помощью провайдера api, а раздел entrypoints.dashboard.auth.basic настраивает базовую аутентификацию HTTP для информационной панели. Используйте результат выполнения команды htpasswd для получения значения записи users. Вы можете указать дополнительные имена пользователей, отделяя их с помощью запятых.

      Мы определили первую точку входа entryPoint, но теперь нам нужно определить другие точки входа для стандартных коммуникаций HTTP и HTTPS, которые не направлены на провайдер api. В разделе entryPoints настраиваются адреса, которые могут прослушивать Traefik и контейнеры, подключенные через прокси. Добавьте в файл следующие строки под заголовком entryPoints:

      traefik.toml

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

      Точка входа http использует порт 80, а точка входа https использует порт 443 для TLS/SSL. Мы автоматически перенаправляем весь трафик порта 80 на точку входа https, чтобы принудительно использовать защищенные соединения для всех запросов.

      Затем добавьте этот раздел для настройки поддержки сертификата Let’s Encrypt для Traefik:

      traefik.toml

      ...
      [acme]
      email = "your_email@your_domain"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      

      Этот раздел называется acme, потому что ACME — это имя протокола, используемое для связи с Let’s Encrypt для управления сертификатами. Служба Let’s Encrypt требует для регистрации действующий адрес электронной почты, и чтобы дать Traefik возможность генерировать сертификаты для наших хостов, установите для ключа email свой адрес электронной почты. Затем мы укажем, что будем сохранять получаемую от Let’s Encrypt информацию в файле JSON с именем acme.json. Ключ entryPoint должен указывать на точку входа, использующую порт 443, и в нашем случае это будет точка входа https.

      Ключ onHostRule указывает, как Traefik следует генерировать сертификаты. Мы хотим получать сертификаты сразу же после создания контейнеров с заданными именами хостов, и для этого мы используем параметр onHostRule.

      Раздел acme.httpChallenge позволяет указать, как Let’s Encrypt сможет проверять необходимость генерирования сертификата. Мы настроим его для обслуживания файла в рамках запроса через точку входа http.

      В заключение мы настроим провайдер docker, добавив в файл следующие строки:

      traefik.toml

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

      Провайдер docker позволяет Traefik выступать в качестве прокси для контейнеров Docker. Мы настроили провайдер на отслеживание новых контейнеров в сети web (которую мы вскоре создадим) и для предоставления доступа к ним как к субдоменам домена your_domain.

      На данный момент файл traefik.toml должен иметь следующее содержание:

      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 = "your_email@your_domain"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      
      [docker]
      domain = "your_domain"
      watch = true
      network = "web"
      

      Сохраните файл и выйдите из редактора. Настроив эти параметры конфигурации, мы можем запускать Traefik.

      Шаг 2 — Запуск контейнера Traefik

      Затем создайте сеть Docker, которую прокси будет использовать для связи с контейнерами. Сеть Docker необходима, чтобы мы могли использовать ее для приложений, запущенных с помощью Docker Compose. Присвоим этой сети имя web.

      • docker network create web

      После запуска контейнера Traefik мы добавим его в эту сеть. Теперь мы можем добавить в эту сеть дополнительные контейнеры, для которых Traefik будет выступать в качестве прокси.

      Создайте пустой файл, где будет храниться информация Let’s Encrypt. Мы передадим ее в контейнер, чтобы Traefik мог ее использовать:

      Traefik сможет использовать этот файл, только если пользователь root внутри контейнера будет иметь уникальный доступ к этому файлу для чтения и записи. Для этого нам нужно будет заблокировать разрешения файла acme.json, чтобы права записи и чтения были только у владельца файла.

      После передачи файла в Docker владелец автоматически сменяется на пользователя root внутри контейнера.

      Затем создайте контейнер Traefik с помощью следующей команды:

      • 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

      Это команда немного длинная, так что попробуем ее разбить.

      Мы используем флаг -d для запуска контейнера в фоновом режиме как демона. Затем мы передадим файл docker.sock в контейнер, чтобы процесс Traefik могу отслеживать изменения в контейнерах. Также мы передадим в контейнер созданные нами файл конфигурации traefik.toml и файл acme.json.

      Затем мы сопоставим порты :80 и :443 нашего хоста Docker с аналогичными портами контейнера Traefik, чтобы Traefik принимал весь трафик HTTP и HTTPS, поступающий на сервер.

      Затем мы создадим два ярлыка Docker, которые будут предписывать Traefik направлять трафик хоста monitor.your_domain на порт :8080 в контейнере Traefik, открывая доступ к информационной панели мониторинга.

      Мы зададим для контейнера сеть web и присвоим ему имя traefik.

      В заключение мы используем образ traefik:1.7.2-alpine для этого контейнера, поскольку он имеет небольшой размер.

      Команда ENTRYPOINT всегда запускается при создании контейнера из образа Docker. В данном случае команда представялет собой двоичный файл traefik в контейнере. При запуске контейнера вы можете передать для команды дополнительные аргументы, но мы настроили все параметры в файле traefik.toml.

      После запуска контейнера вы получили информационную панель, которую можете использовать для просмотра состояния ваших контейнеров. Также вы можете использовать эту информационную панель для визуализации клиентских и серверных ресурсов, зарегистрированных Traefik. Откройте панель мониторинга, введя в браузер адрес https://monitor.your_domain. Вам будет предложено ввести имя пользователя и пароль. Используйте имя пользователя admin и пароль, заданный на шаге 1.

      После входа вы увидите интерфейс, который будет выглядеть примерно так:

      Пустая информационная панель Traefik

      Сейчас на панели почти ничего нет, но вам следует это окно открытым, и вы увидите, как будет меняться его содержание при добавлении в Traefik контейнеров.

      Мы запустили прокси Traefik, настроили его для работы с Docker и подготовились к отслеживанию других контейнеров Docker. Теперь запустим контейнеры, для которых Traefik будет выступать в качестве прокси.

      Шаг 3 — Регистрация контейнеров в Traefik

      Теперь у вас работает контейнер Traefik и вы готовы запускать через него приложения. Давайте запустим через Traefik следующие контейнеры:

      1. Блог, использующий официальный образ WordPress.
      2. Сервер управления базами данных, использующий официальный образ Adminer.

      Для управления этими приложениями мы будем использовать Docker Compose с файлом docker-compose.yml. Откройте файл docker-compose.yml в редакторе:

      Добавьте в файл следующие строки, чтобы указать версию и сети, которые мы будем использовать:

      docker-compose.yml

      version: "3"
      
      networks:
        web:
          external: true
        internal:
          external: false
      

      Мы будем использовать Docker Compose версии 3, потому что это последняя крупная версия формата файлов Compose.

      Чтобы у Traefik была возможность распознавать наши приложения, они должны входить в ту же сеть. Поскольку мы создали сеть вручную, мы подключим ее, указав имя сети web и задав для параметра external значение true. Затем мы определим другую сеть, чтобы мы могли подключать наши открытые контейнеры к контейнеру базы данных, доступ к которому мы не будем предоставлять через Traefik. Мы присвоим этой сети имя internal.

      Теперь мы определим наши службы, по одной за раз. Начнем с контейнера blog, который будет основан на официальном образе WordPress. Добавьте эту конфигурацию в файл:

      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
      

      Ключ environment позволяет задать переменные среды, которые будут заданы внутри контейнера. Мы не задаем значение паарметра WORDPRESS_DB_PASSWORD и тем самым предписываем Docker Compose использовать значение из нашей оболочки и передавать его при создании контейнера. Мы определим эту переменную в нашей оболочке перед запуском контейнеров. Так нам не придется напрямую программировать пароли в файле конфигурации.

      Раздел labels позволяет задать значения конфигурации для Traefik. Ярлыки Docker сами по себе ничего не делают, но Traefik их считывает, и поэтому ему известно, как следует обрабатывать контейнеры. Вот что делает каждый из этих ярлыков:

      • traefik.backend задает имя серверной службы в Traefik (которая указывает на фактический контейнер blog).
      • traefik.frontend.rule=Host:blog.your_domain предписывает Traefik проверить запрошенный хост, и если он соответствует шаблону blog.your_domain, перенаправить трафик в контейнер blog.
      • traefik.docker.network=web указывает, в какой сети Traefik следует искать внутренний IP-адрес для этого контейнера. Поскольку у нашего контейнера Traefik есть доступ ко всей информации Docker, он может взять IP-адрес сети internal, если мы не указали этого.
      • traefik.port задает открытый порт, который Traefik следует использовать для перенаправления трафика в этот контейнер.

      При такой конфигурации весь трафик, отправляемый на порт 80 нашего хоста Docker, будет перенаправляться в контейнер blog.

      Мы назначим для этого контейнера две отдельных сети, чтобы Traefik мог находить его через сеть web и чтобы он мог связываться с контейнером базы данных через сеть internal.

      Наконец, ключ depends_on сообщает Docker Compose, что этот контейнер должен запускаться после того, как будут запущены его зависимости. Поскольку для запуска WordPress требуется база данных, мы должны запустить наш контейнер mysql до того, как запустим контейнер blog.

      Теперь настройте службу MySQL, добавив в файл следующую конфигурацию:

      docker-compose.yml

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

      Для этого контейнера мы используем официальный образ MySQL 5.7. Возможно вы заметили, что мы снова используем элемент environment без значения. Для переменных MYSQL_ROOT_PASSWORD и WORDPRESS_DB_PASSWORD нужно задать одинаковое значение, чтобы наш контейнер WordPress мог связываться с MySQL. Мы не хотим открывать контейнер mysql для Traefik или внешнего мира, и поэтому мы назначим его только в сеть internal. Поскольку у Traefik имеется доступ к сокету Docker, данный процесс по умолчанию открывает клиентскую часть для контейнера mysql. Поэтому мы добавим ярлык traefik.enable=false, указывая, что Traefik не следует открывать доступ к этому контейнеру.

      В заключение добавим следующую конфигурацию для определения контейнера 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
      

      Этот контейнер основан на официальном образе Adminer. Конфигурации network и depends_on для этого контейнера точно совпадают с использованными нами для контейнера blog.

      Однако поскольку мы направляем весь трафик порта 80 нашего хоста Docker непосредственно в контейнер blog, нам нужно настроить этот контейнер по другому, чтобы трафик отправлялся в контейнер adminer. Строка traefik.frontend.rule=Host:db-admin.your_domain предписывает Traefik изучить запрошенный хост. Если он совпадает с шаблоном db-admin.your_domain, Traefik будет перенаправлять трафик в контейнер adminer.

      На данный момент файл docker-compose.yml должен иметь следующее содержание:

      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
      

      Сохраните файл и выйдите из текстового редактора.

      Теперь задайте в оболочке значения переменных WORDPRESS_DB_PASSWORD и MYSQL_ROOT_PASSWORD, прежде чем запускать контейнеры:

      • export WORDPRESS_DB_PASSWORD=secure_database_password
      • export MYSQL_ROOT_PASSWORD=secure_database_password

      Замените secure_database_password желаемым паролем для базы данных. Не забудьте использовать один и тот же пароль для WORDPRESS_DB_PASSWORD и MYSQL_ROOT_PASSWORD.

      Установив эти переменные, запустите контейнеры с помощью docker-compose:

      Еще раз посмотрите на информационную панель администратора Traefik. Вы увидите, что теперь для двух открытых серверов отображаются серверная часть и клиентская часть:

      Заполненная информационная панель Traefik

      Перейдите на адрес blog.your_domain, заменив your_domain на имя вашего домена. Вы будете перенаправлены на соединение TLS и сможете завершить настройку WordPress:

      Экран настройки WordPress

      Откройте Adminer. Для этого введите адрес db-admin.your_domain в адресную строку браузера, заменив your_domain на имя вашего домена. Контейнер mysql не открыт для окружающего мира, но контейнер adminer имеет доступ к нему через внутреннюю сеть internal в Docker, которую они совместно используют, используя имя контейнера mysql как имя хоста.

      На экране входа в систему Adminer используйте имя пользователя root, mysql в качестве сервера и заданное значение пароля MYSQL_ROOT_PASSWORD. После входа в систему вы увидите пользовательский интерфейс Adminer:

      Adminer подключен к базе данных MySQL

      Оба сайта уже работают, и вы можете использовать информационную панель monitor.your_domain для наблюдения за приложениями.

      Заключение

      В этом обучающем руководстве вы настроили Traefik для перенаправления запросов в другие приложения в контейнерах Docker.

      Декларативная конфигурация Traefik на уровне контейнера приложения позволяет легко настраивать дополнительные услуги. При этом контейнер traefik не требуется перезапускать при добавлении новых приложений для переадресации трафика, поскольку Traefik моментально определяет изменения через отслеживаемый файл сокета Docker.

      Чтобы узнать больше о том, что можно сделать с помощью Traefik, ознакомьтесь с официальной документацией по Traefik.



      Source link