One place for hosting & domains

      inverso

      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

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


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

      Introducción

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

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

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

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

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

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

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

      Vamos a comenzar por instalar Apache y PHP-FPM.

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

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

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

      • sudo apt install apache2 php-fpm

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

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

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

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

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

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

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

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

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

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

      Desactive el host virtual predeterminado:

      • sudo a2dissite 000-default

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

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

      Ahora, abra el nuevo archivo de configuración:

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

      Cambie el puerto de escucha a 8080:

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

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

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

      • sudo a2ensite 001-default

      Luego, vuelva a cargar Apache:

      • sudo systemctl reload apache2

      Verifique que, ahora, Apache escuche en 8080:

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

      Output

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

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

      Paso 3: configuración de Apache para usar mod_fastcgi

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

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

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

      Cambie el nombre del archivo de configuración FastCGI:

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

      Cree un nuevo archivo de configuración:

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

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

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

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

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

      Vuelva a cargar Apache si aparece el mensaje Syntax OK:

      • sudo systemctl reload apache2

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

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

      Paso 4: verificación de la funcionalidad de PHP

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

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

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

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

      phpinfo Servidor API

      phpinfo Variables PHP

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

      Paso 5: creación de hosts virtuales para Apache

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

      Primero, cree los directorios root de documentos:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      Guarde el archivo y salga del editor.

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

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

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

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

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

      • sudo systemctl reload apache2

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

      Visualizará los siguientes resultados:

      Página de índice de foobar.net

      Página de índice de test.io

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

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

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

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

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

      Instale Nginx usando el gestor de paquetes:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      Añada lo siguiente al archivo:

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

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

      Guarde y cierre el archivo.

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

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

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

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

      • sudo systemctl reload nginx

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

      Variables PHP de Nginx

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

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

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

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

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

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

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

      /etc/nginx/sites-available/apache

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

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

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

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

      Si no hay errores, vuelva a cargar Nginx:

      • sudo systemctl reload nginx

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

      phpinfo de Apache a través de Nginx

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

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

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

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

      Instale los paquetes necesarios para crear el módulo:

      • sudo apt install unzip build-essential apache2-dev

      Descargue la última versión estable de GitHub:

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

      Extraiga el archivo descargado:

      Cambie al directorio nuevo que contiene los archivos:

      Compile e instale el módulo:

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

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

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

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

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

      Guarde el archivo y salga del editor.

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

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

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

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

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

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

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

      Guarde rpaf.conf y habilite el módulo:

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

      Vuelva a cargar Apache si no hay errores:

      • sudo systemctl reload apache2

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

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

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

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

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

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

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

      /etc/nginx/sites-available/apache

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

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

      Primero, añada el repositorio oficial de Certbot:

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

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

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

      • sudo apt install python-certbot-nginx

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

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

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

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

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

      Output

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

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

      Ahora, ejecute el comando para el segundo dominio:

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

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

      phpinfo ssl

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

      Ahora, desactive el acceso directo a Apache.

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

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

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

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

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

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

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

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

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

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

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

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

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

      /etc/nginx/sites-available/apache

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

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

      /etc/nginx/sites-available/apache

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

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

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

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

      Vuelva a cargar Nginx si la prueba resulta exitosa:

      • sudo service nginx reload

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

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

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

      Output

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

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

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

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

      Conclusión

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



      Source link