One place for hosting & domains

      Reverso

      Como Configurar o Nginx como um Servidor Web e Proxy Reverso em Um Servidor Ubuntu 18.04


      O autor selecionou a Fundação Electronic Frontier para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Apache e o Nginx são dois servidores Web populares, frequentemente usados com PHP. Pode ser útil executar ambos na mesma máquina virtual quando hospedar vários sites que tenham requisitos variados. A solução geral para executar dois servidores Web em um único sistema é ou usar endereços IP multiplos ou números de porta diferentes.

      Servidores que têm tanto endereço IPv4 como IPv6 podem ser configurados para atender sites Apache em um protocolo e sites Nginx no outro, mas isso não é atualmente prático, uma vez que a adoção de IPv6 por ISPs ainda não está difundida. Ter um número de porta diferente, como 81 ou 8080 para o segundo servidor Web é outra solução, mas compartilhar URLs com números de porta (como http://example.com:81) nem sempre é sensato ou ideal.

      Neste tutorial você irá configurar o Nginx como tanto um servidor Web como um proxy reverso para o Apache – tudo em um único servidor.

      Dependendo do aplicativo Web, alterações de código podem ser necessárias para manter o Apache ciente do proxy reverso, especialmente quando os sites SSL são configurados. Para evitar isso, você irá instalar um módulo Apache chamado mod_rpaf que reescreve certas variáveis de ambiente, para que pareça que o Apache está lidando diretamente com pedidos de clientes Web.

      Vamos hospedar quatro nomes de domínios em um servidor. Dois serão atendidos pelo Nginx: example.com (o host virtual padrão) e sample.org. Os dois restantes, foobar.net e test.io, serão atentidos pelo Apache. Também vamos configurar o Apache para atender aplicativos PHP usando o PHP-FPM, que oferece melhor desempenho sobre o mod_php.

      Pré-requisitos

      Para completar este tutorial, você precisará do seguinte:

      Passo 1 — Instalando o Apache e o PHP-FPM

      Vamos começar instalando o Apache e o PHP-FPM.

      Além do Apache e do PHP-FPM, também vamos instalar o módulo do Apache PHP FastCGI, libapache2-mod-fastcgi, para suportar aplicativos Web FastCGI.

      Primeiramente, atualize sua lista de pacotes para garantir que você tenha os pacotes mais recentes.

      A seguir, instale os pacotes Apache e PHP-FPM:

      • sudo apt install apache2 php-fpm

      O módulo Apache FastCGI não está disponível no repositório do Ubuntu, então baixe-o do kernel.org e instale-o usando o 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

      A seguir, vamos alterar a configuração padrão do Apache para usar o PHP-FPM.

      Passo 2 — Configurando o Apache e o PHP-FPM

      Neste passo, vamos alterar o número de porta do Apache para 8080 e configurá-lo para funcionar com o PHP-FPM usando o módulo mod_fastcgi. Renomeie o arquivo de configuração ports.conf do Apache:

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

      Crie um novo arquivo ports.conf com a porta definida para “8080:

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

      Nota: servidores Web são geralmente definidos para ouvir no 127.0.0.1:8080 ao configurar um proxy reverso mas fazer isso definiria o valor da variável de ambiente do PHP SERVER_ADDR para o endereço IP do loopback ao invés do endereço IP público do servidor. Nosso objetivo é configurar o Apache de forma que seus sites não vejam um proxy reverso na frente dele. Então, vamos configurá-lo para escutar no 8080 em todos os endereços IP.

      A seguir, vamos criar um arquivo de host virtual para o Apache. A diretiva neste arquivo será definida para atender sites apenas na porta 8080.

      Desabilite o host virtual padrão:

      • sudo a2dissite 000-default

      Então, crie um novo arquivo de host virtual, usando o site padrão existente:

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

      Agora abra o novo arquivo de configuração:

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

      Altere a porta de escuta para 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>
      

      Salve o arquivo e ative o novo arquivo de configuração:

      • sudo a2ensite 001-default

      Então, recarregue o Apache:

      • sudo systemctl reload apache2

      Verifique se o Apache agora está escutando em 8080:

      O resultado deve se parecer com o exemplo a seguir, com apache2 escutando em 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

      Uma vez que você verifique que o Apache está escutando na porta correta, você pode configurar o suporte para o PHP e FastCGI.

      Passo 3 — Configurando o Apache para Usar o mod_fastcgi

      O Apache atende páginas PHP usando o mod_php por padrão, mas ele exige configuração adicional para funcionar com o PHP-FPM.

      Nota: Se você estiver testando este tutorial em uma instalação existente do LAMP com o mod_php, desative ela primeiro com sudo a2dismod pp7.2.

      Vamos adicionar um bloco de configuração para o mod_fastcgi que depende do mod_action. mod_action é desativado por padrão, então primeiro precisamos habilitá-lo:

      Renomeie o arquivo de configuração do FastCGI existente:

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

      Crie um novo arquivo de configuração:

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

      Adicione as diretivas a seguir ao arquivo para passar pedidos de arquivos .php ao socket UNIX do PHP-FPM:

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

      Salve as alterações e faça um teste de configuração:

      Recarregue o Apache se Syntax OK for exibido:

      • sudo systemctl reload apache2

      Se você ver o aviso 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., você pode ignorá-lo de forma segura agora. Vamos configurar os nomes de servidor mais tarde.

      Agora vamos garantir que podemos atender o PHP do Apache.

      Passo 4 — Verificando a Função PHP

      Vamos garantir que o PHP funciona criando um arquivo phpinfo() e acessando-o de um navegador Web.

      Crie o arquivo /var/www/html/info.php que contém uma chamada para a função phpinfo:

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

      Para ver o arquivo em um navegador, vá para http://your_server_ip:8080/info.php. Isso dará a você uma lista das configurações que o PHP está usando. Você verá um resultado similar a este:

      phpinfo Server API

      phpinfo PHP Variables

      No topo da página, verifique se Server API exibe FPM/FastCGI. Cerca de dois terços da página abaixo, a seção PHP Variables irá dizer a você que SERVER_SOFTWARE é o Apache no Ubuntu. Estes confirmam que o mod_fastcgi está ativo e o Apache está usando o PHP-FPM para processar arquivos PHP.

      Passo 5 — Criando Hosts Virtuais para o Apache

      Vamos criar arquivos de host virtual do Apache para os domínios foobar.net e test.io. Para fazer isso, vamos primeiro criar diretórios root do documento para ambos os sites e colocar alguns arquivos padrão nesses diretórios para que possamos testar facilmente nossa configuração.

      Primeiramente, crie os diretórios root do documento:

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

      Então, crie um arquivo index para cada site:

      • 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

      Então, crie um arquivo phpinfo() para cada site para que possamos testar se o PHP está configurado corretamente.

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

      Agora, crie o arquivo de host virtual para o domínio foobar.net:

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

      Adicione o código a seguir ao arquivo para definir o 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>
      

      A linha AllowOverride All habilita o suporte do .htaccess.

      Essas são apenas as diretivas mais básicas. Para um guia completo sobre a configuração de hosts virtuais no Apache, veja Como Configurar Hosts Virtuais do Apache no Ubuntu 16.04.

      Salve e feche o arquivo. Então, crie uma configuração similar para test.io. Primeiramente, crie o arquivo:

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

      Então, adicione a configuração ao arquivo:

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

      Salve o arquivo e saia do editor.

      Agora que ambos os hosts virtuais do Apache estão configurados, habilite os sites usando o comando a2ensite. Isso cria um link simbólico para o arquivo de host virtual no diretório sites-enabled:

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

      Verifique o Apache quanto a erros de configuração novamente:

      Você verá Syntax OK exibido se não houver erros. Se você ver outra coisa, reveja a configuração e tente novamente.

      Recarregue o Apache para aplicar as alterações uma vez que sua configuração estiver livre de erros:

      • sudo systemctl reload apache2

      Para confirmar que os sites estão funcionando, abra http://foobar.net:8080 e http://test.io:8080 no seu navegador e verifique se cada site exibe seu arquivo index.html.

      Você verá os resultados seguintes:

      foobar.net index page

      test.io index page

      Além disso, garanta que o PHP está funcionando acessando os arquivos info.php para cada site. Visite http://foobar.net:8080/info.php e http://test.io:8080/info.php no seu navegador.

      Você verá a mesma lista de especificações de configuração do PHP em cada site como você viu no Passo 4.

      Agora, temos dois sites hospedados no Apache na porta 8080. Vamos configurar o Nginx a seguir.

      Passo 6 — Instalando e Configurando o Nginx

      Neste passo, vamos instalar o Nginx e configurar os domínios exemple.com e sample.org como hosts virtuais do Nginx. Para um guia completo sobre a configuração de hosts virtuais no Nginx, veja Como Configurar Blocos de Servidor Nginx (Hosts Virtuais) no Ubuntu 18.04.

      Instale o Nginx usando o gerenciador de pacotes:

      Então, remova o symlink padrão do host virtual já que não vamos usá-lo mais:

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

      Vamos criar nosso próprio site padrão mais tarde (exemple.com).

      Agora vamos criar hosts virtuais para o Nginx usando o mesmo procedimento que usamos para o Apache. Primeiramente, crie diretórios root de documento para ambos os sites:

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

      Vamos manter os sites do Nginx em /usr/share/nginx, que é onde o Nginx os quer por padrão. Você pode colocá-los sob /var/www/html com os sites do Apache, mas essa separação pode ajudar a associar sites com o Nginx.

      Como você fez com os hosts virtuais do Apache, crie arquivos index e phpinfo() para teste após a configuração estar completa:

      • 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

      Agora, crie um arquivo de host virtual para o domínio example.com:

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

      O Nginx chama por áreas do server {. . .} de um arquivo de configuração blocos de servidor. Crie um bloco de servidor para o host virtual primário, example.com. A diretiva de configuração default_server torna padrão o host virtual que processa pedidos HTTP que não correspondam a nenhum outro 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;
          }
      }
      

      Salve e feche o arquivo. Agora, crie um arquivo de host virtual para o segundo domínio do Nginx, sample.org:

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

      Adicione o que vem a seguir ao arquivo:

      /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;
          }
      }
      

      Salve e feche o arquivo.

      Então, habilite ambos os sites criando links simbólicos para o diretório 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

      Então, teste a configuração do Nginx para garantir que não existam problemas de configuração:

      Então, recarregue o Nginx se não houver erros:

      • sudo systemctl reload nginx

      Agora, acesse o arquivo phpinfo() de seus hosts virtuais do Nginx em um navegador Web visitando http://example.com/info.php e http://sample.org/info.php. Olhe sob as seções Variáveis PHP novamente.

      Nginx PHP Variables

      ["SERVER_SOFTWARE”] deve mostrar nginx, indicando que os arquivos foram diretamente atendidos pelo Nginx.[ “DOCUMENT_ROOT”] deve apontar para o diretório que você criou mais cedo neste passo para cada site do Nginx.

      Até este ponto, instalamos o Nginx e criamos dois hosts virtuais. A seguir, vamos configurar o Nginx para pedidos de proxy destinados a domínios hospedados no Apache.

      Passo 7 — Configurando o Nginx para Hosts Virtuais do Apache

      Vamos criar um host virtual adicional do Nginx com diferentes nomes de domínios nas diretivas server_name. Os pedidos para esses nomes de domínios serão enviadas por proxy para o Apache.

      Crie um novo arquivo de host virtual do Nginx para transmitir pedidos ao Apache:

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

      Adicione o seguinte bloco de código que especifica os nomes de ambos os domínios de host virtual do Apache e envia os pedidos por proxy ao Apache. Lembre-se de utilizar o endereço IP público em 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;
          }
      }
      

      Salve o arquivo e habilite este novo host virtual criando um link simbólico:

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

      Teste a configuração para garantir que não haja erros:

      Se não houver erros, recarregue o Nginx:

      • sudo systemctl reload nginx

      Abra o navegador e acesse o URL http://foobar.net/info.php no seu navegador. Role para a seção PHP Variables e verifique os valores exibidos.

      phpinfo of Apache via Nginx

      As variáveis SERVER_SOFTWARE e DOCUMENT_ROOT confirmam que este pedido foi tratado por Apache. As variáveis HTTP_X_REAL_IP e HTTP_X_FORWARDED_FOR foram adicionadas pelo Nginx e devem mostrar o endereço IP público do computador que você está usando para acessar o URL.

      Nós configuramos o Nginx com sucesso para pedidos de proxy para domínios específicos no Apache. A seguir, vamos configurar o Apache para definir a variável REMOTE_ADDR como se ele estivesse processando esses pedidos diretamente.

      Passo 8 — Instalando e Configurando o mod_rpaf

      Neste passo, você irá instalar um módulo do Apache chamado mod_rpaf que reescreve os valores do REMOTE_ADDR, HTTPS e HTTP_PORT baseado nos valores fornecidos por um proxy reverso. Sem este módulo, algumas aplicações PHP exigiriam alterações no código para funcionar perfeitamente sem estar por trás de um proxy. Este módulo está presente no repositório do Ubuntu como libapache2-mod-rpaf mas está desatualizado e não suporta certas diretivas de configuração. Ao invés disso, vamos instalá-lo da fonte.

      Instale os pacotes necessários para construir o módulo:

      • sudo apt install unzip build-essential apache2-dev

      Faça download do lançamento estável mais recente do GitHub:

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

      Extraia o arquivo baixado:

      Mude para o novo diretório que contém os arquivos:

      Compile e instale o módulo:

      A seguir, crie um arquivo no diretório mods-available que irá carregar o módulo rpaf:

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

      Adicione o código a seguir ao arquivo para carregar o módulo:

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

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

      Salve o arquivo e saia do editor.

      Crie outro arquivo neste diretório chamado rpaf.conf que irá conter as diretivas de configuração para o mod_rpaf:

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

      Adicione o bloco de código a seguir para configurar o mod_rpaf, certificando-se de especificar o endereço IP do seu 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>
      

      Aqui está uma descrição breve de cada diretiva. Veja o arquivo mod_rpaf README para mais informações.

      • *RPAF_Header *- O cabeçalho a se usar para o endereço IP real do cliente.
      • *RPAF_ProxyIPs *- O IP do proxy para ajustar pedidos feitos pelo HTTP.
      • *RPAF_SetHostName *- Atualiza o nome vhost para que o ServerName e ServerAlias funcionem.
      • RPAF_SetHTTPS - Define a variável ambiente HTTPS baseada no valor contido em X-Forwarded-Proto.
      • RPAF_SetPort - Define a variável ambiente SERVER_PORT. Útil para quando o Apache está por trás de um proxy SSL.

      Salve o rpaf.conf e habilite o módulo:

      Isso cria links simbólicos dos arquivos rpaf.load e rpaf.conf no diretório mods-enabled. Agora, faça um teste de configuração:

      Recarregue o Apache se não houver erros:

      • sudo systemctl reload apache2

      Acesse as páginas do phpinfo() http://foobar.net/info.php e http://test.io/info.php no seu navegador e verifique a seção PHP Variables. A variável REMOTE_ADDR também será agora aquela do endereço IP público do seu computador local.

      Agora vamos configurar a criptografia TLS/SSL para cada site.

      Neste passo, vamos configurar certificados TLS/SSL para ambos os domínios hospedados no Apache. Iremos obter os certificados através do Let’s Encrypt. O Nginx suporta a terminação SSL então podemos configurar o SSL sem modificar arquivos de configuração do Apache. O módulo mod_rpaf garante que as variáveis ambiente necessárias estão definidas no Apache para fazer aplicativos funcionarem perfeitamente por trás de um proxy reverso SSL.

      Primeiramente, vamos separar os blocos server {...} de ambos os domínios para que cada um deles possa ter seus próprios certificados SSL. Abra o arquivo /etc/nginx/sites-available/apache no seu editor:

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

      Modifique o arquivo para que ele se pareça com este, com foobar.net e test.io em seus próprios blocos 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;
              }
          }
      

      Usaremos o Certbot para gerar nossos certificados TLS/SSL. O plug-in Nginx cuidará da reconfiguração do Nginx e recarregará a configuração sempre que necessário.

      Primeiramente, adicione o repositório oficial do Certbot:

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

      Pressione ENTER quando solicitado para confirmar que você quer adicionar o novo repositório. Então, atualize a lista de pacotes para recolher informações do novo repositório:

      Então, instale o pacote Nginx do Certbot com o apt:

      • sudo apt install python-certbot-nginx

      Uma vez instalado, use o comando certbot para gerar os certificados para foobar.net e www.foobar.net:

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

      Este comando diz ao Certbot para usar o plug-in nginx usando -d para especificar os nomes para os quais gostaríamos que o certificado seja válido.

      Se essa é a primeira vez que você executa o certbot, você será solicitado a informar um endereço de e-mail e concordar com os termos de serviço. Após fazer isso, o certbot se comunicará com o servidor da Let’s Encrypt, executando posteriormente um desafio para verificar se você controla o domínio para o qual está solicitando um certificado.

      Em seguida, o Certbot perguntará como você gostaria de definir suas configurações 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):

      Selecione sua escolha e, então, pressione ENTER. A configuração será atualizada e o Nginx irá recarregar para recolher as novas configurações.

      Agora, execute o comando para o segundo domínio:

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

      Acesse um dos domínios do Apache no seu navegador usando o https:// prefix; visite https://foobar.net/info.php e você verá isso:

      phpinfo ssl

      Olhe na seção PHP Variables. A variável SERVER_PORT foi definida para 443 e HTTPS definida para on, como se o Apache fosse diretamente acessado pelo HTTPS. Com essas variáveis definidas, aplicativos PHP não precisam ser configurados especialmente para funcionar por trás de um proxy reverso.

      Agora vamos desativar o acesso direto ao Apache.

      Passo 10 — Bloqueando o Acesso Direto ao Apache (Opcional)

      Uma vez que o Apache está escutando na porta 8080 no endereço IP público, ele é acessível por todos. Isso pode ser bloqueado utilizando o seguinte comando IPtables nas definições do seu firewall.

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

      Certifique-se de usar o endereço IP do seu servidor no lugar do exemplo em vermelho. Assim que a porta 8080 estiver bloqueada no seu firewall, teste se o Apache é inacessível por ela. Abra seu navegador Web e tente acessar um dos nomes de domínios do Apache na porta 8080. Por exemplo: http://example.com:8080

      O navegador deve exibir uma mensagem de erro “Incapaz de conectar” ou “Página não está disponível”. Com a opção IPtables tcp-reset funcionando, um intruso não veria diferença entre a porta 8080 e uma porta que não tenha tenha qualquer serviço nela.

      Nota: as regras IPtables não sobrevivem a uma reinicialização do sistema por padrão. Existem várias maneiras de preservar as regras IPtables, mas a mais fácil é usando iptables-persistent no repositório do Ubuntu. Explore este artigo para aprender mais sobre como configurar o IPTables.

      Agora, vamos configurar o Nginx para atender arquivos estáticos nos sites do Apache.

      Passo 11 - Atendendo Arquivos Estáticos Usando o Nginx (Opcional)

      Quando os proxies do Nginx solicitam domínios do Apache, ele envia todos os pedidos de arquivo daquele domínio ao Apache. O Nginx é mais rápido que o Apache em atender arquivos estáticos como imagens, folhas de estilo e JavaScript. Então vamos configurar o arquivo apache de host virtual do Nginx para atender diretamente arquivos estáticos mas enviar pedidos PHP ao Apache.

      Abra o arquivo /etc/nginx/sites-available/apache no seu editor:

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

      Você precisará adicionar dois blocos adicionais location em cada bloco do servidor, além de modificar seções location existentes. Além disso, você precisará dizer ao Nginx onde encontrar os arquivos estáticos para cada site.

      Se você decidiu não usar os certificados SSL e TLS, modifique seu arquivo para que ele se pareça com este:

      /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;
          }
      }
      

      Se também quiser que o HTTPS esteja disponível, use como alternativa a seguinte configuração:

      /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;
      }
      

      A diretiva try_files faz com que o Nginx procure arquivos na root do documento e atenda-os diretamente. Se o arquivo tem uma extensão .php, o pedido é passado para o Apache. Mesmo se o arquivo não for encontrado na root do documento, o pedido é passado para o Apache para que características do aplicativo como permalinks funcionem sem problemas.

      Aviso: A diretiva location ~ /.ht é muito importante; isso impede o Nginx de servir o conteúdo de arquivos de configuração do Apache como .htaccess e .htpasswd que contenham informações sensíveis.

      Salve o arquivo e faça um teste de configuração:

      Recarregue o Nginx se o teste for bem sucedido:

      • sudo service nginx reload

      Para verificar se tudo está funcionando, você pode examinar os arquivos de registro do Apache em /var/log/apache2 e ver os pedidos GET para os arquivos info.php do test.io e foobar.net. Use o comando tail para ver as últimas linhas do arquivo, e use o switch -f para verificar alterações no arquivo:

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

      Agora, visite http://test.io/info.php no seu navegador e então veja o resultado do registro. Você verá que o Apache está efetivamente respondendo:

      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"

      Então, visite a página index.html para cada site e você não verá qualquer registro do Apache. O Nginx está atendendo-os.

      Quando terminar de observar o arquivo de registro, pressione CTRL+C para parar de acompanhá-lo.

      Com essa configuração, o Apache não será capaz de restringir o acesso a arquivos estáticos. O controle de acesso para arquivos estáticos precisaria ser configurado no arquivo de host virtual apache do Nginx, mas isso está além do âmbito deste tutorial.

      Conclusão

      Agora, você tem um servidor Ubuntu com o Nginx atendendo example.com e sample.org, junto com o Apache atendendo foobar.net e test.io. Embora o Nginx esteja agindo como um serviço de proxy reverso para o Apache, o serviço proxy do Nginx é transparente e as conexões com os domínios do Apache parecem ser atendidas diretamente pelo próprio Apache. Você pode usar este método para servir sites seguros e estáticos.



      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

      Como Usar o Traefik como um Proxy Reverso para Containers do Docker no Ubuntu 18.04


      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 apache2-utils:

      • sudo apt-get install apache2-utils

      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$ruca84Hq$mbjdMZBAG.KWn7vfN/SNK/

      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 nano ou no seu editor de textos favorito:

      Primeiro, 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"
      

      Salve o arquivo e saia do editor. 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.2-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.2-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:

      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 senhaseguradobancodedados pela sua senha do banco de dados desejada. Lembre-se de usar a mesma senha tanto para `WORDPRESSDBPASSWORDquanto paraMYSQLROOT_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:

      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:

      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:

      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.

      Por Keith Thompson



      Source link