One place for hosting & domains

      How to Create an HTTP Proxy Using Squid on CentOS 8


      Updated by Rajakavitha Kodhandapani

      Written by Linode

      This guide will show you how to create your own HTTP proxy using Squid, a highly customizable proxy/cache application, on CentOS 8. An HTTP proxy acts as an intermediary between you and the internet. While connected to your Squid HTTP proxy, you will be able to:

      • Anonymously access internet services.
      • Bypass certain regional and local network restrictions.

      Note

      Install Squid

      1. Secure your Linode by completing the instructions in our guide on Securing Your Server, including adding a limited user account and configuring a firewall.

        Note

        This guide is written for a limited, non-root user. Commands that require elevated privileges are prefixed with sudo. If you are not familiar with the sudo command, you can check our Users and Groups guide.
      2. Ensure that your system is up-to-date:

        sudo yum update && sudo yum upgrade
        
      3. Install Squid using the yum software package manager:

        sudo yum install squid
        
      4. Copy the original configuration file to keep as a backup:

        sudo cp /etc/squid/squid.conf /etc/squid/squid.conf.default
        

        Note

        The Squid configuration file includes comprehensive documentation in its commented lines, along with several uncommented rules that will remain active. These default rules should not be modified while you are following this guide. To gain a deeper understanding of Squid’s options and default settings, you can review the full configuration file.

      Configure Client Access

      Now that you have Squid installed on your Linode, you can configure ways for it to accept connections and serve as an HTTP proxy. The following sections provide different ways for your Squid HTTP proxy to authenticate client connections. You can configure Squid to use either or both authentication methods.

      IP Address Authentication

      A simple way to use Squid as an HTTP proxy is to use a client’s IP address for authentication.

      1. Edit the Squid configuration file and add the following lines at the beginning of the file:

        /etc/squid/squid.conf
        1
        2
        
        acl client src 192.0.2.0 # Home IP
        http_access allow client

        Replace client with a name that identifies the client computer that will connect to your Squid HTTP proxy, then replace 192.0.2.0 with the client computer’s IP address. You can also update the optional comment # Home IP to further describe the client.

      2. Alternatively, you can configure multiple clients by adding new acl lines to /etc/squid/squid.conf and including them in the http_access allow line as follows:

        /etc/squid/squid.conf
        1
        2
        3
        
        acl client1 src 192.0.2.0 # Home IP
        acl client2 src 192.0.2.1 # Work IP
        http_access allow client1 client2

        Replace client1 and client2 with names that identify the client computers, then replace 192.0.2.0 and 192.0.2.1 with their corresponding IP addresses. Update the optional comments # Home IP and # Work IP with accurate descriptions to help keep track of multiple clients. Access to the proxy is granted by adding the names defined by each acl to the http_access allow line.

      User/Password Authentication

      You can also configure your Squid HTTP proxy to accept authentication with usernames and passwords.

      1. Install htpasswd by installing the Apache utility programs. If you have installed Apache on your Linode, you will already have it and can skip this step.

        sudo yum install httpd-tools
        
      2. Create a file to store Squid users and passwords:

        sudo touch /etc/squid/squid_passwd
        
      3. Change ownership of the password file:

        sudo chown squid /etc/squid/squid_passwd
        
      4. Create a username password pair, replacing user1 with the name of the user you’d like to add:

        sudo htpasswd /etc/squid/squid_passwd user1
        

        You will be prompted to create a password for this user:

          
        New password:
        Re-type new password:
        Adding password for user user1
        
        

        You can repeat this step at any time to create new users.

      5. Check the location of the nsca_auth file:

        sudo rpm -ql squid | grep ncsa_auth
        
      6. Edit the Squid configuration file and add the following lines at the beginning of the file:

        Note

        Ensure that you update /usr/lib64/squid/basic_ncsa_auth below with the location of the nsca_auth file that you checked in the previous step.

        /etc/squid/squid.conf
        1
        2
        3
        
        auth_param basic program /usr/lib64/squid/basic_ncsa_auth /etc/squid/squid_passwd
        acl ncsa_users proxy_auth REQUIRED
        http_access allow ncsa_users
      7. To remove a user’s access to the proxy, you must delete the corresponding entry in the squid_passwd file. Each user is represented in the file on a single line in the format of user:passwordhash:

        /etc/squid/squid_passwd
        1
        
        user1:$p948w3nvq3489v6npq396g user2:$q3cn478554387cq34n57vn

        If you are using Nano, the command Control+k will remove the entire line where the cursor rests.

        Once you’ve saved and exited the file, complete user removal by restarting Squid:

        sudo systemctl restart squid
        

      Combined Authentication

      You can combine authentication methods using the same acl definitions that you have added in the previous two sections by using a single http_access rule.

      1. Remove any previous http_access lines you have added.

      2. Edit the Squid configuration file so that the lines you have added at the beginning of the file follow this form:

        /etc/squid/squid.conf
        1
        2
        3
        4
        5
        
        acl client1 src 192.0.2.0 # Home IP
        acl client2 src 192.0.2.1 # Work IP
        auth_param basic program /usr/lib64/squid/basic_ncsa_auth /etc/squid/squid_passwd
        acl ncsa_users proxy_auth REQUIRED
        http_access allow client1 client2 ncsa_users

        Note

        Take care to avoid using multiple http_access rules when combining authentication methods, as Squid will follow the rules in the order that they appear. By using a single http_access rule for your acl definitions, you will ensure that several authentication methods will apply to each client that attempts to connect to your Squid HTTP proxy.

      Anonymize Traffic

      Here, you will add rules to mask client IP addresses from the servers that receive traffic from you Squid HTTP proxy. Without these rules, the originating client IP addresses may be passed on through the X-Forwarded For HTTP header.

      Add the following lines at the beginning of the Squid configuration file:

      /etc/squid/squid.conf
       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      
      forwarded_for off
      request_header_access Allow allow all
      request_header_access Authorization allow all
      request_header_access WWW-Authenticate allow all
      request_header_access Proxy-Authorization allow all
      request_header_access Proxy-Authenticate allow all
      request_header_access Cache-Control allow all
      request_header_access Content-Encoding allow all
      request_header_access Content-Length allow all
      request_header_access Content-Type allow all
      request_header_access Date allow all
      request_header_access Expires allow all
      request_header_access Host allow all
      request_header_access If-Modified-Since allow all
      request_header_access Last-Modified allow all
      request_header_access Location allow all
      request_header_access Pragma allow all
      request_header_access Accept allow all
      request_header_access Accept-Charset allow all
      request_header_access Accept-Encoding allow all
      request_header_access Accept-Language allow all
      request_header_access Content-Language allow all
      request_header_access Mime-Version allow all
      request_header_access Retry-After allow all
      request_header_access Title allow all
      request_header_access Connection allow all
      request_header_access Proxy-Connection allow all
      request_header_access User-Agent allow all
      request_header_access Cookie allow all
      request_header_access All deny all

      Enable Connections

      Next, you will enable clients to connect to your Squid HTTP proxy.

      1. Save and exit the Squid configuration file.

      2. Restart Squid to enable the rules you have added:

        sudo systemctl restart squid
        
      3. Implement firewall rules to enable port 3128, which is the default service port used by Squid:

        sudo firewall-cmd --add-port=3128/tcp --permanent
        sudo firewall-cmd --reload
        

        You can find more information on configuring firewall rules for CentOS in our guide on Introduction to FirewallD on CentOS.

      Connect to your Squid HTTP Proxy

      Your Squid HTTP proxy is now ready to accept client connections and anonymously handle internet traffic.

      At this point, you can configure your local browser or operating system’s network settings to use your Linode as an HTTP proxy. The settings to do this will vary depending on your OS and browser. Instructions for certain OS and browser settings are located in the More Information section below.

      Generally, connecting to your Squid HTTP proxy requires the following information:

      • The IP address or domain name associated with your Linode.
      • The port that is being used by Squid. The default port is 3128.
      • A username and password if you have configured them for authentication.

      Once you have established your OS or browser settings, test the connection by pointing your browser at a website that tells you your IP address, such as:

      The result should display your Linode’s IP address instead of the IP address of your client computer.

      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.

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



      Source link

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


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

      Introducción

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

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

      Requisitos previos

      Para este tutorial, necesitará lo siguiente:

      Paso 1: Configurar y ejecutar Traefik

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

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

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

      • sudo apt-get install apache2-utils

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

      • htpasswd -nb admin secure_password

      El resultado del programa tendrá el siguiente aspecto:

      Output

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

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

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

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

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

      traefik.toml

      defaultEntryPoints = ["http", "https"]
      

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

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

      traefik.toml

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

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

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

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

      traefik.toml

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

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

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

      traefik.toml

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

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

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

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

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

      traefik.toml

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

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

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

      traefik.toml

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

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

      Paso 2: Ejecutar el contenedor de Traefik

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

      • docker network create web

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      Panel de Traefik vacío

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

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

      Paso 3: Registrar contenedores con Traefik

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

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

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

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

      docker-compose.yml

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

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

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

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

      docker-compose.yml

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

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

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

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

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

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

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

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

      docker-compose.yml

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

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

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

      docker-compose.yml

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

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

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

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

      docker-compose.yml

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

      Guarde el archivo y salga del editor de texto.

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

      • export WORDPRESS_DB_PASSWORD=secure_database_password
      • export MYSQL_ROOT_PASSWORD=secure_database_password

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

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

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

      Panel de Traefik con contenido

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

      Pantalla configuración de WordPress

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

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

      Adminer conectado a la base de datos de MySQL

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

      Conclusión

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

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

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



      Source link

      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