One place for hosting & domains

      Cómo configurar Nginx como servidor web y proxy inverso para Apache en un servidor Ubuntu 18.04


      El autor seleccionó la Electronic Frontier Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Apache y Nginx son dos servidores web de código abierto populares que se suelen utilizar con PHP. Puede ser útil ejecutar ambos en la misma máquina virtual al albergar múltiples sitios web con requisitos variados. La solución general para ejecutar dos servidores web en un solo sistema es usar varias direcciones IP o diferentes números de puerto.

      Los servidores que tienen direcciones IPv4 e IPv6 pueden configurarse para servir sitios de Apache en un protocolo y sitios de Nginx en el otro, pero, actualmente, esto no resulta práctico, dado que la adopción de IPv6 por parte de los ISP todavía no está generalizada. Si bien tener un número de puerto diferente, como 81 o 8080, para el segundo servidor web es otra solución, compartir URL con números de puerto (como http://example.com:81) no siempre es razonable o ideal.

      En este tutorial, procederá a configurar Nginx como servidor web y como proxy inverso para Apache en un solo servidor.

      Dependiendo de la aplicación web, se pueden requerir cambios de código para mantener Apache al tanto del proxy inverso, en especial, cuando se configuran los sitios de SSL. Para evitar esto, instalará un módulo de Apache denominado mod_rpaf que reescribe ciertas variables de entorno para que parezca que Apache está gestionando directamente solicitudes de clientes web.

      Albergaremos cuatro nombres de dominio en un servidor. Nginx servirá dos de ellos: example.com (el host virtual predeterminado) y sample.org. Apache servirá los otros dos: foobar.net y test.io. También configuraremos Apache para que sirva aplicaciones de PHP usando PHP-FPM, que ofrece un mejor rendimiento que mod_php.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: instalación de Apache y PHP-FPM

      Vamos a comenzar por instalar Apache y PHP-FPM.

      Además de Apache y PHP-FPM, también instalaremos el módulo PHP FastCGI de Apache, libpache2-mod-fastcgi, para admitir aplicaciones web FastCGI.

      Primero, actualice su lista de paquetes para asegurarse de tener los paquetes más recientes.

      A continuación, instale los paquetes de Apache y PHP-FPM:

      • sudo apt install apache2 php-fpm

      El módulo FastCGI Apache no está disponible en el repositorio de Ubuntu, por lo que debe descargarlo desde kernel.org e instalarlo usando el comando dpkg.

      • wget https://mirrors.edge.kernel.org/ubuntu/pool/multiverse/liba/libapache-mod-fastcgi/libapache2-mod-fastcgi_2.4.7~0910052141-1.2_amd64.deb
      • sudo dpkg -i libapache2-mod-fastcgi_2.4.7~0910052141-1.2_amd64.deb

      Luego, cambiemos la configuración predeterminada de Apache para usar PHP-FPM.

      Paso 2: configuración de Apache y PHP-FPM

      En este paso, cambiaremos el número de puerto de Apache a 8080 y lo configuraremos para que funcione con PHP-FPM usando el módulo mod_fastcgi. Renombre al archivo de configuración ports.conf de Apache:

      • sudo mv /etc/apache2/ports.conf /etc/apache2/ports.conf.default

      Cree un archivo ports.conf nuevo con el puerto establecido en 8080:

      • echo "Listen 8080" | sudo tee /etc/apache2/ports.conf

      Nota: en general, los servidores web se establecen para escuchar en 127.0.0.1:8080 al configurar un proxy inverso, pero al hacerlo, el valor de la variable de entorno SERVER_ADDR de PHP se establece en la dirección IP de bucle invertido en lugar de establecerse en la IP pública del servidor. Nuestro objetivo es configurar Apache de manera tal que sus sitios web no visualicen un proxy inverso delante suyo. Por lo tanto, lo configuraremos para escuchar en 8080 todas las direcciones IP.

      A continuación, crearemos un archivo de host virtual para Apache. La <VirtualHost> directiva en este archivo se establecerá para servir sitios únicamente en el puerto 8080.

      Desactive el host virtual predeterminado:

      • sudo a2dissite 000-default

      A continuación, cree un nuevo archivo de host virtual usando el sitio predeterminado existente:

      • sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/001-default.conf

      Ahora, abra el nuevo archivo de configuración:

      • sudo nano /etc/apache2/sites-available/001-default.conf

      Cambie el puerto de escucha a 8080:

      /etc/apache2/sites-available/000-default.conf

      <VirtualHost *:8080>
          ServerAdmin webmaster@localhost
          DocumentRoot /var/www/html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Guarde el archivo y active el nuevo archivo de configuración:

      • sudo a2ensite 001-default

      Luego, vuelva a cargar Apache:

      • sudo systemctl reload apache2

      Verifique que, ahora, Apache escuche en 8080:

      El resultado debería verse como el siguiente ejemplo, con apache2 escuchando en 8080:

      Output

      Active Internet connections (only servers) Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 1086/sshd tcp6 0 0 :::8080 :::* LISTEN 4678/apache2 tcp6 0 0 :::22 :::* LISTEN 1086/sshd

      Una vez verifique que Apache está escuchando en el puerto correcto, puede configurar la compatibilidad con PHP y FastCGI.

      Paso 3: configuración de Apache para usar mod_fastcgi

      Apache sirve páginas de PHP usando mod_php por defecto, pero requiere de configuración adicional para funcionar con PHP-FPM.

      Nota: si está probando este tutorial en una instalación de LAMP con mod_php, primero, desactívela con sudo a2dismod php7.2.

      Vamos a añadir un bloque de configuración para mod_fastcgi que depende de mod_action. mod_action está desactivado por defecto, por lo que, primero, debemos habilitarlo:

      Cambie el nombre del archivo de configuración FastCGI:

      • sudo mv /etc/apache2/mods-enabled/fastcgi.conf /etc/apache2/mods-enabled/fastcgi.conf.default

      Cree un nuevo archivo de configuración:

      • sudo nano /etc/apache2/mods-enabled/fastcgi.conf

      Añada las siguientes directivas al archivo para transmitir solicitudes de archivos .php al socket PHP-FPM UNIX:

      /etc/apache2/mods-enabled/fastcgi.conf

      <IfModule mod_fastcgi.c>
        AddHandler fastcgi-script .fcgi
        FastCgiIpcDir /var/lib/apache2/fastcgi
        AddType application/x-httpd-fastphp .php
        Action application/x-httpd-fastphp /php-fcgi
        Alias /php-fcgi /usr/lib/cgi-bin/php-fcgi
        FastCgiExternalServer /usr/lib/cgi-bin/php-fcgi -socket /run/php/php7.2-fpm.sock -pass-header Authorization
        <Directory /usr/lib/cgi-bin>
          Require all granted
        </Directory>
      </IfModule>
      

      Guarde los cambios y realice una prueba de configuración:

      Vuelva a cargar Apache si aparece el mensaje Syntax OK:

      • sudo systemctl reload apache2

      Si ve la advertencia Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message., puede ignorarlo de forma segura por ahora. Configuraremos los nombres de servidor más adelante.

      Ahora, asegúrese de que podamos servir PHP desde Apache.

      Paso 4: verificación de la funcionalidad de PHP

      Vamos a asegurarnos de que PHP funcione al crear un archivo phpinfo() y acceder a él desde un navegador.

      Cree el archivo /var/www/html/info.php que contiene una llamada a la función phpinfo:

      • echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

      Para ver el archivo en un navegador, vaya a http://your_server_ip:8080/info.php. Esto le dará una lista de los ajustes de configuración que PHP está usando. Visualizará un resultado similar a esto:

      phpinfo Servidor API

      phpinfo Variables PHP

      En la parte superior de la página, verifique que Server API diga FPM/FastCGI. A los dos tercios de la página, aproximadamente, la sección PHP Variables le indicará que *SERVER_SOFTWARE *es Apache en Ubuntu. Esto confirma que mod_fastcgi está activo y que Apache está usando PHP-FPM para procesar archivos PHP.

      Paso 5: creación de hosts virtuales para Apache

      Vamos a crear archivos de host virtuales de Apache para los dominios foobar.net y test.io. Para hacerlo, primero, crearemos directorios root de documentos para ambos sitios y colocaremos algunos archivos predeterminados en ellos para poder probar nuestra configuración fácilmente.

      Primero, cree los directorios root de documentos:

      • sudo mkdir -v /var/www/foobar.net /var/www/test.io

      A continuación, cree un archivo de índice para cada sitio:

      • echo "<h1 style='color: green;'>Foo Bar</h1>" | sudo tee /var/www/foobar.net/index.html
      • echo "<h1 style='color: red;'>Test IO</h1>" | sudo tee /var/www/test.io/index.html

      Luego, cree un archivo phpinfo() para cada sitio para que podamos comprobar que PHP esté configurado correctamente.

      • echo "<?php phpinfo(); ?>" | sudo tee /var/www/foobar.net/info.php
      • echo "<?php phpinfo(); ?>" | sudo tee /var/www/test.io/info.php

      Ahora, cree el archivo de host virtual para el dominio foobar.net:

      • sudo nano /etc/apache2/sites-available/foobar.net.conf

      Añada el siguiente código al archivo para definir el host:

      /etc/apache2/sites-available/foobar.net.conf

          <VirtualHost *:8080>
              ServerName foobar.net
              ServerAlias www.foobar.net
              DocumentRoot /var/www/foobar.net
              <Directory /var/www/foobar.net>
                  AllowOverride All
              </Directory>
          </VirtualHost>
      

      La línea AllowOverride All habilita la compatibilidad con .htaccess.

      Estas son solo las directivas más básicas. Para obtener una guía completa sobre la configuración de hosts virtuales en Apache, consulte Cómo configurar hosts virtuales de Apache en Ubuntu 16.04.

      Guarde y cierre el archivo. A continuación, cree una configuración similar para test.io. Primero, cree el archivo:

      • sudo nano /etc/apache2/sites-available/test.io.conf

      A continuación, añada la configuración al archivo:

      /etc/apache2/sites-available/test.io.conf

          <VirtualHost *:8080>
              ServerName test.io
              ServerAlias www.test.io
              DocumentRoot /var/www/test.io
              <Directory /var/www/test.io>
                  AllowOverride All
              </Directory>
          </VirtualHost>
      

      Guarde el archivo y salga del editor.

      Ahora que ambos hosts virtuales de Apache están configurados, habilite los sitios usando el comando a2ensite. Esto crea un enlace simbólico al archivo de host virtual en el directorio sites-enabled:

      • sudo a2ensite foobar.net
      • sudo a2ensite test.io

      Revise Apache para verificar que no haya errores de configuración nuevamente:

      Visualizará el mensaje *Syntax OK *si no hay errores. Si ve algo distinto, revise la configuración y vuelva a intentarlo.

      Vuelva a cargar Apache para aplicar los cambios una vez que su configuración esté libre de errores:

      • sudo systemctl reload apache2

      Para confirmar que los sitios están funcionando, abra http://foobar.net:8080 y http://test.io:8080 en su navegador y verifique que cada sitio muestre su archivo index.html.

      Visualizará los siguientes resultados:

      Página de índice de foobar.net

      Página de índice de test.io

      Además, asegúrese de que PHP está funcionando al acceder a los archivos *info.php *de cada sitio. Visite http://foobar.net:8080/info.php y http://test.io:8080/info.php en su navegador.

      Visualizará la misma lista de especificaciones de configuración de PHP en cada sitio que vio en el Paso 4.

      Ahora, tenemos dos sitios web albergados en Apache en el puerto 8080. Procedamos a configurar Nginx a continuación.

      Paso 6: instalación y configuración de Nginx

      En este paso, instalaremos Nginx y configuraremos los dominios exemple.com y sample.com como hosts virtuales de Nginx. Para obtener una guía completa sobre la configuración de hosts virtuales en Nginx, consulte Cómo configurar bloques de servidor Nginx (hosts virtuales) en Ubuntu 18.04.

      Instale Nginx usando el gestor de paquetes:

      A continuación, elimine el enlace simbólico del host virtual predeterminado, dado que no lo usaremos más:

      • sudo rm /etc/nginx/sites-enabled/default

      Crearemos nuestro propio sitio predeterminado más adelante (example.com).

      Ahora, crearemos hosts virtuales para Nginx usando el mismo procedimiento que usamos para Apache. Primero, cree directorios root de documentos para ambos sitios web:

      • sudo mkdir -v /usr/share/nginx/example.com /usr/share/nginx/sample.org

      Mantendremos los sitios web de Nginx en /usr/share/nginx, que es donde Nginx los quiere por defecto. Podría ponerlos en /var/www/html con los sitios de Apache, pero esta separación puede ayudarlo a asociar sitios con Nginx.

      Tal como hizo con los hosts virtuales de Apache, cree archivos index y phpinfo() para probar después de completar la configuración:

      • echo "<h1 style='color: green;'>Example.com</h1>" | sudo tee /usr/share/nginx/example.com/index.html
      • echo "<h1 style='color: red;'>Sample.org</h1>" | sudo tee /usr/share/nginx/sample.org/index.html
      • echo "<?php phpinfo(); ?>" | sudo tee /usr/share/nginx/example.com/info.php
      • echo "<?php phpinfo(); ?>" | sudo tee /usr/share/nginx/sample.org/info.php

      Ahora, cree un archivo de host virtual para el dominio example.com:

      • sudo nano /etc/nginx/sites-available/example.com

      Nginx llama a áreas server {. . .} de *bloques de servidor *de un archivo de configuración. Cree un bloque de servidor para el host virtual primario, example.com. La directiva de configuración default_server lo convierte en el host virtual predeterminado que procesa solicitudes HTTP que no coinciden con ningún otro host virtual.

      /etc/nginx/sites-available/example.com

      server {
          listen 80 default_server;
      
          root /usr/share/nginx/example.com;
          index index.php index.html index.htm;
      
          server_name example.com www.example.com;
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              fastcgi_pass unix:/run/php/php7.2-fpm.sock;
              include snippets/fastcgi-php.conf;
          }
      }
      

      Guarde y cierre el archivo. Ahora, cree un archivo de host virtual para el segundo dominio de Nginx, sample.org:

      • sudo nano etc/nginx/sites-available/sample.org

      Añada lo siguiente al archivo:

      /etc/nginx/sites-available/sample.org

      server {
          root /usr/share/nginx/sample.org;
          index index.php index.html index.htm;
      
          server_name sample.org www.sample.org;
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              fastcgi_pass unix:/run/php/php7.2-fpm.sock;
              include snippets/fastcgi-php.conf;
          }
      }
      

      Guarde y cierre el archivo.

      A continuación, habilite ambos sitios creando enlaces simbólicos al directorio sites-enabled:

      • sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com
      • sudo ln -s /etc/nginx/sites-available/sample.org /etc/nginx/sites-enabled/sample.org

      A continuación, pruebe la configuración de Nginx para asegurarse de que no haya problemas de configuración:

      Luego, si no hay errores, vuelva a cargar Nginx:

      • sudo systemctl reload nginx

      Ahora, acceda al archivo phpinfo() de sus hosts virtuales de Nginx en un navegador web al visitar los sitios http://example.com/info.php y http://sample.org/info.php. Vuelva a buscar en las secciones de PHP Variables.

      Variables PHP de Nginx

      [“SERVER_SOFTWARE” ]debe decir nginx, lo que indica que Nginx sirvió directamente los archivos.[ “DOCUMENT_ROOT” ]debe apuntar al directorio que creó anteriormente en este paso para cada sitio de Nginx.

      En este momento, ya instalamos Nginx y creamos dos hosts virtuales. A continuación, configuraremos Nginx para las solicitudes de proxy destinadas a dominios albergados en Apache.

      Paso 7: configuración de Nginx para hosts virtuales de Apache.

      Vamos a crear un host virtual de Nginx adicional con múltiples nombres de dominio en las directivas de server_name. Las solicitudes de estos nombres de dominio se redirigirán mediante proxy a Apache.

      Cree un archivo de host virtual de Nginx nuevo para reenviar solicitudes a Apache:

      • sudo nano /etc/nginx/sites-available/apache

      Añada el siguiente bloque de código que especifica los nombres de ambos dominios de host virtuales de Apache y redirige sus solicitudes a Apache mediante proxy. Recuerde usar la dirección IP pública en proxy_pass:

      /etc/nginx/sites-available/apache

      server {
          listen 80;
          server_name foobar.net www.foobar.net test.io www.test.io;
      
          location / {
              proxy_pass http://your_server_ip:8080;
              proxy_set_header Host $host;
              proxy_set_header X-Real-IP $remote_addr;
              proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header X-Forwarded-Proto $scheme;
          }
      }
      

      Guarde el archivo y habilite este host virtual nuevo al crear un enlace simbólico:

      • sudo ln -s /etc/nginx/sites-available/apache /etc/nginx/sites-enabled/apache

      Pruebe la configuración para asegurarse de que no haya errores:

      Si no hay errores, vuelva a cargar Nginx:

      • sudo systemctl reload nginx

      Abra el navegador y acceda a la URL http://foobar.net/info.php. Desplácese hacia abajo a la sección de *PHP Variables *y verifique los valores mostrados.

      phpinfo de Apache a través de Nginx

      Las variables SERVER_SOFTWARE *y *DOCUMENT_ROOT *confirman que Apache gestionó esta solicitud. Nginx añadió las variables *HTTP_X_REAL_IP y HTTP_X_FORWARDED_FOR, y deben mostrar la dirección IP pública del equipo que está utilizando para acceder a la URL.

      Configuramos Nginx correctamente para que redirija solicitudes de dominios específicos a Apache mediante proxy. A continuación, configuremos Apache para establecer la variable REMOTE_ADDR como si estuviera gestionando directamente estas solicitudes.

      Paso 8: instalación y configuración de mod_rpaf

      En este paso, instalará un módulo de Apache llamado mod_rpaf que reescribe los valores de REMOTE_ADDR, HTTPS y HTTP_PORT en función de los valores proporcionados por un proxy inverso. Sin este módulo, algunas aplicaciones de PHP requerirían cambios de código para funcionar sin problemas detrás de un proxy. Este módulo está presente en el repositorio de Ubuntu como libpache2-mod-rpaf, pero está obsoleto y no admite ciertas directivas de configuración. En su lugar, lo instalaremos desde la fuente.

      Instale los paquetes necesarios para crear el módulo:

      • sudo apt install unzip build-essential apache2-dev

      Descargue la última versión estable de GitHub:

      • wget https://github.com/gnif/mod_rpaf/archive/stable.zip

      Extraiga el archivo descargado:

      Cambie al directorio nuevo que contiene los archivos:

      Compile e instale el módulo:

      A continuación, cree un archivo en el directorio mods-available que cargará el módulo rpaf:

      • sudo nano /etc/apache2/mods-available/rpaf.load

      Añada el siguiente código al archivo para cargar el módulo:

      /etc/apache2/mods-available/rpaf.load

      LoadModule rpaf_module /usr/lib/apache2/modules/mod_rpaf.so
      

      Guarde el archivo y salga del editor.

      Cree otro archivo en este directorio llamado rpaf.conf que contendrá las directivas de configuración para mod_rpaf:

      • sudo nano /etc/apache2/mods-available/rpaf.conf

      Añada el siguiente bloque de código para configurar mod_rpaf, asegurándose de especificar la dirección IP de su servidor:

      /etc/apache2/mods-available/rpaf.conf

          <IfModule mod_rpaf.c>
              RPAF_Enable             On
              RPAF_Header             X-Real-Ip
              RPAF_ProxyIPs           your_server_ip 
              RPAF_SetHostName        On
              RPAF_SetHTTPS           On
              RPAF_SetPort            On
          </IfModule>
      

      Esta es una breve descripción de cada directiva. Consulte el archivo README de mod_rpaf para obtener más información.

      • RPAF_Header: el encabezado que se utilizará para la dirección IP real del cliente.
      • RPAF_ProxyIPs: la IP de proxy para ajustar las solicitudes HTTP.
      • RPAF_SetHostName: actualiza el nombre de vhost para que ServerName y ServerAlias funcionen.
      • RPAF_SetHTTPS: establece la variable de entorno HTTPS en función del valor contenido en X-Forwarded-Proto.
      • RPAF_SetPort: establece la variable de entorno SERVER_PORT. Es útil para cuando Apache está detrás de un proxy SSL.

      Guarde rpaf.conf y habilite el módulo:

      Esto crea enlaces simbólicos de los archivos rpaf.load y rpaf.conf en el directorio mods-enabled. Ahora, realice una prueba de configuración:

      Vuelva a cargar Apache si no hay errores:

      • sudo systemctl reload apache2

      Acceda a las páginas phpinfo() http://foobar.net/info.php y http://test.io/info.php en su navegador y verifique la sección PHP Variables. La variable REMOTE_ADDR, ahora, también corresponderá a la de la dirección IP pública de su equipo local.`

      Ahora, configuremos el cifrado TLS/SSL para cada sitio.

      Paso 9: creación de sitios web HTTPS con Let’s Encrypt (Opcional)

      En este paso, configuraremos certificados TLS/SSL para ambos dominios albergados en Apache. Obtendremos los certificados a través de Let’s Encrypt. Nginx admite la terminación SSL, por lo que podemos configurar SSL sin modificar los archivos de configuración de Apache. El módulo mod_rpaf se asegura de que las variables de entorno requeridas estén establecidas en Apache para que las aplicaciones funcionen sin problemas detrás de un proxy inverso SSL.

      Primero, separaremos los bloques server {...} de ambos dominios para que cada uno de ellos pueda tener sus propios certificados SSL. Abra el archivo /etc/nginx/sites-available/apache en su editor:

      • sudo nano /etc/nginx/sites-available/apache

      Modifique el archivo para que se vea de la siguiente manera, con foobar.net y test.io en sus propios bloques server:

      /etc/nginx/sites-available/apache

          server {
              listen 80;
              server_name foobar.net www.foobar.net;
      
              location / {
                  proxy_pass http://your_server_ip:8080;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
                  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                  proxy_set_header X-Forwarded-Proto $scheme;
              }
          }
          server {
              listen 80;
              server_name test.io www.test.io;
      
              location / {
                  proxy_pass http://your_server_ip:8080;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
                  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                  proxy_set_header X-Forwarded-Proto $scheme;
              }
          }
      

      Utilizaremos Certbot para generar nuestros certificados TLS/SSL. Su complemento de Nginx se encargará de reconfigurar Nginx y volver a cargar la configuración cuando sea necesario.

      Primero, añada el repositorio oficial de Certbot:

      • sudo add-apt-repository ppa:certbot/certbot

      Presione ENTER cuando se le indique para confirmar que desea añadir el repositorio nuevo. A continuación, actualice la lista de paquetes para obtener la información de paquetes del repositorio nuevo:

      A continuación, instale el paquete Nginx de Certbot con apt:

      • sudo apt install python-certbot-nginx

      Una vez instalado, utilice el comando certbot para generar los certificados para foobar.net y www.foobar.net:

      • sudo certbot --nginx -d foobar.net -d www.foobar.net

      Este comando le indica a Certbot que use el complemento nginx, utilizando -d para especificar los nombres para los que deseamos que el certificado sea válido.

      Si es la primera vez que ejecuta certbot, se le pedirá que ingrese una dirección de correo electrónico y que acepte las condiciones de servicio. A continuación, certbot se comunicará con el servidor de Let’s Encrypt, y, luego, realizará una comprobación para verificar que usted controle el dominio para el que está solicitando un certificado.

      Luego, Certbot le preguntará cómo desea configurar sus ajustes de HTTPS:

      Output

      Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access. ------------------------------------------------------------------------------- 1: No redirect - Make no further changes to the webserver configuration. 2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for new sites, or if you're confident your site works on HTTPS. You can undo this change by editing your web server's configuration. ------------------------------------------------------------------------------- Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

      Seleccione su elección y presione ENTER. La configuración se actualizará y Nginx se volverá a cargar para recopilar los ajustes nuevos.

      Ahora, ejecute el comando para el segundo dominio:

      • sudo certbot --nginx -d test.io -d www.test.io

      Acceda a uno de los dominios de Apache en su navegador utilizando https:// prefix; visite https://foobar.net/info.php y verá esto:

      phpinfo ssl

      Busque en la sección PHP Variables. La variable SERVER_PORT se estableció en 443 y HTTPS, en on, como si se hubiese accedido a Apache directamente desde HTTPS. Con estas variables establecidas, las aplicaciones de PHP no requieren una configuración especial para funcionar detrás de un proxy inverso.

      Ahora, desactive el acceso directo a Apache.

      Paso 10: bloqueo del acceso directo a Apache (opcional)

      Dado que Apache está escuchando en el puerto 8080, en la dirección IP pública, es accesible para todos. Puede bloquearse al utilizar el siguiente comando IPtables en su conjunto de reglas de firewall.

      • sudo iptables -I INPUT -p tcp --dport 8080 ! -s your_server_ip -j REJECT --reject-with tcp-reset

      Asegúrese de usar la dirección IP de su servidor en lugar del ejemplo en rojo. Una vez que el puerto 8080 esté bloqueado en su firewall, compruebe que sea imposible acceder a Apache desde este. Abra su navegador web e intente acceder a uno de los nombres de dominio de Apache en el puerto 8080. Por ejemplo, http://example.com:8080

      El navegador debería mostrar el mensaje de error “Unable to connect” o “Webpage is not available”. Con la opción IPtables tcp-reset implementada, una persona externa no vería ninguna diferencia entre el puerto 8080 y un puerto que no tiene ningún servicio.

      Nota: por defecto, las reglas de IPtables no se mantienen al reiniciar el sistema. Hay varias formas de preservar las reglas de IPtables, pero lo más fácil es usar iptables-persistent en el repositorio de Ubuntu. Estudie este artículo para obtener más información sobre cómo configurar IPTables.

      Ahora, configuremos Nginx para servir archivos estáticos para los sitios de Apache.

      Paso 11: servir archivos estáticos utilizando Nginx (opcional)

      Cuando Nginx redirige solicitudes de dominios de Apache mediante proxy, envía cada solicitud de archivo de esos dominios a Apache. Nginx es más rápido que Apache en servir archivos estáticos como imágenes, JavaScript y hojas de estilo. Por lo tanto, procederemos a configurar el archivo de host virtual apache de Nginx para servir directamente archivos estáticos, pero enviar solicitudes de PHP a Apache.

      Abra el archivo /etc/nginx/sites-available/apache en su editor:

      • sudo nano /etc/nginx/sites-available/apache

      Deberá añadir dos bloques de location adicionales a cada bloque de servidor, y modificar las secciones de location existentes. Además, deberá indicarle a Nginx dónde encontrar los archivos estáticos de cada sitio.

      Si decidió no usar certificados SSL y TLS, modifique su archivo para que se vea así:

      /etc/nginx/sites-available/apache

      server {
          listen 80;
          server_name test.io www.test.io;
          root /var/www/test.io;
          index index.php index.htm index.html;
      
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              proxy_pass http://your_server_ip:8080;
              proxy_set_header Host $host;
              proxy_set_header X-Real-IP $remote_addr;
              proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header X-Forwarded-Proto $scheme;
          }
      
          location ~ /.ht {
              deny all;
          }
      }
      
      server {
          listen 80;
          server_name foobar.net www.foobar.net;
          root /var/www/foobar.net;
          index index.php index.htm index.html;
      
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              proxy_pass http://your_ip_address:8080;
              proxy_set_header Host $host;
              proxy_set_header X-Real-IP $remote_addr;
              proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header X-Forwarded-Proto $scheme;
          }
      
          location ~ /.ht {
              deny all;
          }
      }
      

      Si también desea que esté disponible HTTPS, utilice la siguiente configuración en su lugar:

      /etc/nginx/sites-available/apache

      server {
          listen 80;
          server_name test.io www.test.io;
          root /var/www/test.io;
          index index.php index.htm index.html;
      
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              proxy_pass http://your_server_ip:8080;
              proxy_set_header Host $host;
              proxy_set_header X-Real-IP $remote_addr;
              proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header X-Forwarded-Proto $scheme;
          }
      
          location ~ /.ht {
              deny all;
          }
      
          listen 443 ssl;
          ssl_certificate /etc/letsencrypt/live/test.io/fullchain.pem;
          ssl_certificate_key /etc/letsencrypt/live/test.io/privkey.pem;
          include /etc/letsencrypt/options-ssl-nginx.conf;
          ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
      }
      
      server {
          listen 80;
          server_name foobar.net www.foobar.net;
          root /var/www/foobar.net;
          index index.php index.htm index.html;
      
          location / {
              try_files $uri $uri/ /index.php;
          }
      
          location ~ .php$ {
              proxy_pass http://your_ip_address:8080;
              proxy_set_header Host $host;
              proxy_set_header X-Real-IP $remote_addr;
              proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header X-Forwarded-Proto $scheme;
          }
      
          location ~ /.ht {
              deny all;
          }
      
          listen 443 ssl;
          ssl_certificate /etc/letsencrypt/live/foobar.net/fullchain.pem;
          ssl_certificate_key /etc/letsencrypt/live/foobar.net/privkey.pem;
          include /etc/letsencrypt/options-ssl-nginx.conf;
          ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
      }
      

      La directiva try_files hace que Nginx busque archivos en el root de documentos y los sirva directamente. Si el archivo tiene una extensión .php, la solicitud se transmite a Apache. Aunque el archivo no se encuentre en el root de documentos, la solicitud se transmite a Apache para que características de la aplicación, como permalinks, funcionen sin problemas.

      Advertencia: la directiva location ~ /.ht es muy importante; impide que Nginx sirva los contenidos de los archivos de configuración de Apache, como.htaccess y .htpasswd, que contienen información sensible.

      Guarde el archivo y realice una prueba de configuración:

      Vuelva a cargar Nginx si la prueba resulta exitosa:

      • sudo service nginx reload

      Para verificar que todo funcione, puede examinar los archivos de registro de Apache en /var/log/apache2 y consultar las solicitudes GET de los archivos info.php de test.io y foobar.net. Utilice el comando tail para ver las últimas líneas del archivo, y use el botón -f para ver si hay cambios en el archivo:

      • sudo tail -f /var/log/apache2/other_vhosts_access.log

      Ahora, visite http://test.io/info.php en su navegador y, luego, verifique la salida del registro. Verá que Apache está contestando:

      Output

      test.io:80 your_server_ip - - [01/Jul/2016:18:18:34 -0400] "GET /info.php HTTP/1.0" 200 20414 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.111 Safari/537.36"

      A continuación, visite la página index.html de cada sitio y no verá entradas de registro de Apache. Nginx las está sirviendo.

      Cuando haya terminado de observar el archivo de registro, presione CTRL+C para dejar de seguirlo.

      Con esta configuración, Apache no podrá restringir el acceso a archivos estáticos. El control de acceso de los archivos estáticos deberá configurarse en el archivo de host virtual apache de Nginx, pero eso va más allá del alcance de este tutorial.

      Conclusión

      Ahora, tiene un servidor Ubuntu con Nginx sirviendo example.com y sample.org, y Apache sirviendo foobar.net y test.io. Aunque Nginx está actuando como proxy inverso de Apache, el servicio de proxy de Nginx es transparente y las conexiones a los dominios de Apache parecen servirse directamente desde Apache. Puede usar este método para servir sitios seguros y estáticos.



      Source link

      Set Up a Reverse Proxy in an LXD Container to Host Multiple Websites


      Updated by Linode Contributed by Simos Xenitellis

      Introduction

      LXD (pronounced “Lex-Dee”) is a system container manager build on top of Linux Containers (LXC) supported by Canonical. The goal of LXD is to provide an experience similar to a virtual machine but through containerization rather than hardware virtualization. Compared to Docker for delivering applications, LXD offers nearly full operating-system functionality with additional features such as snapshots, live migrations, and storage management.

      A reverse proxy is a server that sits between internal applications and external clients, forwarding client requests to the appropriate server. While many common applications, such as Node.js, are able to function as servers on their own, they may lack a number of advanced load balancing, security, and acceleration features.

      This guide explains the creation of a reverse proxy in an LXD container in order to host multiple websites, each in their own additional containers. You will utilize NGINX and Apache web servers, while also relying on NGINX as a reverse proxy.

      Please refer to the following diagram to understand the reverse proxy created in this guide.

      Diagram of LXD reverse proxy and web servers

      In this guide you will:

      Note

      For simplicity, the term container is used throughout this guide to describe the LXD system containers.

      Before You Begin

      1. Complete A Beginner’s Guide to LXD: Setting Up an Apache Web Server In a Container. The guide instructs you to create a container called web with the Apache web server for testing purposes. Remove this container by running the following commands.

        lxc stop web
        lxc delete web
        

        Note

      2. This guide will use the hostnames apache1.example.com and nginx1.example.com for the two example websites. Replace these names with hostnames you own and setup their DNS entries to point them to the IP address of the server you created. For help with DNS see our DNS Manager Guide.

      Creating the Containers

      1. Create two containers called apache1 and nginx1, one with the Apache web server and another with the NGINX web server, respectively. For any additional websites, you may create new containers with your chosen web server software.

        lxc launch ubuntu:18.04 apache1
        lxc launch ubuntu:18.04 nginx1
        
      2. Create the proxy container for the reverse proxy.

        lxc launch ubuntu:18.04 proxy
        
      3. List the containers with the list command.

        lxc list
        
      4. The output will look similar to the following.

          
        +---------+---------+---------------------+-----------------------------------------------+------------+-----------+
        |  NAME   |  STATE  |        IPV4         |                     IPV6                      |    TYPE    | SNAPSHOTS |
        +---------+---------+---------------------+-----------------------------------------------+------------+-----------+
        | apache1 | RUNNING | 10.10.10.204 (eth0) | fd42:67a4:b462:6ae2:216:3eff:fe01:1a4e (eth0) | PERSISTENT |           |
        +---------+---------+---------------------+-----------------------------------------------+------------+-----------+
        | nginx1  | RUNNING | 10.10.10.251 (eth0) | fd42:67a4:b462:6ae2:216:3eff:febd:67e3 (eth0) | PERSISTENT |           |
        +---------+---------+---------------------+-----------------------------------------------+------------+-----------+
        | proxy   | RUNNING | 10.10.10.28 (eth0)  | fd42:67a4:b462:6ae2:216:3eff:fe00:252e (eth0) | PERSISTENT |           |
        +---------+---------+---------------------+-----------------------------------------------+------------+-----------+
        
        

        There are three containers, all in the RUNNING state – each with their own private IP address. Take note of the IP addresses (both IPv4 and IPv6) for the container proxy. You will need them to configure the proxy container in a later section.

        Now that the containers have been created, the following steps will detail how to set up the web server software in the apache1 and nginx1 containers, and the proxy container so that the web servers are accessible from the internet.

      Configuring the Apache Web Server Container

      When using a reverse proxy in front of a web server, the web server does not know the IP addresses of visitors. The web server only sees the IP address of the reverse proxy. However, each web server has a way to identify the real remote IP address of a visitor. For Apache, this is performed with the Remote IP Apache module. For the module to work, the reverse proxy must be configured to pass the remote IP address’ information.

      1. Start a shell in the apache1 container.

        lxc exec apache1 -- sudo --user ubuntu --login
        
      2. Update the package list in the apache1 container.

        sudo apt update
        
      3. Install the package apache2 in the container.

        sudo apt install -y apache2
        
      4. Create the file /etc/apache2/conf-available/remoteip.conf.

        remoteip.conf
        1
        2
        
        RemoteIPHeader X-Real-IP
        RemoteIPTrustedProxy 10.10.10.28 fd42:67a4:b462:6ae2:216:3eff:fe00:252e

        You can use the nano text editor by running the command sudo nano /etc/apache2/conf-available/remoteip.conf. Note, these are the IP addresses of the proxy container shown earlier, for both IPv4 and IPv6. Replace these with the IPs from your lxc list output.

        Note

        Instead of specifying the IP addresses, you can also use the hostname proxy.lxd. However, the RemoteIP Apache module is peculiar when using the hostname and will use only one of the two IP addresses (either IPv4 or IPv6), which means the Apache web server will not know the real source IP address for some connections. By listing explicitly both IPv4 and IPv6 addresses, you can be certain that RemoteIP will successfully accept the source IP information from all connections of the reverse proxy.

      5. Enable the new remoteip.conf configuration.

        sudo a2enconf remoteip
        
          
        Enabling conf remoteip.
        To activate the new configuration, you need to run:
        systemctl reload apache2
        
        
      6. Enable the remoteip Apache module.

        sudo a2enmod remoteip
        
          
        Enabling module remoteip.
        To activate the new configuration, you need to run:
        systemctl restart apache2
        
        
      7. Edit the default web page for Apache to make a reference that it runs inside a LXD container.

        sudo nano /var/www/html/index.html
        

        Change the line “It works!” (line number 224) to “It works inside a LXD container!” Save and exit.

      8. Restart the Apache web server.

        sudo systemctl reload apache2
        
      9. Exit back to the host.

        exit
        

      You have created and configured the Apache web server, but the server is not yet accessible from the Internet. It will become accessible after you configure the proxy container in a later section.

      Creating the NGINX Web Server Container

      Like Apache, NGINX does not know the IP addresses of visitors when using a reverse proxy in front of a web server. It only sees the IP address of the reverse proxy instead. Each NGINX web server software can identify the real remote IP address of a visitor with the Real IP module. For the module to work, the reverse proxy must be configured accordingly to pass the information regarding the remote IP addresses.

      1. Start a shell in the nginx1 container.

        lxc exec nginx1 -- sudo --user ubuntu --login
        
      2. Update the package list in the nginx1 container.

        sudo apt update
        
      3. Install NGINX in the container.

        sudo apt install -y nginx
        
      4. Create the file /etc/nginx/conf.d/real-ip.conf.

        real-ip.conf
        1
        2
        
        real_ip_header    X-Real-IP;
        set_real_ip_from  proxy.lxd;

        You can use the nano text editor by running the command sudo nano /etc/nginx/conf.d/real-ip.conf.

        Note

        You have specified the hostname of the reverse proxy, proxy.lxd. Each LXD container gets automatically a hostname, which is the name of the container plus the suffix .lxd. By specifying the set_real_ip_from field with proxy.lxd, you are instructing the NGINX web server to accept the real IP address information for each connection, as long as that connection originates from proxy.lxd. The real IP address information will be found in the HTTP header X-Real-IP in each connection.

      5. Edit the default web page for NGINX to make a reference that it runs inside a LXD container.

        sudo nano /var/www/html/index.nginx-debian.html
        

        Change the line “Welcome to nginx!” (line number 14) to “Welcome to nginx running in a LXD system container!”. Save and exit.

      6. Restart the NGINX web server.

        sudo systemctl reload nginx
        
      7. Exit back to the host.

        exit
        

      You have created and configured the NGINX web server, but the server is not accessible yet from the Internet. It will become accessible after you configure the proxy container in the next section.

      Setting up the Reverse Proxy

      In this section you will configure the container proxy. You will install NGINX and set it up as a reverse proxy, then add the appropriate LXD proxy device in order to expose both ports 80 and 443 to the internet.

      1. Add LXD proxy devices to redirect connections from the internet to ports 80 (HTTP) and 443 (HTTPS) on the server to the respective ports at the proxy container.

        lxc config device add proxy myport80 proxy listen=tcp:0.0.0.0:80 connect=tcp:127.0.0.1:80 proxy_protocol=true
        lxc config device add proxy myport443 proxy listen=tcp:0.0.0.0:443 connect=tcp:127.0.0.1:443 proxy_protocol=true
        
          
        Device myport80 added to proxy
        Device myport443 added to proxy
        
        

        The lxc config device add command takes as arguments:

        Argument Explanation
        proxy The name of the container.
        myport80 A name for this proxy device.
        proxy The type of the LXD device (LXD proxy device).
        listen=tcp:0.0.0.0:80 The proxy device will listen on the host (default) on port 80, protocol TCP, on all interfaces.
        connect=tcp:127.0.0.1:80 The proxy device will connect to the container on port 80, protocol TCP, on the loopback interface. In previous versions of LXD you could have specified localhost here. However, in LXD 3.13 or newer, you can only specify IP addresses.
        proxy_protocol=true Request to enable the PROXY protocol so that the reverse proxy will get the originating IP address from the proxy device.

        Note

        If you want to remove a proxy device, use lxc config device remove. If you want to remove the above device myport80, run the following command:

        lxc config device remove proxy myport80
        

        Where proxy is the name of the container, and myport80 is the name of the device.

      2. Start a shell in the proxy container.

        lxc exec proxy -- sudo --user ubuntu --login
        
      3. Update the package list.

        sudo apt update
        
      4. Install NGINX in the container.

        sudo apt install -y nginx
        
      5. Logout from the container.

        logout
        

      Direct Traffic to the Apache Web Server From the Reverse Proxy

      The reverse proxy container is running and the NGINX package has been installed. To work as a reverse proxy, add the appropriate website configuration so that NGINX can identify (with server_name below) the appropriate hostname, and then pass (with proxy_pass below) the connection to the appropriate LXD container.

      1. Start a shell in the proxy container.

        lxc exec proxy -- sudo --user ubuntu --login
        
      2. Create the file apache1.example.com in /etc/nginx/sites-available/ for the configuration of your first website.

        apache1.example.com
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        
        server {
                listen 80 proxy_protocol;
                listen [::]:80 proxy_protocol;
        
                server_name apache1.example.com;
        
                location / {
                        proxy_set_header Host $host;
                        proxy_set_header X-Real-IP $remote_addr;
                        proxy_pass http://apache1.lxd;
                }
        
                real_ip_header proxy_protocol;
                set_real_ip_from 127.0.0.1;
        }

        You can run sudo nano /etc/nginx/sites-available/apache1.example.com to open up a text editor and add the configuration. Note, in this case you only need to edit the server_name to be the hostname of the website.

      3. Enable the website.

        sudo ln -s /etc/nginx/sites-available/apache1.example.com /etc/nginx/sites-enabled/
        
      4. Restart the NGINX reverse proxy. By restarting the service, NGINX will read and apply the new site instructions just added to /etc/nginx/sites-enabled.

        sudo systemctl reload nginx
        
      5. Exit the proxy container and return back to the host.

        logout
        
      6. From your local computer, visit the URL of your website with your web browser. You should see the default Apache page:

        Web page of Apache server running in a container

        Note

        If you look at the Apache access.log file (default file /var/log/apache2/access.log), it will still show the private IP address of the proxy container instead of the real IP address. This issue is specific to the Apache web server and has to do with how the server prints the logs. Other software on the web server will be able to use the real IP. To fix this through the Apache logs, see the section Troubleshooting.

      Direct Traffic to the NGINX Web Server From the Reverse Proxy

      The reverse proxy container is running and the NGINX package has been installed. To work as a reverse proxy, you will add the appropriate website configuration so NGINX can identify (with server_name below) the appropriate hostname, and then pass (with proxy_pass below) the connection to the appropriate LXD container with the actual web server software.

      1. Start a shell in the proxy container.

        lxc exec proxy -- sudo --user ubuntu --login
        
      2. Create the file nginx1.example.com in /etc/nginx/sites-available/ for the configuration of your second website.

        nginx1.example.com
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        
        server {
                listen 80 proxy_protocol;
                listen [::]:80 proxy_protocol;
        
                server_name nginx1.example.com;
        
                location / {
                        proxy_set_header Host $host;
                        proxy_set_header X-Real-IP $remote_addr;
                        proxy_pass http://nginx1.lxd;
                }
        
                real_ip_header proxy_protocol;
                set_real_ip_from 127.0.0.1;
        }

        You can run sudo nano /etc/nginx/sites-available/nginx1.example.com to create the configuration. Note, you only need to edit the fields server_name to be the hostname of the website.

      3. Enable the website.

        sudo ln -s /etc/nginx/sites-available/nginx1.example.com /etc/nginx/sites-enabled/
        
      4. Restart the NGINX reverse proxy service.

        sudo systemctl reload nginx
        
      5. Exit the proxy container and return back to the host.

        logout
        
      6. From your local computer, visit the URL of your website with your web browser. You should see the following default NGINX page.

        Web page of the nginx server running in a container

      Adding Support for HTTPS with Let’s Encrypt

      1. Start a shell in the proxy container.

        lxc exec proxy -- sudo --user ubuntu --login
        
      2. Add the repository ppa:certbot/certbot by running the following command.

        sudo add-apt-repository ppa:certbot/certbot
        
      3. Output will look similar to the following.

          
              This is the PPA for packages prepared by Debian Let's Encrypt Team and backported for Ubuntu(s).
              More info: https://launchpad.net/~certbot/+archive/ubuntu/certbot
             Press [ENTER] to continue or Ctrl-c to cancel adding it.
        
             Get:1 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]
             ...
             Fetched 3360 kB in 2s (2018 kB/s)
             Reading package lists... Done
        
        
      4. Install the following two packages to a) support the creation of Let’s Encrypt certificates; and b) auto-configure the NGINX reverse proxy to use Let’s Encrypt certificates. The packages are pulled from the newly-created repository.

        sudo apt-get install certbot python-certbot-nginx
        

        Note

        This configures the reverse proxy to also act as a TLS Termination Proxy. Any HTTPS configuration is only found in the proxy container. By doing so, it is not necessary to perform any tasks inside the web server containers relating to certificates and Let’s Encrypt.

      5. Run certbot as root with the --nginx parameter in order to perform the auto-configuration of Let’s Encrypt for the first website. You will be asked to supply a valid email address for urgent renewal and security notices. You will then be asked to accept the Terms of Service and whether you would like to be contacted by the Electronic Frontier Foundation in the future. Next, you will provide the website for which you are activating HTTPS. Finally, you can choose to set up a facility that automatically redirects HTTP connections to HTTPS connections.

        sudo certbot --nginx
        
          
        Saving debug log to /var/log/letsencrypt/letsencrypt.log
        Plugins selected: Authenticator nginx, Installer nginx
        Enter email address (used for urgent renewal and security notices) (Enter 'c' to
        cancel): myemail@example.com
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Please read the Terms of Service at
        https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
        agree in order to register with the ACME server at
        https://acme-v02.api.letsencrypt.org/directory
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        (A)gree/(C)ancel: A
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Would you be willing to share your email address with the Electronic Frontier
        Foundation, a founding partner of the Let's Encrypt project and the non-profit
        organization that develops Certbot? We'd like to send you email about our work
        encrypting the web, EFF news, campaigns, and ways to support digital freedom.
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        (Y)es/(N)o: N
        
        Which names would you like to activate HTTPS for?
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        1: apache1.example.com
        2: nginx1.example.com
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Select the appropriate numbers separated by commas and/or spaces, or leave input
        blank to select all options shown (Enter 'c' to cancel): 1
        Obtaining a new certificate
        Performing the following challenges:
        http-01 challenge for apache1.example.com
        Waiting for verification...
        Cleaning up challenges
        Deploying Certificate to VirtualHost /etc/nginx/sites-enabled/apache1.example.com
        
        Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        1: No redirect - Make no further changes to the webserver configuration.
        2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
        new sites, or if you're confident your site works on HTTPS. You can undo this
        change by editing your web server's configuration.
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
        Redirecting all traffic on port 80 to ssl in /etc/nginx/sites-enabled/apache1.example.com
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Congratulations! You have successfully enabled https://apache1.example.com
        
        You should test your configuration at:
        https://www.ssllabs.com/ssltest/analyze.html?d=apache1.example.com
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        
        IMPORTANT NOTES:
         - Congratulations! Your certificate and chain have been saved at:
           /etc/letsencrypt/live/apache1.example.com/fullchain.pem
           Your key file has been saved at:
           /etc/letsencrypt/live/apache1.example.com/privkey.pem
           Your cert will expire on 2019-10-07. To obtain a new or tweaked
           version of this certificate in the future, simply run certbot again
           with the "certonly" option. To non-interactively renew *all* of
           your certificates, run "certbot renew"
         - Your account credentials have been saved in your Certbot
           configuration directory at /etc/letsencrypt. You should make a
           secure backup of this folder now. This configuration directory will
           also contain certificates and private keys obtained by Certbot so
           making regular backups of this folder is ideal.
         - If you like Certbot, please consider supporting our work by:
        
           Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
           Donating to EFF:                    https://eff.org/donate-le
        
        
      6. Run certbot as root with the --nginx parameter in order to perform the auto-configuration of Let’s Encrypt for the second website. This is the second time we run certbot, therefore we are asked directly to select the website to configure.

        sudo certbot --nginx
        
          
        Saving debug log to /var/log/letsencrypt/letsencrypt.log
        Plugins selected: Authenticator nginx, Installer nginx
        
        Which names would you like to activate HTTPS for?
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        1: apache1.example.com
        2: nginx1.example.com
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Select the appropriate numbers separated by commas and/or spaces, or leave input
        blank to select all options shown (Enter 'c' to cancel): 2
        Obtaining a new certificate
        Performing the following challenges:
        http-01 challenge for nginx1.example.com
        Waiting for verification...
        Cleaning up challenges
        Deploying Certificate to VirtualHost /etc/nginx/sites-enabled/nginx1.example.com
        
        Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        1: No redirect - Make no further changes to the webserver configuration.
        2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
        new sites, or if you're confident your site works on HTTPS. You can undo this
        change by editing your web server's configuration.
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
        Redirecting all traffic on port 80 to ssl in /etc/nginx/sites-enabled/nginx1.example.com
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Congratulations! You have successfully enabled https://nginx1.example.com
        
        You should test your configuration at:
        https://www.ssllabs.com/ssltest/analyze.html?d=nginx1.example.com
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        
        IMPORTANT NOTES:
         - Congratulations! Your certificate and chain have been saved at:
           /etc/letsencrypt/live/nginx1.example.com/fullchain.pem
           Your key file has been saved at:
           /etc/letsencrypt/live/nginx1.example.com/privkey.pem
           Your cert will expire on 2019-10-07. To obtain a new or tweaked
           version of this certificate in the future, simply run certbot again
           with the "certonly" option. To non-interactively renew *all* of
           your certificates, run "certbot renew"
         - If you like Certbot, please consider supporting our work by:
        
           Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
           Donating to EFF:                    https://eff.org/donate-le
        
        
      7. After adding all websites, perform a dry run in order to test the renewal of the certificates. Check that all websites are updating successfully to ensure the automated facility will update the certificates without further effort.

        sudo certbot renew --dry-run
        
          
        Saving debug log to /var/log/letsencrypt/letsencrypt.log
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Processing /etc/letsencrypt/renewal/apache1.example.com.conf
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Cert not due for renewal, but simulating renewal for dry run
        Plugins selected: Authenticator nginx, Installer nginx
        Renewing an existing certificate
        Performing the following challenges:
        http-01 challenge for apache1.example.com
        Waiting for verification...
        Cleaning up challenges
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        new certificate deployed with reload of nginx server; fullchain is
        /etc/letsencrypt/live/apache1.example.com/fullchain.pem
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Processing /etc/letsencrypt/renewal/nginx1.example.com.conf
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        Cert not due for renewal, but simulating renewal for dry run
        Plugins selected: Authenticator nginx, Installer nginx
        Renewing an existing certificate
        Performing the following challenges:
        http-01 challenge for nginx1.example.com
        Waiting for verification...
        Cleaning up challenges
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        new certificate deployed with reload of nginx server; fullchain is
        /etc/letsencrypt/live/nginx1.example.com/fullchain.pem
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        ** DRY RUN: simulating 'certbot renew' close to cert expiry
        **          (The test certificates below have not been saved.)
        
        Congratulations, all renewals succeeded. The following certs have been renewed:
          /etc/letsencrypt/live/apache1.example.com/fullchain.pem (success)
          /etc/letsencrypt/live/nginx1.example.com/fullchain.pem (success)
        ** DRY RUN: simulating 'certbot renew' close to cert expiry
        **          (The test certificates above have not been saved.)
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        
        IMPORTANT NOTES:
         - Your account credentials have been saved in your Certbot
           configuration directory at /etc/letsencrypt. You should make a
           secure backup of this folder now. This configuration directory will
           also contain certificates and private keys obtained by Certbot so
           making regular backups of this folder is ideal.
        
        

        Note

        The certbot package adds a systemd timer in order to activate the automated renewal of Let’s Encrypt certificates. You can view the details of this timer by running systemctl list-timers.

      8. The certbot tool edits and changes the NGINX configuration files of your websites. In doing so, certbot does not obey initial listen directive (listen 80 proxy_protocol;) and does not add the proxy_protocol parameter to the newly added listen 443 ssl; lines. You must edit the configuration files for each website and append “proxy_protocol” to each “listen 443 ssl;” line.

        sudo nano /etc/nginx/sites-enabled/apache1.example.com
        sudo nano /etc/nginx/sites-enabled/nginx1.example.com
        
          
        listen 443 ssl proxy_protocol; # managed by Certbot
        listen [::]:443 ssl proxy_protocol; # managed by Certbot
        
        

        Note

        Each website configuration file has two pairs of listen directives: HTTP and HTTPS, respectively. The first is the original pair for HTTP that was added in a previous section. The second pair was added by certbot for HTTPS. These are pairs because they they cover both IPv4 and IPv6. The notation [::] refers to IPv6. When adding the parameter proxy_protocol, add it before the ; on each line as shown above.

      9. Restart NGINX.

        sudo systemctl restart nginx
        

      Troubleshooting

      Browser Error “SSL_ERROR_RX_RECORD_TOO_LONG”

      You have configured Certbot and created the appropriate Let’s Encrypt configuration for each website. But when you access the website from your browser, you get the following error.

        
      Secure Connection Failed
      
      An error occurred during a connection to apache1.example.com. SSL received a record that exceeded the maximum permissible length. Error code: SSL_ERROR_RX_RECORD_TOO_LONG
      
          The page you are trying to view cannot be shown because the authenticity of the received data could not be verified.
          Please contact the website owners to inform them of this problem.
      
      

      This error is caused when the NGINX reverse proxy in the proxy container does not have the proxy_protocol parameter in the listen 443 directives. Without the parameter, the reverse proxy does not consume the PROXY protocol information before it performs the HTTPS work. It mistakenly passes the PROXY protocol information to the HTTPS module, hence the record too long error.

      Follow the instructions in the previous section and add proxy_protocol to all listen 443 directives. Finally, restart NGINX.

      Error “Unable to connect” or “This site can’t be reached”

      When you attempt to connect to the website from your local computer and receive Unable to connect or This site can’t be reached errors, it is likely the proxy devices have not been configured.

      Run the following command on the host to verify whether LXD is listening and is able to accept connections to ports 80 (HTTP) and 443 (HTTPS).

      sudo ss -ltp '( sport = :http || sport = :https )'
      

      Note

      The ss command is similar to netstat and lsof. It shows information about network connections. In this case, we use it to verify whether there is a service on ports 80 and 443, and which service it is. * -l, to display the listening sockets, * -t, to display only TCP sockets, * -p, to show which processes use those sockets, * ( sport = :http || sport = :https ), to show only ports 80 and 443 (HTTP and HTTPS, respectively).

      In the following output we can verify that both ports 80 and 443 (HTTP and HTTPS, respectively) are in the LISTEN state. In the last column we verify that the process listening is lxd itself.

        
      State     Recv-Q  Send-Q   Local Address:Port   Peer Address:Port
      LISTEN    0       128                  *:http              *:*       users:(("lxd",pid=1301,fd=7),("lxd",pid=1301,fd=5))
      LISTEN    0       128                  *:https             *:*       users:(("lxd",pid=1349,fd=7),("lxd",pid=1349,fd=5))
      
      

      If you see a process listed other than lxd, stop that service and restart the proxy container. By restarting the proxy container, LXD will apply the proxy devices again.

      The Apache access.log Shows the IP Address of the Proxy Container

      You have set up the apache1 container and verified that it is accessible from the internet. But the logs at /var/log/apache2/access.log still show the private IP address of the proxy container, either the private IPv4 (10.x.x.x) or the private IPv6 addresses. What went wrong?

      The default log formats for printing access logs in Apache only print the IP address of the host of the last hop (i.e. the proxy server). This is the %h format specifier as shown below.

        
      LogFormat "%v:%p %h %l %u %t "%r" %>s %O "%{Referer}i" "%{User-Agent}i"" vhost_combined
      LogFormat "%h %l %u %t "%r" %>s %O "%{Referer}i" "%{User-Agent}i"" combined
      LogFormat "%h %l %u %t "%r" %>s %O" common
      
      

      The %h must be manually replaced with the %a format specifier, which prints the value as returned by the real RemoteIP Apache module.

        
      LogFormat "%v:%p %a %l %u %t "%r" %>s %O "%{Referer}i" "%{User-Agent}i"" vhost_combined
      LogFormat "%a %l %u %t "%r" %>s %O "%{Referer}i" "%{User-Agent}i"" combined
      LogFormat "%a %l %u %t "%r" %>s %O" common
      
      
      1. Run the following command in the apache1 container to edit the configuration file httpd.conf and perform the change from %h to %a.

        sudo nano /etc/apache2/apache2.conf
        
      2. Reload the Apache web server service.

        sudo systemctl reload apache2
        

      Next Steps

      You have set up a reverse proxy to host many websites on the same server and installed each website in a separate container. You can install static or dynamic websites in the containers. For dynamic websites, you may need additional configuration; check the respective documentation for setup using a reverse proxy. In addition, you may also use NGINX as a reverse proxy for non-HTTP(S) services.

      More Information

      You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

      Find answers, ask questions, and help others.

      This guide is published under a CC BY-ND 4.0 license.



      Source link

      Como Usar o Traefik como um Proxy Reverso para Containers do Docker no CentOS 7


      O autor selecionou o Girls Who Code para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Docker pode ser uma maneira eficiente de executar aplicativos web em produção, mas você pode querer executar vários aplicativos no mesmo host do Docker. Nesta situação, você precisará configurar um proxy reverso, já que você só deseja expor as portas 80 e 443 para o resto do mundo.

      O Traefik é um proxy reverso que reconhece o Docker e inclui seu próprio painel de monitoramento ou dashboard. Neste tutorial, você usará o Traefik para rotear solicitações para dois containers de aplicação web diferentes: um container WordPress e um container Adminer, cada um falando com um banco de dados MySQL. Você irá configurar o Traefik para servir tudo através de HTTPS utilizando o Let’s Encrypt.

      Pré-requisitos

      Para acompanhar este tutorial, você vai precisar do seguinte:

      Passo 1 — Configurando e Executando o Traefik

      O projeto do Traefik tem uma imagem Docker oficial, portanto vamos utilizá-la para executar o Traefik em um container Docker.

      Mas antes de colocarmos o nosso container Traefik em funcionamento, precisamos criar um arquivo de configuração e configurar uma senha criptografada para que possamos acessar o painel de monitoramento.

      Usaremos o utilitário htpasswd para criar essa senha criptografada. Primeiro, instale o utilitário, que está incluído no pacote httpd-tools:

      • sudo yum install -y httpd-tools

      Em seguida, gere a senha com o htpasswd. Substitua senha_segura pela senha que você gostaria de usar para o usuário admin do Traefik:

      • htpasswd -nb admin senha_segura

      A saída do programa ficará assim:

      Output

      admin:$apr1$kEG/8JKj$yEXj8vKO7HDvkUMI/SbOO.

      Você utilizará essa saída no arquivo de configuração do Traefik para configurar a Autenticação Básica de HTTP para a verificação de integridade do Traefik e para o painel de monitoramento. Copie toda a linha de saída para poder colá-la mais tarde.

      Para configurar o servidor Traefik, criaremos um novo arquivo de configuração chamado traefik.toml usando o formato TOML. O TOML é uma linguagem de configuração semelhante ao arquivos INI, mas padronizado. Esse arquivo nos permite configurar o servidor Traefik e várias integrações, ou providers, que queremos usar. Neste tutorial, usaremos três dos provedores disponíveis do Traefik: api,docker e acme, que é usado para suportar o TLS utilizando o Let’s Encrypt.

      Abra seu novo arquivo no vi ou no seu editor de textos favorito:

      Entre no modo de inserção pressionando i, adicione dois EntryPoints nomeados http ehttps, que todos os backends terão acesso por padrão:

      traefik.toml

      defaultEntryPoints = ["http", "https"]
      

      Vamos configurar os EntryPoints http e https posteriormente neste arquivo.

      Em seguida, configure o provider api, que lhe dá acesso a uma interface do painel. É aqui que você irá colar a saída do comando htpasswd:

      traefik.toml

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

      O painel é uma aplicação web separada que será executada no container do Traefik. Vamos definir o painel para executar na porta 8080.

      A seção entrypoints.dashboard configura como nos conectaremos com o provider da api, e a seção entrypoints.dashboard.auth.basic configura a Autenticação Básica HTTP para o painel. Use a saída do comando htpasswd que você acabou de executar para o valor da entrada users. Você poderia especificar logins adicionais, separando-os com vírgulas.

      Definimos nosso primeiro entryPoint, mas precisaremos definir outros para comunicação HTTP e HTTPS padrão que não seja direcionada para o provider da api. A seção entryPoints configura os endereços que o Traefik e os containers com proxy podem escutar. Adicione estas linhas ao arquivo logo abaixo do cabeçalho entryPoints:

      traefik.toml

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

      O entrypoint http manipula a porta 80, enquanto o entrypoint https usa a porta443 para o TLS/SSL. Redirecionamos automaticamente todo o tráfego na porta 80 para o entrypoint https para forçar conexões seguras para todas as solicitações.

      Em seguida, adicione esta seção para configurar o suporte ao certificado Let's Encrypt do Traefik:

      traefik.toml

      ...
      [acme]
      email = "seu_email@seu_domínio"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      

      Esta seção é chamada acme porque ACME é o nome do protocolo usado para se comunicar com o Let's Encrypt para gerenciar certificados. O serviço Let's Encrypt requer o registro com um endereço de e-mail válido, portanto, para que o Traefik gere certificados para nossos hosts, defina a chave email como seu endereço de e-mail. Em seguida, vamos especificar que armazenaremos as informações que vamos receber do Let's Encrypt em um arquivo JSON chamado acme.json. A chave entryPoint precisa apontar para a porta de manipulação do entrypoint 443, que no nosso caso é o entrypoint https.

      A chave onHostRule determina como o Traefik deve gerar certificados. Queremos buscar nossos certificados assim que nossos containers com os nomes de host especificados forem criados, e é isso que a configuração onHostRule fará.

      A seção acme.httpChallenge nos permite especificar como o Let's Encrypt pode verificar se o certificado deve ser gerado. Estamos configurando-o para servir um arquivo como parte do desafio através do entrypoint http.

      Finalmente, vamos configurar o provider docker adicionando estas linhas ao arquivo:

      traefik.toml

      ...
      [docker]
      domain = "seu_domínio"
      watch = true
      network = "web"
      

      O provedor docker permite que o Traefik atue como um proxy na frente dos containers do Docker. Configuramos o provider para vigiar ou watch por novos containers na rede web (que criaremos em breve) e os expor como subdomínios de seu_domínio.

      Neste ponto, o traefik.toml deve ter o seguinte conteúdo:

      traefik.toml

      defaultEntryPoints = ["http", "https"]
      
      [entryPoints]
        [entryPoints.dashboard]
          address = ":8080"
          [entryPoints.dashboard.auth]
            [entryPoints.dashboard.auth.basic]
              users = ["admin:sua_senha_criptografada"]
        [entryPoints.http]
          address = ":80"
            [entryPoints.http.redirect]
              entryPoint = "https"
        [entryPoints.https]
          address = ":443"
            [entryPoints.https.tls]
      
      [api]
      entrypoint="dashboard"
      
      [acme]
      email = "seu_email@seu_domínio"
      storage = "acme.json"
      entryPoint = "https"
      onHostRule = true
        [acme.httpChallenge]
        entryPoint = "http"
      
      [docker]
      domain = "seu_domínio"
      watch = true
      network = "web"
      

      Depois de adicionar o conteúdo, pressione ESC para sair do modo de inserção. Digite :x e depois ENTER para salvar e sair do arquivo. Com toda essa configuração pronta, podemos ativar o Traefik.

      Passo 2 – Executando o Container Traefik

      Em seguida, crie uma rede do Docker para o proxy compartilhar com os containers. A rede do Docker é necessária para que possamos usá-la com aplicações que são executadas usando o Docker Compose. Vamos chamar essa rede de web.

      • docker network create web

      Quando o container Traefik iniciar, nós o adicionaremos a essa rede. Em seguida, podemos adicionar containers adicionais a essa rede posteriormente para o Traefik fazer proxy.

      Em seguida, crie um arquivo vazio que conterá as informações do Let's Encrypt. Compartilharemos isso no container para que o Traefik possa usá-lo:

      O Traefik só poderá usar esse arquivo se o usuário root dentro do container tiver acesso exclusivo de leitura e gravação a ele. Para fazer isso, bloqueie as permissões em acme.json para que somente o proprietário do arquivo tenha permissão de leitura e gravação.

      Depois que o arquivo for repassado para o Docker, o proprietário será automaticamente alterado para o usuário root dentro do container.

      Finalmente, crie o container Traefik com 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.seu_domínio
      • -l traefik.port=8080
      • --network web
      • --name traefik
      • traefik:1.7.6-alpine

      O comando é um pouco longo, então vamos dividi-lo.

      Usamos a flag -d para executar o container em segundo plano como um daemon. Em seguida, compartilhamos nosso arquivo docker.sock dentro do container para que o processo do Traefik possa escutar por alterações nos containers. Compartilhamos também o arquivo de configuração traefik.toml e o arquivoacme.json que criamos dentro do container.

      Em seguida, mapeamos as portas :80 e :443 do nosso host Docker para as mesmas portas no container Traefik, para que o Traefik receba todo o tráfego HTTP e HTTPS para o servidor.

      Em seguida, configuramos dois labels do Docker que informam ao Traefik para direcionar o tráfego para o monitor.seu_domínio para a porta :8080 dentro do container do Traefik, expondo o painel de monitoramento.

      Configuramos a rede do container para web, e nomeamos o container para traefik.

      Finalmente, usamos a imagem traefik:1.7.6-alpine para este container, porque é pequena.

      Um ENTRYPOINT da imagem do Docker é um comando que sempre é executado quando um container é criado a partir da imagem. Neste caso, o comando é o binário traefik dentro do container. Você pode passar argumentos adicionais para esse comando quando você inicia o container, mas definimos todas as nossas configurações no arquivo traefik.toml.

      Com o container iniciado, agora você tem um painel que você pode acessar para ver a integridade de seus containers. Você também pode usar este painel para visualizar os frontends e backends que o Traefik registrou. Acesse o painel de monitoramento apontando seu navegador para https://monitor.seu_domínio. Você será solicitado a fornecer seu nome de usuário e senha, que são admin e a senha que você configurou no Passo 1.

      Uma vez logado, você verá uma interface semelhante a esta:

      Empty Traefik dashboard

      Ainda não há muito o que ver, mas deixe essa janela aberta e você verá o conteúdo mudar à medida que você adiciona containers para o Traefik trabalhar.

      Agora temos nosso proxy Traefik em execução, configurado para funcionar com o Docker, e pronto para monitorar outros containers Docker. Vamos iniciar alguns containers para que o Traefik possa agir como proxy para eles.

      Com o container do Traefik em execução, você está pronto para executar aplicações por trás dele. Vamos lançar os seguintes containers por trás do Traefik:

      1. Um blog usando a imagem oficial do WordPress.

      2. Um servidor de gerenciamento de banco de dados usando a imagem oficial do Adminer.

      Vamos gerenciar essas duas aplicações com o Docker Compose usando um arquivo docker-compose.yml. Abra o arquivo docker-compose.yml em seu editor:

      Adicione as seguintes linhas ao arquivo para especificar a versão e as redes que usaremos:

      docker-compose.yml

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

      Usamos a versão 3 do Docker Compose porque é a mais nova versão principal do formato de arquivo Compose.

      Para o Traefik reconhecer nossas aplicações, elas devem fazer parte da mesma rede e, uma vez que criamos a rede manualmente, nós a inserimos especificando o nome da rede web e configurandoexternal para true. Em seguida, definimos outra rede para que possamos conectar nossos containers expostos a um container de banco de dados que não vamos expor por meio do Traefik. Chamaremos essa rede de internal.

      Em seguida, definiremos cada um dos nossos serviços ou services, um de cada vez. Vamos começar com o container blog, que basearemos na imagem oficial do WordPress. Adicione esta configuração ao arquivo:

      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.seu_domínio
            - traefik.docker.network=web
            - traefik.port=80
          networks:
            - internal
            - web
          depends_on:
            - mysql
      

      A chave environment permite que você especifique variáveis de ambiente que serão definidas dentro do container. Ao não definir um valor para WORDPRESS_DB_PASSWORD, estamos dizendo ao Docker Compose para obter o valor de nosso shell e repassá-lo quando criamos o container. Vamos definir essa variável de ambiente em nosso shell antes de iniciar os containers. Dessa forma, não codificamos senhas no arquivo de configuração.

      A seção labels é onde você especifica os valores de configuração do Traefik. As labels do Docker não fazem nada sozinhas, mas o Traefik as lê para saber como tratar os containers. Veja o que cada uma dessas labels faz:

      • traefik.backend especifica o nome do serviço de backend no Traefik (que aponta para o container real blog).
      • traefik.frontend.rule=Host:blog.seu_domínio diz ao Traefik para examinar o host solicitado e, se ele corresponde ao padrão de blog.seu_domínio, ele deve rotear o tráfego para o container blog.
      • traefik.docker.network=web especifica qual rede procurar sob o Traefik para encontrar o IP interno para esse container. Como o nosso container Traefik tem acesso a todas as informações do Docker, ele possivelmente levaria o IP para a rede internal se não especificássemos isso.
      • traefik.port especifica a porta exposta que o Traefik deve usar para rotear o tráfego para esse container.

      Com essa configuração, todo o tráfego enviado para a porta 80 do host do Docker será roteado para o container blog.

      Atribuímos este container a duas redes diferentes para que o Traefik possa encontrá-lo através da rede web e possa se comunicar com o container do banco de dados através da rede internal.

      Por fim, a chave depends_on informa ao Docker Compose que este container precisa ser iniciado após suas dependências estarem sendo executadas. Como o WordPress precisa de um banco de dados para ser executado, devemos executar nosso container mysql antes de iniciar nosso containerblog.

      Em seguida, configure o serviço MySQL adicionando esta configuração ao seu arquivo:

      docker-compose.yml

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

      Estamos usando a imagem oficial do MySQL 5.7 para este container. Você notará que estamos mais uma vez usando um item environment sem um valor. As variáveis MYSQL_ROOT_PASSWORD eWORDPRESS_DB_PASSWORD precisarão ser configuradas com o mesmo valor para garantir que nosso container WordPress possa se comunicar com o MySQL. Nós não queremos expor o container mysql para o Traefik ou para o mundo externo, então estamos atribuindo este container apenas à rede internal. Como o Traefik tem acesso ao soquete do Docker, o processo ainda irá expor um frontend para o container mysql por padrão, então adicionaremos a label traefik.enable=false para especificar que o Traefik não deve expor este container.

      Por fim, adicione essa configuração para definir o container do Adminer:

      docker-compose.yml

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

      Este container é baseado na imagem oficial do Adminer. A configuração network e depends_on para este container corresponde exatamente ao que estamos usando para o container blog.

      No entanto, como estamos redirecionando todo o tráfego para a porta 80 em nosso host Docker diretamente para o container blog, precisamos configurar esse container de forma diferente para que o tráfego chegue ao container adminer. A linha traefik.frontend.rule=Host:db-admin.seu_domínio diz ao Traefik para examinar o host solicitado. Se ele corresponder ao padrão do db-admin.seu_domínio, o Traefik irá rotear o tráfego para o container adminer.

      Neste ponto, docker-compose.yml deve ter o seguinte conteúdo:

      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.seu_domínio
            - 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.seu_domínio
            - traefik.docker.network=web
            - traefik.port=8080
          networks:
            - internal
            - web
          depends_on:
            - mysql
      

      Salve o arquivo e saia do editor de texto.

      Em seguida, defina valores em seu shell para as variáveis WORDPRESS_DB_PASSWORD e MYSQL_ROOT_PASSWORD antes de iniciar seus containers:

      • export WORDPRESS_DB_PASSWORD=senha_segura_do_banco_de_dados
      • export MYSQL_ROOT_PASSWORD=senha_segura_do_banco_de_dados

      Substitua senha_segura_do_banco_de_dados pela sua senha do banco de dados desejada. Lembre-se de usar a mesma senha tanto para WORDPRESS_DB_PASSWORD quanto para MYSQL_ROOT_PASSWORD.

      Com estas variáveis definidas, execute os containers usando o docker-compose:

      Agora, dê outra olhada no painel de administrador do Traefik. Você verá que agora existe um backend e um frontend para os dois servidores expostos:

      Populated Traefik dashboard

      Navegue até blog.seu_domínio, substituindo seu_domínio pelo seu domínio. Você será redirecionado para uma conexão TLS e poderá agora concluir a configuração do WordPress:

      WordPress setup screen

      Agora acesse o Adminer visitando db-admin.seu_domínio no seu navegador, novamente substituindo seu_domínio pelo seu domínio. O container mysql não está exposto ao mundo externo, mas o container adminer tem acesso a ele através da rede internal do Docker que eles compartilham usando o nome do container mysql como um nome de host.

      Na tela de login do Adminer, use o nome de usuário root, use mysql para o server, e use o valor que você definiu para MYSQL_ROOT_PASSWORD para a senha. Uma vez logado, você verá a interface de usuário do Adminer:

      Adminer connected to the MySQL database

      Ambos os sites agora estão funcionando, e você pode usar o painel em monitor.seu_domínio para ficar de olho em suas aplicações.

      Conclusão

      Neste tutorial, você configurou o Traefik para fazer proxy das solicitações para outras aplicações em containers Docker.

      A configuração declarativa do Traefik no nível do container da aplicação facilita a configuração de mais serviços, e não há necessidade de reiniciar o container traefik quando você adiciona novas aplicações para fazer proxy, uma vez que o Traefik percebe as alterações imediatamente através do arquivo de soquete do Docker que ele está monitorando.

      Para saber mais sobre o que você pode fazer com o Traefik, consulte a documentação oficial do Traefik. Se você quiser explorar mais os containers Docker, confira Como Configurar um Registro Privado do Docker no Ubuntu 18.04 ou How To Secure a Containerized Node.js Application with Nginx, Let's Encrypt, and Docker Compose. Embora esses tutoriais sejam escritos para o Ubuntu 18.04, muitos dos comandos específicos do Docker podem ser usados para o CentOS 7.



      Source link