One place for hosting & domains

      servidor

      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

      Cómo instalar Jupyter Notebook, ejecutarla y conectarse a ella en un servidor remoto


      El autor seleccionó la Apache Software Foundation para que recibiera una donación de $100 como parte del programa Write for DOnations.

      Introducción

      Jupyter Notebook es una aplicación web interactiva de código abierto que le permite escribir y ejecutar código informático en más de 40 lenguajes de programación, incluidos Python, R, Julia y Scala. Jupyter Notebook, un producto de Project Jupyter, es útil para la codificación iterativa, ya que le permite escribir un pequeño fragmento de código, ejecutarlo y obtener el resultado.

      Jupyter Notebook proporciona la capacidad de crear documentos notebook, denominados simplemente “notebooks”. Los notebooks creados desde Jupyter Notebook son documentos de investigación reproducibles e intercambiables que incluyen elementos de texto enriquecido, ecuaciones, código y sus resultados (cifras, tablas, tramas interactivas). También pueden exportarse a archivos de código sin procesar, HTML o documentos PDF, o bien utilizarse para crear presentaciones de diapositivas interactivas o páginas web.

      A través de este artículo, aprenderá a instalar y configurar la aplicación Jupyter Notebook en un servidor web de Ubuntu 18.04, y también a conectarse a ella desde su computadora local. Además, también veremos cómo utilizar Jupyter Notebook para ejecutar un ejemplo de código de Python.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Además, si su computadora local tiene Windows instalado, deberá instalar PuTTY para establecer un túnel SSH hacia su servidor. Siga nuestra guía Cómo crear claves SSH con PuTTY en Windows para descargar e instalar PuTTY.

      Paso 1: Instalar Jupyter Notebook

      Dado que los notebooks se utilizan para escribir, ejecutar y ver el resultado de pequeños fragmentos de código, primero deberá configurar la compatibilidad de lenguajes de programación. Jupyter Notebook utiliza un kernel específico de lenguaje, un programa informático que ejecuta e inspecciona código. Jupyter Notebook tiene muchos kernels en diferentes lenguajes y el predeterminado es IPython. A través de este tutorial, configurará Jupyter Notebook para ejecutar código de Python a través del kernel de IPython.

      Suponiendo que haya seguido los tutoriales con vínculos de la sección de requisitos previos, debería tener instalados Python 3, pip y un entorno virtual. Los ejemplos de esta guía cumplen con la convención utilizada en el tutorial de los requisitos previos respecto de la instalación de Python 3, por la cual se denomina al entorno virtual “my_env”. Sin embargo, podrá asignarle el nombre que desee.

      Comience activando el entorno virtual:

      • source my_env/bin/activate

      A continuación, su linea de comandos llevará como prefijo el nombre de su entorno.

      Ahora que se encuentra en su entorno virtual, instale Jupyter Notebook:

      • python3 -m pip install jupyter

      Si la instalación fue correcta, verá un resultado similar a este:

      Output

      . . . Successfully installed MarkupSafe-1.0 Send2Trash-1.5.0 backcall-0.1.0 bleach-2.1.3 decorator-4.3.0 entrypoints-0.2.3 html5lib-1.0.1 ipykernel-4.8.2 ipython-6.4.0 ipython-genutils-0.2.0 ipywidgets-7.2.1 jedi-0.12.0 jinja2-2.10 jsonschema-2.6.0 jupyter-1.0.0 jupyter-client-5.2.3 jupyter-console-5.2.0 jupyter-core-4.4.0 mistune-0.8.3 nbconvert-5.3.1 nbformat-4.4.0 notebook-5.5.0 pandocfilters-1.4.2 parso-0.2.0 pexpect-4.5.0 pickleshare-0.7.4 prompt-toolkit-1.0.15 ptyprocess-0.5.2 pygments-2.2.0 python-dateutil-2.7.3 pyzmq-17.0.0 qtconsole-4.3.1 simplegeneric-0.8.1 six-1.11.0 terminado-0.8.1 testpath-0.3.1 tornado-5.0.2

      Con esto, Jupyter Notebook quedará instalado en su servidor. A continuación, veremos la forma de ejecutar la aplicación.

      Paso 2: Ejecutar Jupyter Notebook

      Jupyter Notebook debe ejecutarse desde su VPS, de modo que pueda conectarse a ella desde su computadora local utilizando un túnerl SSH y su navegador web favorito.

      Para ejecutar el servidor Jupyter Notebook, instroduzca el siguiente comando:

      Después de ejecutar este comando, verá un resultado similar a este:

      Output

      [I 19:46:22.031 NotebookApp] Writing notebook server cookie secret to /home/sammy/.local/share/jupyter/runtime/notebook_cookie_secret [I 19:46:22.365 NotebookApp] Serving notebooks from local directory: /home/sammy/environments [I 19:46:22.365 NotebookApp] 0 active kernels [I 19:46:22.366 NotebookApp] The Jupyter Notebook is running at: [I 19:46:22.366 NotebookApp] http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675 [I 19:46:22.366 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 19:46:22.366 NotebookApp] No web browser found: could not locate runnable browser. [C 19:46:22.367 NotebookApp] Copy/paste this URL into your browser when you connect for the first time, to login with a token: http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675&tokenExample_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675

      Es posible que en el resultado observe una advertencia No web browser found. Esto es normal, ya que la aplicación se ejecuta en un servidor y probablemente no haya instalado en él un navegador web. A través de esta guía, verá la forma de conectarse a Notebook en el servidor utilizando túneles SSH en la siguiente sección.

      Por ahora, salga de Jupyter Notebook presionando CTRL+C e y, y luego utilice ENTER para confirmar:

      Output

      Shutdown this notebook server (y/[n])? y [C 20:05:47.654 NotebookApp] Shutdown confirmed [I 20:05:47.654 NotebookApp] Shutting down 0 kernels

      Luego, cierre el servidor con el comando exit:

      Ejecutó Jupyter Notebook en su servidor. Sin embargo, para acceder a la aplicación y comenzar a trabajar con notebooks, deberá conectarse a ella mediante túneles SSH y un navegador web en su computadora local.

      Los túneles SSH son una alternativa sencilla y rápida para conectarse a la aplicación Jupyter Notebook de su servidor. El shell seguro (más conocido como SSH) es un protocolo de red que le permite conectarse a un servidor remoto de forma segura a través de una red no protegida.

      El protocolo SSH incluye un mecanismo de enrutamiento de puerto que le permite canalizar algunas aplicaciones que se ejecutan en un número de puerto específico de un servidor a un número de puerto específico en su computadora local. Aprenderemos a “enrutar” de forma segura la aplicación Jupyter Notebook de su servidor (en el puerto 8888, por defecto) a un puerto de su computadora local.

      El método que utilice para establecer un túnel SSH dependerá del sistema operativo de su computadora local. Entre las subsecciones que se muestran a continuación,elija la que sea más pertinente para su computadora.

      Nota: Es posible configurar e instalar Jupyter Notebook utilizando DigitalOcean Web Console, pero la conexión a la aplicación mediante un túnel SSH debe realizarse a través del terminal o con PuTTY.

      Túneles SSH con macOS o Linux

      Si su computadora local tiene Linux o macOS instalado, es posible establecer un túnel SSH con un solo comando.

      ssh es el comando estándar para abrir una conexión SSH, pero cuando se utiliza con la directiva -L se puede especificar que un puerto determinado en el host local (es decir, su computadora local) se envíe a un host y un puerto determinados en el host remoto (en este caso, su servidor). Esto significa que lo que ejecute en el puerto especificado en el servidor remoto (8888, el puerto predeterminado de Jupyter Notebook) aparecerá en el puerto especificado en su computadora local (8000en el comando del ejemplo).

      Para establecer su propio túnel SSH, ejecute el siguiente comando. Puede cambiar el puerto 8000por uno de su elección si, por ejemplo, otro proceso utiliza el puerto 8000. Se le recomienda utilizar un puerto mayor o igual al 8000, ya que es improbable que otros procesos utilicen esos números de puertos. Asegúrese de incluir la dirección IP de su propio servidor y el nombre de su usuario no root del servidor:

      • ssh -L 8000:localhost:8888 sammy@your_server_ip

      Si no hay errores en este comando, accederá a su servidor remoto. Desde allí, active el entorno virtual:

      • source ~/environments/my_env/bin/activate

      Luego, ejecute la aplicación Jupyter Notebook:

      Para conectarse a Jupyter Notebook, utilice su navegador web favorito y diríjase al puerto local del host local: http://localhost:8000. Ahora que estableció conexión con Jupyter Notebook, continúe con el Paso 4 para aprender a utilizarla.

      Túneles SSH con Windows y PuTTY

      PuTTY es un cliente SSH de código abierto para Windows que puede utilizarse para conectarse a su servidor. Tras descargar e instalar PuTTY en su computadora con Windows (como se describe en el tutorial de los requisitos previos), abra el programa e introduzca la URL o la dirección IP de su servidor, como se muestra aquí:

      Introduzca la URL o IP del servidor en Putty

      A continuación, haga clic en + SSH en la parte inferior izquierda del panel y luego en Tunnels. En esta ventana, introduzca el puerto que desea utilizar para acceder a Jupyter en su computadora local (8000). Se le recomienda utilizar un puerto mayor o igual al 8000, ya que es improbable que otros procesos utilicen esos números de puertos. Si otro proceso utiliza el puerto 8000, seleccione un número de puerto diferente que no se haya utilizado. A continuación, establezca el destino como localhost:8888, ya que Jupyter Notebook funciona en el puerto 8888. Luego, haga clic en el botón Add. Deberían aparecer los puertos en el campo Forwarded ports:

      Configure el túnel SSH en Putty

      Por último, haga clic en el botón Open. Esto conectará su computadora al servidor a través de SSH y canalizará los puertos deseados. Si no aparecen errores, active su entorno virtual:

      • source ~/environments/my_env/bin/activate

      Luego, ejecute Jupyter Notebook:

      A continuación, diríjase al puerto local en su navegador web favorito, una opción puede ser http://localhost:8000 (o cualquier número de puerto que haya elegido), para establecer conexión con la instancia de Jupyter Notebook del servidor. Ahora que estableció conexión con Jupyter Notebook, continúe con el Paso 4 para aprender a utilizarla.

      Paso 4: Usar Jupyter Notebook

      Cuando se accede a través de un navegador web, Jupyter Notebook proporciona un panel de notebooks que funciona como navegador de archivos y le proporciona una interfaz para crear, editar y explorar notebooks. Considere estos notebooks como documentos (guardados con una extensión de archivo .ipynb) que usted puede llenar con cualquier número de celdas individuales. Cada celda tiene un editor de texto interactivo que puede utilizarse para ejecutar código o escribir texto representado. Además, los notebooks le permiten escribir y ejecutar ecuaciones e incluir otros medios, como imágenes o tramas interactivas. También se pueden exportar y compartir en varios formatos (.ipyb, .pdf, .py). Para mostrar algunas de estas funciones, crearemos un archivo notebook desde el panel de notebooks, escribiremos una tabla de texto sencilla con una ecuación y ejecutaremos código básico de Python 3.

      En este punto, deberá estar conectado al servidor a través de un túnel SSH y haber iniciado la aplicación Jupyter Notebook desde su servidor. Una vez que se dirija a http://localhost:8000, verá aparecer una página de inicio de sesión:

      Pantalla de inicio de sesión de Jupyter Notebook

      En el campo Password or token de la parte superior, introduzca el token que vio aparecer en el resultado después de ejecutar jupyter notebook desde su servidor:

      Output

      [I 20:35:17.004 NotebookApp] Writing notebook server cookie secret to /run/user/1000/jupyter/notebook_cookie_secret [I 20:35:17.314 NotebookApp] Serving notebooks from local directory: /home/sammy [I 20:35:17.314 NotebookApp] 0 active kernels [I 20:35:17.315 NotebookApp] The Jupyter Notebook is running at: [I 20:35:17.315 NotebookApp] http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675 [I 20:35:17.315 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 20:35:17.315 NotebookApp] No web browser found: could not locate runnable browser. [C 20:35:17.316 NotebookApp] . . .

      También puede copiar esa URL del resultado de su terminal y pegarla en la barra de direcciones de su navegador.

      De forma automática, Jupyter notebook mostrará los archivos y las carpetas almacenados en el directorio desde el que se ejecuta. Cree un nuevo archivo notebook haciendo clic en New y luego en Python 3 en la parte superior derecha del panel de notebooks:

      Cree un nuevo notebook de Python3

      Dentro de este nuevo notebook, cambie la primera celda para aceptar sintaxis de lenguaje de marcado presionando Cell > Cell Type > Markdown en la barra de navegación de la parte superior. Esta categoría “Cell Type” también le permite escribir ecuaciones en LaTeX además de usar lenguaje de marcado. Por ejemplo, escriba lo siguiente en la celda después del cambio a lenguaje de marcado:

      # Simple Equation
      
      Let us now implement the following equation in Python:
      $$ y = x^2$$
      
      where $x = 2$
      

      Para convertir el lenguaje de marcado en texto enriquecido, presione CTRL + ENTER. Debería aparecer el siguiente resultado:

      Convierta la ecuación de ejemplo en texto enriquecido

      Puede utilizar las celdas de lenguaje de marcado para crear notas y documentar su código.

      Ahora, implementaremos una ecuación sencilla y mostraremos el resultado. Haga clic en Insert *> *Insert Cell Below para insertar una celda. En esta nueva celda, introduzca el siguiente código:

      x = 2
      y = x*x
      print(y)
      

      Para ejecutar el código, presione CTRL + ENTER. Se mostrará el siguiente resultado:

      Resuelva la ecuación de muestra

      Estos son algunos ejemplos relativamente sencillos de lo que puede hacer con Jupyter Notebook. Sin embargo, es una aplicación muy potente que puede implementarse en muchos casos de uso. Desde aquí, puede agregar algunas bibliotecas de Python y utilizar el notebook como haría con cualquier otro entorno de desarrollo de Python.

      Conclusión

      Ahora, debería poder escribir código y texto reproducible de Python utilizando Jupyter Notebook en un servidor remoto. Para ver rápidamente Jupyter Notebook, haga clic en Help en la barra de navegación superior y seleccione User Interface Tour, como se muestra aquí:

      Encontrar el recorrido de la ayuda de Jupyter Notebook

      Si le interesa, le sugerimos obtener más información sobre Jupyter Notebook consultando la documentación de Project Jupyter. Además, puede aprovechar lo que aprendió en este tutorial aprendiendo a codificar en Python 3.



      Source link

      Cómo instalar el servidor web de Apache en Debian 9


      Introducción

      El servidor HTTP Apache es el más usado del mundo. Ofrece muchas características potentes, entre las que se incluyen módulos que se cargan de forma dinámica, una sólida compatibilidad con medios y amplia integración con otras herramientas de software populares.

      En esta guía, explicaremos la forma de instalar el servidor web de Apache en su servidor de Debian 9.

      Requisitos previos

      Antes de comenzar a aplicar esta guía, debe tener un usuario no root normal con privilegios sudo configurado en su servidor. Además, deberá habilitar un firewall básico para que bloquee los puertos que no sean esenciales. Para aprender a configurar una cuenta normal de usuario y un firewall para su servidor, siga nuestra guía de configuración inicial para servidores de Debian 9.

      Cuando disponga de una cuenta, inicie sesión como usuario no root para comenzar.

      Paso 1: Instalar Apache

      Apache está disponible dentro de los repositorios de software predeterminados de Debian, lo que permite instalarlo utilizando herramientas convencionales de administración de paquetes.

      Comencemos actualizando el índice de paquetes locales para que reflejen los últimos cambios anteriores:

      A continuación, instale el paquete apache2:

      Una vez confirmada la instalación, apt instalará Apache y todas las dependencias necesarias.

      Paso 2: Ajustar el firewall

      Antes de probar Apache, es necesario modificar los ajustes de firewall para permitir el acceso externo a los puertos web predeterminados. Suponiendo que siguió las instrucciones de los requisitos previos, debería tener un firewall UFW configurado para que restrinja el acceso a su servidor.

      Durante la instalación, Apache se registra con UFW para proporcionar algunos perfiles de aplicación que pueden utilizarse para habilitar o deshabilitar el acceso a Apache a través del firewall.

      Enumere los perfiles de aplicación ufw escribiendo lo siguiente:

      Verá una lista de los perfiles de aplicación:

      Output

      Available applications: AIM Bonjour CIFS . . . WWW WWW Cache WWW Full WWW Secure . . .

      Los perfiles de Apache comienzan con WWW:

      • WWW: este perfil abre solo el puerto 80 (tráfico web normal no cifrado).
      • WWW Cache: este perfil abre solo el puerto 8080 (algunas veces se utiliza para proxies web y de caché).
      • WWW Full: este perfil abre el puerto 80 (tráfico web normal no cifrado) y el puerto 443 (tráfico cifrado de TLS/SSL).
      • WWW Secure: este perfil abre solo el puerto 443 (tráfico cifrado de TLS/SSL).

      Se recomienda habilitar el perfil más restrictivo, que de todos modos permitirá el tráfico que configuró. Debido a que en esta guía aún no configuramos SSL para nuestro servidor, solo deberemos permitir el tráfico en el puerto 80:

      Puede verificar el cambio escribiendo lo siguiente:

      Debería ver el tráfico HTTP permitido en el resultado que se muestra:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere WWW ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) WWW (v6) ALLOW Anywhere (v6)

      Como puede ver, el perfil se activó para permitir el acceso al servidor web.

      Paso 3: Comprobar su servidor web

      Al final del proceso de instalación, Debian 9 inicia Apache. El servidor web ya debería estar en funcionamiento.

      Realice una verificación con el sistema systemd init para saber si se encuentra en ejecución el servicio escribiendo lo siguiente:

      • sudo systemctl status apache2

      Output

      ● apache2.service - The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2018-09-05 19:21:48 UTC; 13min ago Main PID: 12849 (apache2) CGroup: /system.slice/apache2.service ├─12849 /usr/sbin/apache2 -k start ├─12850 /usr/sbin/apache2 -k start └─12852 /usr/sbin/apache2 -k start Sep 05 19:21:48 apache systemd[1]: Starting The Apache HTTP Server... Sep 05 19:21:48 apache systemd[1]: Started The Apache HTTP Server.

      Como puede ver en este resultado, parece que el servicio se inició correctamente. Sin embargo, la mejor forma de comprobarlo es solicitar una página de Apache.

      Puede acceder a la página de destino predeterminada de Apache para confirmar que el software funcione correctamente mediante su dirección IP: Si no conoce la dirección IP de su servidor, puede obtenerla de varias formas desde la línea de comandos.

      Intente escribir esto en la línea de comandos de su servidor:

      Obtendrá algunas direcciones separadas por espacios. Puede probar cada una de ellas en su navegador web para ver si funcionan.

      Una alternativa es usar la herramienta curl, que debería proporcionarle su dirección IP pública tal como se ve desde otra ubicación en Internet.

      Primero, instale curl utilizando apt:

      Luego, utilice curl para recuperar icanhazip.com mediante IPv4:

      Cuando tenga la dirección IP de su servidor, introdúzcala en la barra de direcciones de su navegador:

      http://your_server_ip
      

      Debería ver la página web predeterminada de Apache de Debian 9:

      Página predeterminada de Apache

      Esta página indica que Apache funciona correctamente. También incluye información básica sobre archivos y ubicaciones de directorios importantes de Apache.

      Paso 4: Administrar el proceso de Apache

      Ahora el servidor web funciona, repasemos algunos comandos de administración básicos.

      Para detener su servidor web, escriba lo siguiente:

      • sudo systemctl stop apache2

      Para iniciar el servidor web cuando se detenga, escriba lo siguiente:

      • sudo systemctl start apache2

      Para detener y luego iniciar el servicio de nuevo, escriba lo siguiente:

      • sudo systemctl restart apache2

      Si solo realiza cambios de configuración, Apache a menudo puede recargarse sin cerrar conexiones. Para hacerlo, utilice este comando:

      • sudo systemctl reload apache2

      Por defecto, Apache está configurado para iniciarse automáticamente cuando el servidor lo hace. Si no es lo que quiere, deshabilite este comportamiento escribiendo lo siguiente:

      • sudo systemctl disable apache2

      Para volver a habilitar el servicio de modo que se cargue en el inicio, escriba lo siguiente:

      • sudo systemctl enable apache2

      Ahora, Apache debería iniciarse de forma automática cuando el servidor lo haga de nuevo.

      Paso 5: Configurar hosts virtuales (recomendado)

      Al emplear el servidor web Apache, puede utilizar _hosts virtuales _(similares a bloques de servidor de Nginx) para encapsular detalles de configuración y alojar más de un dominio desde un único servidor. Configuraremos un dominio llamado example.com, pero debería cambiarlo por su propio nombre de dominio. Consulte nuestra Introducción a DNS de DigitalOcean para hallar más información sobre la configuración de un nombre de dominio con DigitalOcean.

      Por defecto, Apache en Debian 9 tiene habilitado un bloque de servidor que está configurado para proporcionar documentos del directorio /var/www/html. Si bien esto funciona bien para un solo sitio, puede ser difícil de manejar si aloja varios. En vez de modificar /var/www/html, crearemos una estructura de directorio dentro de /var/www para nuestro sitio example.com y dejaremos /var/www/html como directorio predeterminado que se abastecerá si una solicitud de cliente no coincide con otros sitios.

      Cree el directorio para example.com, utilizando el indicador -p para crear cualquier directorio principal necesario:

      sudo mkdir -p /var/www/example.com/html
      

      A continuación, asigne la propiedad del directorio con la variable de entorno $USER:

      • sudo chown -R $USER:$USER /var/www/example.com/html

      Los permisos de sus root web deberían ser correctos si no modificó su valor unmask, pero puede comprobarlo escribiendo lo siguiente:

      • sudo chmod -R 755 /var/www/example.com

      A continuación, cree una página de ejemplo index.html utilizando nano o su editor favorito:

      • nano /var/www/example.com/html/index.html

      Dentro de ella, agregue el siguiente ejemplo de HTML:

      /var/www/example.com/html/index.html

      <html>
          <head>
              <title>Welcome to Example.com!</title>
          </head>
          <body>
              <h1>Success!  The example.com virtual host is working!</h1>
          </body>
      </html>
      

      Guarde y cierre el archivo cuando termine.

      Para que Apache proporcione este contenido, es necesario crear un archivo de host virtual con las directivas correctas. En lugar de modificar el archivo de configuración predeterminado situado en /etc/apache2/sites-available/000-default.conf directamente, crearemos uno nuevo en /etc/apache2/sites-available/example.com.conf:

      • sudo nano /etc/apache2/sites-available/example.com.conf

      Péguelo en el siguiente bloque de configuración, similar al predeterminado, pero actualizado para nuestro nuevo directorio y nombre de dominio:

      /etc/apache2/sites-available/example.com.conf

      <VirtualHost *:80>
          ServerAdmin admin@example.com
          ServerName example.com
          ServerAlias www.example.com
          DocumentRoot /var/www/example.com/html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Tenga en cuenta que cambiamos DocumentRoot por nuestro nuevo directorio y ServerAdmin por un correo electrónico al que pueda acceder el administrador del sitio example.com. También agregamos dos directivas: ServerName, que establece el dominio de base que debería coincidir para esta definición de host virtual, y ServerAlias, que define más nombres que deberían coincidir como si fuesen el nombre de base.

      Guarde y cierre el archivo cuando termine.

      Habilitaremos el archivo con la herramienta a2ensite:

      • sudo a2ensite example.com.conf

      Deshabilite el sitio predeterminado definido en 000-default.conf:

      • sudo a2dissite 000-default.conf

      A continuación, realizaremos una prueba para ver que no haya errores de configuración:

      • sudo apache2ctl configtest

      Debería ver el siguiente resultado:

      Output

      Syntax OK

      Reinicie Apache para implementar sus cambios:

      • sudo systemctl restart apache2

      Con esto, Apache debería ser el servidor de su nombre de dominio. Puede probar esto visitando http://example.com. Allí, debería ver algo como lo siguiente:

      Ejemplo de host virtual de Apache

      Paso 6: Familiarizarse con archivos y direcciones importantes de Apache

      Ahora que sabe administrar el propio servicio de Apache, debe tomarse unos minutos para familiarizarse con algunos directorios y archivos importantes.

      Contenido

      • /var/www/html: el contenido web real, que por defecto solo consta de la página predeterminada de Apache que vio antes, se proporciona desde el directorio /var/www/html. Esto se puede cambiar modificando los archivos de configuración de Apache.

      Configuración del servidor

      • /etc/apache2: el directorio de configuración de Apache. En él se encuentran todos los archivos de configuración de Apache.
      • /etc/apache2/apache2.conf: el archivo principal de configuración de Apache. Esto se puede modificar para realizar cambios en la configuración general de Apache. Este archivo administra la carga de muchos de los demás archivos del directorio de configuración.
      • /etc/apache2/ports.conf: este archivo especifica los puertos en los que Apache escuchará. Por defecto, Apache escucha en el puerto 80. De forma adicional, lo hace en el 443 cuando se habilita un módulo que proporciona capacidades SSL.
      • /etc/apache2/sites-available/: el directorio en el que se pueden almacenar hosts por sitio. Apache no utilizará los archivos de configuración de este directorio a menos que estén vinculados al directorio sites-enabled. Normalmente, toda la configuración de bloques de servidor se realiza en este directorio y luego se habilita al vincularse al otro directorio con el comando a2ensite.
      • /etc/apache2/sites-enabled/: el directorio donde se almacenan hosts virtuales por sitio habilitados. Normalmente, se crean vinculando los archivos de configuración del directorio sites-available con a2ensite. Apache lee los archivos de configuración y los enlaces de este directorio cuando se inicia o se vuelve a cargar para compilar una configuración completa.
      • /etc/apache2/conf-available/ y /etc/apache2/conf-enabled/: estos directorios tienen la misma relación que los directorios sites-available y sites-enabled, pero se utilizan para almacenar fragmentos de configuración que no pertenecen a un host virtual. Los archivos del directorio conf-available pueden habilitarse con el comando a2enconf y deshabilitarse con el comando a2disconf.
      • /etc/apache2/mods-available/ y /etc/apache2/mods-enabled/: estos directorios contienen los módulos disponibles y habilitados, respectivamente. Los archivos que terminan en .load contienen fragmentos para cargar módulos específicos, mientras que los archivos que terminan en .conf contienen la configuración de estos módulos. Los módulos pueden habilitarse y deshabilitarse con los comandos a2enmod y a2dissmod.

      Registros del servidor

      • /var/log/apache2/access.log: por defecto, cada solicitud enviada a su servidor web se asienta en este archivo de registro a menos que Apache esté configurado para no hacerlo.
      • /var/log/apache2/error.log: por defecto, todos los errores se registran en este archivo. La directiva LogLevel de la configuración de Apache especifica el nivel de detalle de los registros de error.

      Conclusión

      Ahora que ha instaló su servidor web, dispone de varias opciones respecto del tipo de contenido que puede ofrecer y de las tecnologías que puede utilizar para crear una experiencia más completa.

      Si desea construir una pila de aplicaciones más completa, puede consultar este artículo sobre cómo configurar una pila LAMP en Debian 9.



      Source link