hits counter
Este sitio web utiliza cookies para obtener estadísticas de navegación. Si sigue adelante, consideraremos que acepta su uso. Acepto | Más información

Servidores


Servidor LEMP + Joomla + SSL

LEMP es el acrónimo que corresponde a Linux, (E)nginx, MySQL y PHP. Todos estos elementos son necesarios para poder instalar uno de los CMS más usados en la creaciónn de páginas webs y blogs: Joomla. Además, añadiremos al final una utilidad para gestionar las bases de datos de una manera fácil y cómoda: phpMyAdmin. Una vez instalados y configurados todos ellos, tendremos un conjunto de servicios con el que podremos crear un completo sitio web alojado en nuestra propia Raspberry Pi.

Requisitos previos

Puesto que Linux ya lo tenemos funcionando en nuestra máquina mediante el uso de Raspberry Pi OS, antes de ponernos manos a la obra con los demás elementos, tenemos que asegurarnos de haber hecho estas dos cosas:

  1. 1.) Asignarle a la Raspberry Pi una IP estática, tal y como se indica en este apartado.
  2. 2.) Crear un DNS dinámico para poder acceder al servidor desde Internet, algo que podemos hacer de la forma que explicamos aquí.


Nginx

Nginx es un servidor web que consume menos recursos hardware que Apache, por lo que es más adecuado para instalarlo en una pequeña placa como la Raspberry Pi. Además, es capaz de gestionar más páginas por segundo y su tiempo de respuesta es menor. Estas mejoras se producen sobre todo cuando se utiliza con páginas web estáticas.

Instalamos el servidor:

sudo apt install nginx

Podemos ver que se ha instalado correctamente accediendo desde el navegador de nuestro PC a la IP de la Raspberry, lo que nos mostrará esto:

A continuación vamos a editar su fichero de configuración:

sudo nano /etc/nginx/nginx.conf

Aquí le indicamos que por razones de seguridad no envíe la versión del servidor en las conexiones HTTP, para lo cual descomentamos esta línea:

server_tokens off;

Para que el cambio surta efecto, reiniciamos el servicio:

sudo service nginx restart

Terminada la configuración, conviene comprobar que no hemos cometido errores, para lo que escribimos este comando:

sudo nginx -t

Las páginas web que queramos mostrar, como veremos más adelante, se guardan en el directorio /var/www/html. Por otro lado, conviene saber que los ficheros que guardan los registros de acceso al servidor se encuentran en /var/log/nginx y son dos: access.log y error.log. Podemos revisarlos de vez en cuando para comprobar el funcionamiento del servidor.


Instalar PHP

Hecho lo anterior, ya podemos instalar PHP en su versión 8.2:

sudo apt install php8.2-fpm php8.2-mbstring php8.2-mysql php8.2-curl php8.2-gd php8.2-zip php8.2-xml php8.2-intl

A diferencia de Apache, Nginx no se configurará automáticamente para su uso con PHP. En su lugar, debemos realizar cambios en sus archivos de configuración para que se cargue. También tendremos que utilizar PHP-FPM y no PHP estándar debido a la forma en que funciona este servidor web.

Vamos a editar el siguiente fichero de configuración para indicarle a Nginx que se encargue de servir también archivos PHP:

sudo nano /etc/nginx/sites-enabled/default

Para ello incluimos index.php a la lista y además descomentamos, más abajo, las otras líneas que se indican a continuación:

# Add index.php to the list if you are using PHP
index index.php index.html index.htm;
. . . . . .
. . . . . .
# pass PHP scripts to FastCGI server
#
location ~ \.php$ {
            include snippets/fastcgi-php.conf;
#
#          # With php-fpm (or other unix sockets):
            fastcgi_pass unix:/run/php/php8.2-fpm.sock;
#          # With php-cgi (or other tcp sockets):
#          fastcgi_pass 127.0.0.1:9000;
}

Debemos comprobar que la línea fastcgi_pass unix:/run/php/php8.2-fpm.sock haga referencia a la versión de PHP que hemos instalado antes (8.2).

Ahora reiniciamos el servidor:

sudo systemctl reload nginx

Para asegurarnos de que PHP funciona correctamente, en la ruta /var/www/html creamos un archivo de prueba:

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

en el que incluiremos este sencillo contenido:

<?php
phpinfo();
?>

Si accedemos desde el navegador del PC a la IP local de la Raspberry (192.168.1.33) nos aparecerá un cuadro con información detallada sobre la versión de PHP instalada:

Una vez comprobado que PHP funciona, eliminamos el fichero de prueba y nos colocamos de nuevo en nuestro /home:

sudo rm index.php
cd ~

Certificado SSL

Con lo hecho hasta aquí, una vez que instalemos Joomla en los pasos siguientes, sólo podremos usarlo mediante el protocolo HTTP. Pero necesitamos convertir nuestro servidor Nginx en un servidor web seguro que use el protocolo HTTPS. Para ello vamos a añadir un Certificado SSL de Let's Encrypt.


MariaDB

Raspberry Pi OS, al igual que otras distribuciones de Linux, ya no incluye MySQL en sus repositorios, debido a que ha dejado de ser Open source (código abierto) al convertirse en propiedad de Oracle. En su lugar utiliza un fork o escisión del mismo llamado MariaDB. Así pues, procedemos a la instalación de este gestor de bases de datos:

sudo apt install mariadb-server

Contrariamente a lo que ocurría con MySQL, MariaDB no nos pide que pongamos una contraseña de administrador durante su instalación, así que tendremos que añadirla en el procedimiento de seguridad que tenemos que realizar seguidamente:

sudo mysql_secure_installation

Lo que nos dará como resultado lo siguiente:

Enter current password for root (enter for none):                   [Pulsamos <Enter>]
Switch to unix_socket authentication [Y/n]                             [Contestamos 'Y' a la pregunta]
Change the root password? [Y/n]                    [Escribimos 'Y' para poner una nueva password]
New password:                                                [Ponemos una contraseña y la anotamos]
Re-enter new password:                                 [La escribimos de nuevo]

Luego, a todas las demás preguntas, contestamos Y, que es la opción por defecto.

IMPORTANTE: no olvidemos anotar la contraseña de root que acabamos de poner. La vamos a necesitar a continuación para la creación de una base de datos y también para entrar en la utilidad phpMyAdmin que instalaremos al final.

Ahora vamos a crear la base de datos y el usuario con su contraseña:

sudo mysql -u root -p

Escribimos las órdenes que se muestran en negrita, cambiando mi_password por una contraseña para la base de datos (que anotaremos, ya que vamos a usarla después para configurar Joomla):

Enter password:                    [La del administrador (root), que anotamos más arriba]
MariaDB [(none)]> CREATE DATABASE joomladb;
MariaDB [(none)]> CREATE USER 'jl_user'@'localhost' IDENTIFIED BY 'mi_password';
MariaDB [(none)]> GRANT ALL PRIVILEGES ON joomladb.* TO 'jl_user'@'localhost';
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> quit;

Por último, instalaremos el conector php-mysql y el descompresor unar:

sudo apt install php-mysql unar

Instalar y configurar Joomla

Vamos al directorio donde instalaremos el CMS:

cd /var/www/html

Para instalar Joomla necesitamos conocer antes cuál es su última versión. Una vez conocida, la descargamos:

sudo wget https://downloads.joomla.org/cms/joomla5/5-1-2/Joomla_5-1-2-Stable-Full_Package.zip

Ahora descomprimimos el fichero:

sudo unar -D Joomla_5-1-2-Stable-Full_Package.zip

Y ya podemos eliminarlo:

sudo rm Joomla_5-1-2-Stable-Full_Package.zip

Volvemos a nuestro /home y cambiamos recursivamente el dueño y el grupo del directorio de instalación:

cd ~
sudo chown -R www-data:www-data /var/www/html

Hecho lo anterior, ya podemos pasar a su configuración. Desde cualquier PC accedemos a la Raspberry mediante HTTPS y el DNS dinámico que creamos al principio:

https://midominio.com

Y aparecerá el instalador web de Joomla:

Seleccionamos el idioma, le damos un nombre al sitio y pulsamos debajo en Configurar los datos de inicio de sesión.

Pasaremos a la siguinte ventana:

En el primer campo podemos poner cualquier nombre. El segundo campo es el que contendrá el verdadero nombre del usuario administrador, que usaremos para iniciar sesión. La contraseña, como se indica, debe contener al menos 12 caracteres. Al final se nos pide una dirección de email. Y pulsamos en Configurar conexión a la base de datos.

Esto nos lleva a la siguiente ventana:

Los dos primeros campos los dejamaos como están. En los dos siguientes escribiremos el nombre de usuario de la base de datos que creamos antes (jl_user) y su correspondiente contraseña. A continuación pondremos el nombre de la base de datos (joomladb). Los dos últimos campos los dejamos como vienen por defecto. Finalmente hacemos clic en Instalar Joomla.

Se iniciará el proceso de instalación:

Una vez terminado este, aparecerá otra ventana indicando que Joomla ya está instalado:

El valor recomendado de desactivar el buffer lo cambiaremos después. Ahora pinchamos en Abrir la administración y se nos pedirá que escribamos el nombre del administrador y su contraseña, que configuramos unos pasos más atrás:

Al hacer clic en Log in accederemos por fin al Panel de inicio de Joomla. Una vez dentro, una de la primeras cosas que podemos cambiar es el idioma. Para ello, en el menú lateral hacemos clic en System y luego, a la derecha, en la sección Manage - Languages. Arriba tenemos el botón Install Languages, donde buscaremos Spanish y finalmente pinchamos en el botón Install. Para que se quede permanente y no haya que seleccionarlo en cada inicio de sesión, cuando entremos de nuevo en el Panel de inicio, hacemos clic arriba a la derecha en el botón Menú de usuario -- Editar cuenta -- Configuración básica: seleccionamos el español en "Idioma de la administración" así como en "Idioma del sitio" y guardamos los cambios pinchando, arriba a la izquierda, en el botón Guardar.

Para entrar en lo sucesivo en la página de administración utilizaremos esta URL:

https://midominio/administrator/index.php

Configurar PHP

Hay algunos parámetros en PHP que podemos cambiar para mejorar el uso de nuestro recién instalado CMS. Para ello editamos el fichero de configuración de PHP:

sudo nano /etc/php/8.2/fpm/php.ini

Con la combinación de teclas Ctrl+w haremos la búsqueda de los siguientes parámetros hasta dejarlos como se muestra a continuación:

output_buffering = Off
post_max_size = 64M
upload_max_filesize = 64M

Para que estos cambios surtan efecto tenemos que reiniciar el servicio PHP-FPM:

sudo systemctl restart php8.2-fpm

phpMyAdmin

phpMyAdmin es una utilidad, escrita en PHP, que sirve para administrar las bases de datos SQL por medio de una interfaz web, por lo que su uso resulta muy fácil e intuitivo. Para su instalación vamos a escribir lo siguiente:

sudo apt install phpmyadmin

Durante el proceso de instalación se nos preguntará qué servidor web hemos instalado. Aunque estemos usando Nginx, seleccionamos apache2 con la tecla Espacio, le damos a Aceptar y continuamos. Después nos preguntará si queremos configurar la base de datos con dbconfig-common; puesto que ya tenemos una creada, contestamos que No.

Una vez finalizada la instalación, creamos un enlace entre la carpeta de la utilidad que acabamos de instalar y el directorio raíz de HTML mediante este comando:

sudo ln -s /usr/share/phpmyadmin /var/www/html

Y ahora, para acceder a la interfaz de phpMyAdmin, ponemos en el navegador lo siguiente:

http://192.168.1.33/phpmyadmin

La IP anterior debe corresponder, lógicamente, con la IP local de nuestra Raspberry. El usuario es root y su contraseña es la que le asignamos más arriba cuando instalamos MariaDB.



Servidor LAMP + WordPress + SSL

LAMP es el acrónimo que corresponde a Linux, Apache, MySQL y PHP. Todos estos elementos son necesarios para poder instalar después el CMS más usado para la creación de blogs: WordPress. Además, añadiremos al final una utilidad para gestionar las bases de datos de una manera fácil y cómoda: phpMyAdmin. Una vez instalados y configurados todos ellos, tendremos un conjunto de servicios con el que podremos crear un completo sitio web alojado en nuestra propia Raspberry Pi.


Requisitos previos

Puesto que Linux ya lo tenemos funcionando en nuestra máquina mediante el uso de Raspberry Pi OS, antes de ponernos manos a la obra con los demás elementos, tenemos que asegurarnos de haber hecho estas dos cosas:

  1. 1.) Asignarle a la Raspberry Pi una IP estática, tal y como se indica en este apartado.
  2. 2.) Crear un DNS dinámico para poder acceder al servidor desde Internet, algo que podemos hacer de la forma que explicamos aquí.


Apache

Apache es probablemente el servidor web más utilizado del mundo. Para una placa con poca potencia de hardware como la Raspberry Pi sería, sin embargo, más adecuado usar Nginx, como explicamos en el apartado anterior; pero este presenta problemas para cambiar los enlaces permanentes de WordPress, motivo por el cual nos hemos decantado por el primero.

Instalarlo y dejarlo listo para funcionar es muy fácil:

sudo apt install apache2

Si en el PC abrimos el navegador y escribimos la IP local de nuestra RasPi, podremos ver una página web de prueba que nos indica que el servidor está funcionando:

Para poder configurar más adelante en WordPress los enlaces permanentes a nuestro gusto es necesario hacer ahora un par de cambios. El primero es habilitar el módulo rewrite:

sudo a2enmod rewrite

Y el segundo es configurar adecuadamente este fichero:

sudo nano /etc/apache2/sites-enabled/000-default.conf

añadiendo las líneas que se muestran en negrita, de manera que quede así:

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

</VirtualHost>

Además, por razones de seguridad, vamos a evitar que envíe la versión del servidor en las conexiones al mismo. Para lograrlo, editamos el fichero

sudo nano /etc/apache2/apache2.conf

y al final del archivo escribimos estos dos parámetros:

ServerSignature Off
ServerTokens Prod

Ahora reiniciamos el servidor:

sudo systemctl restart apache2

Instalar PHP

En segundo lugar instalaremos PHP en su versión 8.2:

sudo apt install php8.2 libapache2-mod-php8.2 php8.2-mbstring php8.2-mysql php8.2-xml php8.2-curl php8.2-gd php8.2-zip php8.2-intl

Y reiniciamos de nuevo el servidor web:

sudo systemctl restart apache2

Para asegurarnos de que todo funciona correctamente, en la ruta /var/www/html borramos el fichero actual y lo sustituimos por un PHP de prueba:

cd /var/www/html
sudo rm index.html
sudo nano index.php

en el que incluiremos este sencillo contenido:

<?php
phpinfo();
?>

Si accedemos desde el navegador del PC a la IP local de la Raspberry (192.168.1.33) nos aparecerá un cuadro con información detallada sobre la versión de PHP instalada:

Una vez comprobado que PHP funciona, eliminamos el fichero de prueba y nos colocamos de nuevo en nuestro /home:

sudo rm index.php
cd ~

A partir de este momento nuestra Raspberry Pi ya tiene soporte para PHP, algo imprescondible para poder ejecutar luego WordPress.

Las páginas o sitios web que queramos mostrar hemos de guardarlas, como hemos visto antes, en el directorio /var/www/html. Por otro lado, conviene saber que los ficheros que guardan los registros de acceso al servidor se encuentran en /var/log/apache2 y son dos: access.log y error.log. Podemos revisarlos de vez en cuando para comprobar el funcionamiento del servidor.


MariaDB

Raspberry Pi OS, al igual que otras distribuciones de Linux, ya no incluye MySQL en sus repositorios, debido a que ha dejado de ser Open source (código abierto) al convertirse en propiedad de Oracle. En su lugar utiliza un fork o escisión del mismo llamado MariaDB. Así pues, procedemos a la instalación de este gestor de bases de datos:

sudo apt install mariadb-server

Contrariamente a lo que ocurría con MySQL, MariaDB no nos pide que pongamos una contraseña de administrador durante su instalación, así que tendremos que añadirla en el procedimiento de seguridad que tenemos que realizar seguidamente:

sudo mysql_secure_installation

Lo que nos dará como resultado lo siguiente:

Enter current password for root (enter for none):                   [Pulsamos <Enter>]
Switch to unix_socket authentication [Y/n]                             [Contestamos 'Y' a la pregunta]
Change the root password? [Y/n]                    [Escribimos 'Y' para poner una nueva password]
New password:                                                [Ponemos una contraseña y la anotamos]
Re-enter new password:                                 [La escribimos de nuevo]

Luego, a todas las demás preguntas, contestamos Y, que es la opción por defecto.

IMPORTANTE: no olvidemos anotar la contraseña de root que acabamos de poner. La vamos a necesitar a continuación para la creación de una base de datos y también para entrar en la utilidad phpMyAdmin que instalaremos al final.

Ahora vamos a crear la base de datos y el usuario con su contraseña:

sudo mysql -u root -p

Escribimos las órdenes que se muestran en negrita, cambiando mi_password por una contraseña para la base de datos (que anotaremos, ya que vamos a usarla después para configurar WordPress):

Enter password:                    [La del administrador (root), que anotamos más arriba]
MariaDB [(none)]> CREATE DATABASE wordpress;
MariaDB [(none)]> CREATE USER 'wp_user'@'localhost' IDENTIFIED BY 'mi_password';
MariaDB [(none)]> GRANT ALL PRIVILEGES ON wordpress.* TO 'wp_user'@'localhost';
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> quit;

Certificado SSL

Con lo hecho hasta aquí, una vez que instalemos WordPress en el siguiente paso, sólo podremos usarlo mediante el protocolo HTTP. Pero necesitamos convertir nuestro servidor Apache en un servidor web seguro que use el protocolo HTTPS. Para ello vamos a añadir un Certificado SSL de Let's Encrypt.


Instalar y configurar Wordpress

Nos vamos al directorio en el que se guardan las páginas web, descargamos WordPress, lo descomprimimos, lo movemos de sitio, borramos todo lo que ya no es necesario y volvemos a nuestro directorio /home:

cd /var/www/html
sudo wget http://wordpress.org/latest.tar.gz
sudo tar -xzf latest.tar.gz
sudo mv wordpress/* .
sudo rmdir wordpress
sudo rm latest.tar.gz
cd ~

Luego le cambiamos recursivamente el dueño y el grupo a la carpeta anterior:

sudo chown -R www-data:www-data /var/www/html

Hecho todo eso, ya podemos pasar a su configuración del CMS. Desde el PC accedemos a la Raspberry mediante el protocolo HTTPS y nuestro dominio:

https://midominio.com

Se nos mostrará una ventana para elegir el idioma:

Pulsamos en el botón Continuar y veremos la ventana de bienvenida en la que se nos indica la información (relativa a la base de datos que creamos antes) que se nos van a pedir a continuación. Aceptamos y pasamos a la siguiente ventana en la que tendremos que introducir dicha información: nombre de la base de datos (wordpress), nombre de usuario (wp_user) y contraseña (la que anotamos más arriba). Los dos últimos campos los dejamos como están:

Pulsamos en Enviar y en otra pequeña ventana se nos advierte de que ya ha terminado la primera parte de la instalación de WordPress, así que ahora pulsamos en Realizar la instalación.

Una última ventana nos solicitará la información necesaria para crear nuestro sitio web: el título que deseamos ponerle, el nombre del usuario que va a administrarlo, su contraseña (ya nos aparece una por defecto) y un correo electrónico válido:

Ya sólo queda pinchar en Instalar WordPress para que se complete el proceso. Veremos un recordatorio de cuál es nuestro usuario para administrar el sitio y la necesidad de escribir la contraseña que hemos elegido antes. Pinchamos en Acceder.

Y entraremos directamente en la ventana de login. Por supuesto, también lo podremos hacer después, en cualquier momento, escribiendo en el navegador nuestro dominio con certificado de Let's Encrypt seguido de /wp-login.php:

https://midominio.com/wp-login.php

Una vez pulsemos en Acceder, entraremos en nuestro flamante CMS y lo primero que haremos será acceder al menú lateral, ir a Ajustes -- Enlaces permanentes y cambiar la opción que viene por de defecto (Simple) por la que se muestra en esta imagen de ejemplo (Nombre de la entrada):


Este cambio es importante, ya que hace los enlaces más comprensibles para los usuarios y además ayuda al posicionamiento SEO de nuestro blog a la hora de ser indexado por los buscadores.

Para que se haga efectivo el cambio hay que pulsar más abajo en Guardar cambios.


phpMyAdmin

phpMyAdmin es una utilidad, escrita en PHP, que sirve para administrar las bases de datos SQL por medio de una interfaz web, por lo que su uso resulta muy fácil e intuitivo. Para su instalación vamos a escribir lo siguiente:

sudo apt install phpmyadmin

Durante el proceso de instalación se nos preguntará qué servidor web hemos instalado. Seleccionamos apache2 con la tecla Espacio, le damos a Aceptar y continuamos. Después nos preguntará si queremos configurar la base de datos con dbconfig-common; puesto que ya tenemos una creada, contestamos que No.

Una vez finalizada la instalación, escribiremos estos dos comandos:

sudo phpenmod mysqli
sudo systemctl restart apache2

Y ahora, para acceder a la interfaz de phpMyAdmin, ponemos en el navegador lo siguiente:

http://192.168.1.33/phpmyadmin

La IP anterior debe corresponder, lógicamente, con la IP local de nuestra Raspberry. El usuario es root y su contraseña es la que le asignamos más arriba cuando instalamos MariaDB.



Servidor de impresión

Si no disponemos de una impresora con conexión de red Ethernet, sino de una simple impresora USB, la tendremos conectada a uno de nuestros ordenadores y sólo podremos imprimir desde este PC. Para solventar este inconveniente, podemos configurar la Raspberry Pi como un servidor de impresión, lo que nos permitirá imprimir desde cualquier PC conectado a la red local. Es una solución fácil y práctica para quienes no dispongan de una impresora de red. Veamos cómo convertir nuestra RasPi en un servidor de impresión gracias a CUPS.

Instalación de CUPS

  1. 1.) Necesitamos descargar e instalar Raspberry Pi OS Desktop, es decir, la versión con escritorio. La versión Lite no sirve porque tendremos que usar el navegador de la Raspberry para acceder a CUPS, como veremos en el punto 6.
  2. 2.) Conectamos el cable de la impresora a uno de los puertos USB de la RasPi y encendemos ambas máquinas.
  3. 3.) Debemos asignar una IP fija a la Raspberry, tal y como se explica aquí.
  4. 4.) Procedemos entonces a actualizar el sistema operativo de la forma habitual:
    sudo apt update
    sudo apt upgrade
  5. 5.) Ejecutamos estos dos comandos para instalar y preparar el uso de CUPS (cambiando piuser por el nombre del usuario que estemos usando en nuestro sistema):
    sudo apt install printer-driver-gutenprint
    sudo usermod -a -G lpadmin piuser
  6. 6.) Desde el escritorio de la Raspberry, abrimos el navegador y escribimos la dirección
    localhost:631
    para entrar en la interfaz web de CUPS a través del puerto 631.
  7. 7.) En la pestaña "Administración", en el apartado Servidor, marcamos las casillas "Compartir impresoras conectadas a este sistema":
    y también "Permitir administración remota". Con esto último podremos acceder a la interfaz web de CUPS instalada en la Raspberry desde el navegador de otro PC, escribiendo su IP y el puerto:
    192.168.1.33:631
    Finalmente pulsamos en el botón "Cambiar configuración" para que se activen ambas opciones.
  8. 8.) En la misma pestaña "Administración", en el apartado Impresoras, ahora pulsamos en el botón "Añadir impresora":
    9.      Se nos pedira el usuario y contraseña de acceso a la Raspberry.
  9. 9.) Seleccionamos nuestra impresora en la parte superior (Impresoras locales) y pulsamos en el botón "Siguiente".
  10. 10.) En la siguiente pantalla comprobamos que los datos son correctos. Opcionalmente podemos poner un nombre a la impresora en Ubicación. Luego marcamos la casilla "Compartir esta impresora" y pulsamos en "Siguiente".
  11. 11.) Pasamos después a una nueva pantalla. Lo más importante aquí está en el apartado Modelo, donde debemos elegir el modelo exacto de nuestra impresora. Si no aparece en la lista (cosa que desgraciadamente es bastante habitual), en el apartado inferior (O proporcione un archivo PPD) podremos seleccionar la carpeta con el fichero PPD que corresponda a la impresora, pulsando en el botón "Examinar"; pero debemos tener en cuenta que dicho fichero habremos de buscarlo y descargarlo previamente de Internet. Hecho esto, pulsamos en "Añadir impresora".
    IMPORTANTE: en última instancia, si no encontramos la impresora con ninguno de los dos métodos anteriores, puede que en la web del fabricante hallemos un instalador con el driver para CUPS, en cuyo caso tendremos que obviar los pasos anteriores (esto es, del 6 al 11) e instalar el driver manualmente en la Raspberry. Hecho esto, ya podremos ir al siguiente y último paso.
  12. 12.) En la pestaña "Impresoras" debe de aparecer ya la impresora que hayamos seleccionado y configurado (bien sea desde CUPS o usando el driver del fabricante) en el punto anterior:

Imprimir en la red local

Completados los pasos anteriores, en los PCs con Linux de nuestra red local debería de aparecer automáticamente en la lista de impresoras, y si no ha habido ningún problema, podremos imprimir en ella.

En el caso de Windows 11, en cambio, la cosa es más complicada. La impresora compartida no aparecerá por sí misma entre los dispositivos de la configuración del sistema. Tendremos que añadirla nosotros manualmente. Para ello seguiremos estos pasos:

  1. 1.) Guardamos en una carpeta el/los fichero/s con los drivers para la impresora.
  2. 2.) Nos vamos a Inicio - Configuración - Bluetooth y dispositivos - Impresoras y escáneres - Agregar una impresora o un escáner - Agregar dispositivo.
  3. 3.) Pulsamos debajo en "La impresora no está en la lista - Agregar manualmente".
  4. 4.) Elegimos "Seleccionar una impresora compartida por nombre" y escribimos lo siguiente:
    http://192.168.1.33:631/printers/HLL2300D
    sustituyendo 192.168.1.33 por la IP local de la Raspberry y HLL2300D por el nombre de nuestra impresora tal y como aparecía anteriormente en CUPS.
  5. 5.) Pulsamos en el botón "Siguiente" y la seleccionamos en la lista de impresoras, si aparece. Si no aparece en esta lista, hacemos clic en el botón "Usar disco" y buscamos la carpeta del paso 1 donde guardamos los drivers.
  6. 6.) Ahora en "Bluetooth y dispositivos - Impresoras y escáneres" ya aparecerá la impresora.


Servidor FTP con TLS

Un servidor FTP (File Transfer Protocol) es un servidor que funciona bajo un protocolo diseñado específicamente para la transferencia de ficheros. Por ello, si queremos compartir archivos desde fuera de la red local, es decir, desde Internet, es muy práctico disponer de un servidor FTP. En Linux podemos instalar varios de ellos. Nosotros vamos a usar ProFtpd debido a su gran flexibilidad para el manejo y configuración de las distintas carpetas que queramos poner a disposición de los demás.

Así pues, lo primero es instalar el servidor:

sudo apt install proftpd

Durante el proceso de instalacción puede que se nos pregunte qué tipo de servidor queremos instalar. Elegimos el tipo por defecto: independiente (standalone).


Carpetas compartidas

Acabado el proceso, creamos las carpetas en las que vamos a guardar los archivos. Para ello usaremos un disco duro USB que se encuentra conectado a la Raspberry y montado en la ruta /media/hdusb (si no lo tenemos instalado, aquí se explica cómo formatearlo y montarlo). En él vamos a crear una carpeta llamada ftp y dentro de ella crearemos varias subcarpetas: musica, elibros y fotos para compartir ficheros, y finalmente la carpeta recibidos para que los usuarios puedan enviar sus propios ficheros al servidor. Lo haremos así:

cd /media/hdusb                         [directorio de montaje del HD]
sudo mkdir ftp
cd ftp
sudo mkdir musica
sudo mkdir elibros
sudo mkdir fotos
sudo mkdir recibidos
sudo chmod 777 recibidos

Si hemos realizado correctamente los pasos anteriores, debemos de tener ya creadas cuatro subcarpetas:

/media/hdusb/ftp/musica
/media/hdusb/ftp/elibros
/media/hdusb/ftp/fotos
/media/hdusb/ftp/recibidos

En las tres primeras copiaremos todos los ficheros y subcarpetas que deseemos compartir; la última (recibidos) la dejaremos vacía para que los usuarios nos envíen a nosotros sus ficheros.


Usuario de acceso

Para acceder al servidor vamos a crear un usuario específico:

sudo adduser ftpuser

Recordemos anotar su contraseña para no olvidarla.

Luego editamos el fichero donde se guardan los usuarios del sistema:

sudo nano /etc/passwd

Al final del mismo, localizamos al usuario que acabamos de crear y hacemos dos cosas: cambiamos el directorio /home/ftpuser por el directorio donde guardaremos el contenido que vamos a compartir (/media/hdusb/ftp) y luego cambiamos el intérprete de comandos /bin/bash por /bin/false, de modo que quede así:

ftpuser:x:1001:1001:,,,:/media/hdusb/ftp:/bin/false

A continuación, y convirtiéndonos antes en administrador, incluimos dicho intérprete de comandos falso en el fichero /etc/shells:

sudo su
echo "/bin/false" >> /etc/shells
exit

Hecho esto, el nuevo usuario sólo podrá entrar por FTP, pero no por SSH. De todas formas, para una mayor seguridad, podemos editar el fichero

sudo nano /etc/ssh/sshd_config

e incluir esta línea para denegar explícitamente su acceso:

DenyUsers ftpuser

Y reiniciamos el servicio:

sudo service ssh restart

Configurar el servidor

Necesitamos configurar adecuadamente nuestro server. Lo haremos modificando el fichero que se encuentra en la ruta /etc/proftpd/proftpd.conf. Pero antes vamos a hacer una copia de seguridad de dicho fichero por si cometemos algún error grave y tenemos que volver a él:

sudo cp /etc/proftpd/proftpd.conf /etc/proftpd/proftpd.conf.original

Tomada esta medida preventiva, ya podemos comenzar con el proceso:

sudo nano /etc/proftpd/proftpd.conf

Usaremos a continuación una serie de directivas para configurar el servidor. La lista completa la podemos consultar aquí.

Empezaremos, opcionalmente, por darle un nombre e identificar nuestros servidor:

ServerName "Personal FTP Server"
ServerIdent on "Uroboros FTP personal server"

Indicaremos el tiempo máximo de espera (en segundos) para cada uno de estas directivas:

TimeoutLogin 120
TimeoutNoTransfer 600
TimeoutStalled 600
TimeoutIdle 600

Como medida de seguridad, comprobaremos que esté presente la siguiente línea, que hace que el usuario de acceso al servidor quede enjaulado en su carpeta /home, que cambiamos antes por la que contiene el árbol de directorios del servidor (/media/hdusb/ftp):

# Use this to jail all users in their homes
DefaultRoot    ~

Además, impediremos que se pueda acceder al servidor como root:

RootLogin                               off

A fin de evitar posibles problemas con los cortafuegos de los clientes, usaremos el servidor en modo pasivo. Para ello descomentamos la directiva PassivePorts y le asignamos un rango de puertos:

PassivePorts                          25000 30000

Conviene saber que los puertos pasivos serán por los que se transmitan los datos, mientras que el puerto 21 se usa para el envío de los comandos. Si hubiéramos optado por un servidor activo, sólo emplearíamos dos puertos: el 21 para los comandos y el 20 para los datos.

Vamos a añadir también algunas líneas para configurar las descargas y las subidas:

# No permitir que los ficheros subidos sean sobrescritos
AllowOverwrite                       off
# Permitir continuar descargas/downloads interrumpidas
AllowRetrieveRestart               on
# No permitir continuar las subidas/uploads interrumpidas
AllowStoreRestart                   off
# Borrar las subidas/uploads abortadas
DeleteAbortedStores               on

Controlaremos la cantidad de usuarios que se pueden conectar simultáneamente, para lo que se incluirán las siguientes líneas:

# Número máximo de usuarios y de conexiones permitidas en el servidor
MaxClients                              4 "Máximo %M usuarios conectados."
MaxClientsPerHost                  3 "Sólo se admiten 3 conexiones por Host/IP."
MaxClientsPerUser                  9 "Sólo se admiten 9 conexiones por usuario."

También podemos configurar el tamaño máximo de los archivos de descarga/subida, en este caso poniendo limitaciones al usuario ftpuser y sin ninguna limitación para el resto:

# Limitaciones de los archivos de descarga y subida
MaxRetrieveFileSize                 100 Gb user ftpuser
MaxRetrieveFileSize                 *
MaxStoreFileSize                     50 Gb user ftpuser
MaxStoreFileSize                     *

O cuántos intentos de inicio de sesión vamos a permitir:

# Intentos de inicio de sesión permitidos
MaxLoginAttempts                 3

Al final del archivo añadimos esta directiva, que definirá los permisos que otorgaremos a las carpetas de descargas (los usuarios podrán descargar de ellas, pero no podrán modificar, borrar o enviar ficheros/carpetas):

<Directory /media/hdusb/ftp>
   <Limit WRITE>
	 DenyAll
   </Limit>
   <Limit READ>   
	 AllowAll	  
   </Limit>		  
</Directory>

Mediante esta otra directiva configuraremos la subcarpeta recibidos, en la que se almacenará todo lo que los usuarios envíen al servidor, y para ello definiremos los permisos apropiados sobre la misma (se podrán enviar ficheros/carpetas, pero no se podrá descargar de ella):

<Directory /media/hdusb/ftp/recibidos>
   <Limit READ WRITE>
	 DenyAll
   </Limit>
   <Limit STOR MKD>   
	 AllowAll	  
   </Limit>		  
</Directory>

Ahora vamos a indica qué usuarios (de todos los que tengamos activos en el sistema) permitiremos que accedan al servidor:

<Limit LOGIN>
     AllowUser ftpuser		[Tendrá acceso a /media/hdusb/ftp]
     AllowUser piuser		[Tendrá acceso a /home/piuser]
     DenyAll			[Nadie más podrá acceder al servidor]
</Limit>

Por último, denegaremos el uso de chmod para el cambio de permisos:

<Limit SITE_CHMOD>
     DenyAll
</Limit>

Y ya podemos guardar el fichero de configuración y comprobar que no hay errores en el mismo:

sudo proftpd -t

Puesta en marcha

Reiniciamos el servidor FTP y comprobamos que esté activo:

sudo service proftpd restart
sudo systemctl status proftpd.service

Recordemos que es necesario abrir los puertos pasivos indicados antes (del 25000 al 30000 TCP) y el puerto 21 TCP en el router, redireccionándolos a la IP local de la Raspberry para permitir el acceso desde Internet. Si tenemos instalado un cortafuegos, también debemos abrirlos en él.

Una vez que el servidor esté en funcionamiento, podemos obtener información sobre los usuarios conectados al mismo utilizando alguno de estos comandos:

ftpwho
ftptop                       [Salimos pulsando Ctrl+c]

Y si deseamos ver el tráfico generado, podemos echar un vistazo de vez en cuando al contenidso de los ficheros de log:

sudo cat /var/log/proftpd/proftpd.log             [Accesos al servidor]
sudo cat /var/log/proftpd/xferlog                    [Transferencias realizadas]

Conexión segura sobre TLS

Tal y como está configurado el servidor FTP, los datos que se intercambian entre el este y el cliente viajan en "claro", es decir, sin cifrar, por lo que alguien que esté en la misma red (una wifi pública, por ejemplo) puede capturar con un sniffer (como el famoso Wireshark) los datos enviados y las credenciales de conexión. Para evitar esto, dotaremos a nuestro servidor de un sistema de cifrado, para lo cual vamos a usar el protocolo de seguridad TLS (Transport Layer Security) creando un certificado autogenerado por nosotros mismos.

En primer lugar, si no lo están ya, instalaremos estos dos paquetes:

sudo apt install openssl proftpd-mod-crypto

Creamos el directorio donde guardar las claves del certificado:

sudo mkdir /etc/proftpd/ssl

Luego generamos el certificado:

sudo openssl req -x509 -newkey rsa:2048 -keyout /etc/proftpd/ssl/proftpd.key -out /etc/proftpd/ssl/proftpd.crt -nodes -days 1095

Se nos pedirá que escribamos una serie de datos: país (con dos letras; por ejemplo, ES), región, ciudad, organización, departamento, nombre y email. Podemos poner los datos que creamos oportunos o incluso dejar algunos en blanco (sólo hemos de pulsar Intro).

Una vez creadas las claves pública y privada, cambiamos sus permisos:

sudo chmod 600 /etc/proftpd/ssl/proftpd.crt
sudo chmod 600 /etc/proftpd/ssl/proftpd.key

Ahora, para utilizarlas en nuestro servidor, tendremos que realizar una serie de pasos. En primer lugar editaremos el fichero de configuración del mismo:

sudo nano /etc/proftpd/proftpd.conf

y descomentamos esta línea:

Include /etc/proftpd/tls.conf

A continuación editamos el fichero al que acabamos de hacer referencia:

sudo nano /etc/proftpd/tls.conf

Borramos todo su contenido y añadimos sólo lo siguiente:

<IfModule mod_tls.c>  
   TLSEngine                  on
   TLSLog                     /var/log/proftpd/tls.log 
   TLSProtocol                SSLv23  
   TLSOptions                 NoSessionReuseRequired  
   TLSRSACertificateFile      /etc/proftpd/ssl/proftpd.crt  
   TLSRSACertificateKeyFile   /etc/proftpd/ssl/proftpd.key  
   TLSVerifyClient            off  
   TLSRequired                on  
</IfModule>

Al estar usando FTPS (también llamado FTP implícito) necesitamos abrir el puerto 990 TCP en el router y, si lo tenemos instalado, también en el cortafuegos ufw.

Luego tendremos que editar el siguiente fichero:

sudo nano /etc/proftpd/modules.conf

y descomentamos la siguiente línea para que se cargue el módulo tls:

LoadModule mod_tls.c

Hecho todo lo anterior, reiniciamos el servidor y comprobamos que está activo:

sudo service proftpd restart
sudo systemctl status proftpd.service

Desde otro PC, tendremos que usar un cliente FTP (como FileZilla, por ejemplo) y escribir los datos para conectar con el servidor:

Al realizar la conexión, debería de aparecer el certificado que creamos antes. Cuando lo haga, pulsamos en Aceptar y ya podemos estar seguros de que disponemos de cifrado TLS en nuestro servidor FTP.

Si queremos que se guarde la conexión, la creamos desde el menú Archivo -- Gestor de sitos. Pinchamos en Nuevo sitio y a la derecha ponemos los datos correspondientes, sin olvidarnos de seleccionar Requiere FTP explícito sobre TLS en el apartado Cifrado:



Servidor de eBooks

Vamos a montar un servidor de eBooks mediante el sistema COPS, con el que crearemos una interfaz web que nos permitirá acceder a los libros electrónicos almacenados en la Raspberry y poder ojearlos, descargarlos o enviarlos por email.

Requisitos previos

Antes de ponernos manos a la obra, tenemos que asegurarnos de haber hecho estas dos cosas:

  1. 1.) Asignarle a la Raspberry Pi una IP estática, tal y como se indica en este apartado.
  2. 2.) Usar un dispositivo USB como lugar para guardar los eBooks (aquí se explica cómo formatearlo y montarlo). Suponiendo que lo tenemos montado en la ruta /media/hdusb y que lo hemos añadido al fichero /etc/fstab, sólo tendremos que crear dentro de ella una carpeta específica para almacenar los libros y darle todos los permisos:
    cd /media/hdusb
    sudo mkdir ebooks
    sudo chmod 777 ebooks

Nginx y PHP

Instalamos el servidor web:

sudo apt install nginx

Podemos ver que se ha instalado correctamente accediendo desde el navegador de nuestro PC a la IP de la Raspberry, lo que nos mostrará esto:

Hecho lo anterior, ya podemos instalar también PHP en su versión 8.2:

sudo apt install php8.2-fpm php8.2-gd php8.2-cli php8.2-sqlite3 php8.2-json php8.2-intl php8.2-xml php8.2-mbstring php8.2-zip

A diferencia de Apache, Nginx no se configurará automáticamente para su uso con PHP. En su lugar, debemos realizar cambios en sus archivos de configuración para que se cargue. También tendremos que utilizar PHP-FPM y no PHP estándar debido a la forma en que funciona este servidor web.

Vamos a editar el siguiente fichero de configuración para indicarle a Nginx que se encargue de servir también archivos PHP:

sudo nano /etc/nginx/sites-enabled/default

Para ello, en la segunda línea incluimos index.php y, más abajo, descomentamos las otras líneas que se indican a continuación, de modo que quede así:

# Add index.php to the list if you are using PHP  
index index.php index.html index.htm index.nginx-debian.html; 
. . . . .
. . . . .  
# pass PHP scripts to FastCGI server
#
location ~ \.php$ {
	include snippets/fastcgi-php.conf; 
#
#       # With php-fpm (or other unix sockets):
        fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
}

Debemos comprobar que la línea fastcgi_pass unix:/var/run/php/php8.2-fpm.sock; haga referencia a la versión de PHP que hemos instalado antes (8.2).

Ahora reiniciamos el servidor:

sudo service nginx restart

Para asegurarnos de que PHP funciona correctamente, en la ruta /var/www/html creamos un archivo de prueba:

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

en el que incluiremos este sencillo contenido:

<?php
phpinfo();
?>

Si accedemos desde el navegador del PC a la IP local de la Raspberry (192.168.1.33) nos aparecerá un cuadro con información detallada sobre la versión de PHP instalada:

Una vez comprobado que PHP funciona, eliminamos el fichero de prueba y nos colocamos de nuevo en nuestro /home:

sudo rm index.php
cd

A continuación vamos a editar el fichero de configuración de Nginx:

sudo nano /etc/nginx/nginx.conf

Aquí le indicamos que por razones de seguridad no envíe la versión del servidor en las conexiones HTTP, para lo cual descomentamos esta línea:

server_tokens off;

Para que el cambio surta efecto, reiniciamos el servicio:

sudo service nginx restart

Los ficheros que guardan los registros de acceso al servidor se encuentran en /var/log/nginx y son dos: access.log y error.log. Podemos revisarlos de vez en cuando para comprobar el funcionamiento del servidor.


COPS

COPS es el software PHP que usaremos para el mantenimiento de nuestra biblioteca, lo que nos permitirá servir los libros electrónicos a cualquier dispositivo que se conecte a él. Vamos a descargarlo en la Raspberry y a descomprimirlo ejecutando los siguientes comandos:

sudo mkdir -p /var/www/html/ebooks
cd /var/www/html/ebooks
sudo wget https://github.com/seblucas/cops/releases/download/1.1.3/cops-1.1.3.zip
sudo unzip cops-1.1.3.zip

Es aconsejable cambiar el dueño y el grupo de la carpeta que hemos creado y todo su contenido, para lo cual volvemos al directorio anterior (/var/www/html), realizamos dicha acción y regresamos de nuevo a donde estábamos:

cd ..
sudo chown -R www-data:www-data *
cd ebooks

Ahora procedemos a configurar COPS renombrando el fichero de ejemplo y luego editándolo:

sudo cp config_local.php.example config_local.php
sudo nano config_local.php

Buscamos la línea

$config['calibre_directory'] = './';

y la sustituimos por la ruta donde vamos a guardar los libros:

$config['calibre_directory'] = '/media/hdusb/ebooks/';                  [Ha de finalizar con /]

Luego en esta otra línea:

$config['cops_title_default'] = "COPS";

escribiremos el título que queramos que aparezca en el servidor, por ejemplo:

$config['cops_title_default'] = "Raspberry Pi eBooks Server";

Además de los cambios anteriores, añadiremos una nueva línea para indicar el máximo número de libros por página que se mostrarán por defecto, precedida de un comentario que explica su uso:

/*
* Max number of items per page
* -1 unlimited
*/
$config['cops_max_item_per_page'] = '50';

Opcionalmente podemos configurar COPS para que envíe los libros por correo. En las cuatro primeras líneas podremos los valores smtp del servidor de email que se correspondan con los datos de nuestra cuenta. Al final, en address.from escribiremos la dirección que queremos que aparezca como remitente de los correos y en subject, el asunto:

/*
* Enable and configure Send To Kindle (or Email) feature.
*
* Don't forget to authorize the sender email you configured in your Kindle's Approved
* Personal Document E-mail List.
*
* If you want to use a simple smtp server (provided by your ISP for example), you can
* configure it like that
*/
$config['cops_mail_configuration'] = array ( "smtp.host"           => "smtp.server.com",
                                                                       "smtp.username"  => "micorreo@servidor.com",
                                                                       "smtp.password"   => "contraseña",
                                                                       "smtp.secure"        => "ssl",
                                                                       "address.from"      => "correo@servidor.com",
                                                                       "subject"                => "Tu libro: "
);

En el fichero config_default.php encontraremos todas las opciones disponibles y los valores por defecto.


Copiar la librería de Calibre a COPS

La aplicación más usada para gestionar los eBooks en nuestro PC y pasarlos al lector es Calibre. Pues bien, a continuación nos toca copiar todo el contenido de la librería de Calibre (Calibre Library) a la carpeta de almacenamiento de COPS (/media/hdusb/ebooks). No hay que olvidar copiar también los ficheros de base de datos (metadata.db y metadata_db_prefs_backup.json). Podemos hacer esto desde un PC con Windows recurriendo a la aplicación WinSCP, un cliente SFTP/SCP que funciona a través del servidor SSH y que resulta muy práctico para transferir archivos a/desde la Raspberry. También podemos usar un simple servidor FTP o hacerlo a través de Samba.

Una vez copiados todos los libros, cambiamos el dueño y grupo de toda la biblioteca::

cd /media/hdusb/
sudo chown -R www-data:www-data ebooks

Y ya poodemos entrar en COPS mediante un navegador, accediendo a la IP de la Raspberry seguida de /ebooks

192.168.1.33/ebooks

Configuración

Haciendo clic en la herramienta de la parte inferior izquierda (la que se indica con la flecha amarilla en la imagen anterior) podremos realizar algunos cambios en la configuración de COPS. La primera de las opciones nos permite modificar la plantilla (Template — Click to switch to Bootstrap).

Con la opción Max. número de libros por página es posible aumentar la velocidad de respuesta del servidor si escribirmos una cifra baja. En el fichero de configuración que editamos antes pusimos 50. Si ponemos -1, que es lo que se asigna por defecto si no hubiéramos añadido esa opción en el mencionado fichero, se mostrarían todos los libros en un sola página, lo que, además de resultar incómodo de manejar, ralentizaría mucho el proceso de presentación de los resultados cuando existe una gran cantidad de libros.

En cuanto a Su correo (Para envío de libros por correo), si en el fichero que editamos con anterioridad hemos añadido y configurado un servidor de correo, aquí podremos escribir una dirección de email a la que queramos que se envíen los libros. De esta forma, una vez dentro de la ficha del libro, aparecerá un nuevo icono con forma de carta que nos permitirá enviarlo por correo:


Enviar libros por correo a lectores Kindle

Si disponemos de un lector Kindle podremos recibir los libros por correo directamente en nuestro dispositivo. Para ello hay que hacer dos cosas: en primer lugar, añadir a la cuenta de Amazon la dirección de correo del remitente de los libros que se reciben desde el servidor de eBooks, y en segundo lugar, incluir en la configuración del servidor la cuenta de correo Kindle (xxxx@kindle.com) a donde se van a enviar los libros. Veamos estos dos pasos con más detalle.

A) En Amazon:

  1. 1.- Entrar en la cuenta de Amazon.
  2. 2.- Ir a “Cuenta y listas” (parte superior derecha).
  3. 3.- En el menú desplegable elegir la opción “Gestionar contenido y dispositivos”.
  4. 4.- Pinchar sobre “Preferencias”, en la parte superior de la página.
  5. 5.- Desplazarse al apartado “Configuración de documentos personales” (está al final, abajo) y pinchar en él.
  6. 6.- Ir a “Lista de direcciones de e-mails autorizadas para el envío de documentos personales” y hacer clic en “Añade una nueva dirección de e-mail autorizada”.
  7. 7.- Escribir la dirección de correo del servidor de eBooks y hacer clic en el botón "Añadir dirección". La dirección de correo del servidor la puede conocer el usuario poniendo un email suyo en la configuración del servidor (como se explica al final del subapartado anterior), enviándose cualquier libro a dicho email y comprobando el remitente del mismo.

B) En el servidor:

Pinchamos en la configuración que hemos indicado antes (icono de herramienta, abajo a la izquierda) y en el apartado Su correo (Para envío de libros por correo) ponemos ahora nuestro email de Kindle (xxxxx@kindle.com) donde recibiremos los libros.

A partir de ahora, cada vez que estemos en la ficha de un libro que nos interese, hacemos clic en el icono con forma de carta (ver la imagen de la captura anterior) para que lo envíe por correo directamente a nuestro Kindle. Pero antes de que nos llegue el libro al dispositivo, recibiremos otro correo (en este caso, en la cuenta de email de Amazon) para que autoricemos dicho envío.


Acceder desde Internet

En estos momentos nuestro servidor de eBooks sólo tiene acceso local (LAN). Si queremos poder acceder desde fuera, necesitamos crear un DNS dinámico, algo que podemos hacer de la forma que explicamos aquí.

Una vez realizado el paso anterior, pasaremos a implementar algunas medidas de seguridad. Primero vamos a "esconder" nuestro servidor cambiando el puerto estándar por otro diferente, ya que el puerto 80 (HTTP) es uno de los más atacados por quienes intentan acceder ilegalmente a un servidor web o saturarlo con multitud de peticiones (ataque DoS, Denial of Service). Para ello editamos el fichero de configuración:

sudo nano /etc/nginx/sites-enabled/default

y ponemos un puerto distinto del 80 (por ejemplo, el 8329) en estas dos líneas del principio:

server {
            listen 8329 default_server;
            listen [::]:8329 default_server;

Reiniciamos con

sudo service nginx restart

Esto implica que a partir de ahora, para acceder al servidor, tendremos que escribir el número de puerto, de esta manera:

midominio.com:8329/ebooks/

Poner credenciales de acceso

Necesitamos evitar que cualquiera pueda entrar en nuestro servidor libremente. Para ello es preciso restringir el acceso mediante un usuario y contraseña. Haremos esto siguiendo unos sencillos pasos. En primer lugar instalamos este paquete de utilidades:

sudo apt install apache2-utils

Esto nos permitirá usar el comando htpasswd para crear el usuario y la contraseña (que convendría anotar para no olvidarnos de ellos). Lo haremos poniendo al final del mismo el nombre del usuario:

sudo htpasswd -c /etc/nginx/.htpasswd usuario

A continuación se nos pedirá que escribamos la contraseña dos veces. Si queremos añadir más usuarios, emplearemos el mismo comando, pero omitiendo el parámetro -c.

Ahora necesitamos editar de nuevo el fichero que modificamos anteriormente:

sudo nano /etc/nginx/sites-enabled/default

y en el apartado location / incluimos las siguientes dos líneas resaltadas en negrita:

location / {
            try_files $uri $uri/ =404;
            auth_basic "Acceso restringido";
            auth_basic_user_file /etc/nginx/.htpasswd;
}

Reiniciamos otra vez:

sudo service nginx restart

y podremos comprobar que ahora nos pide el usuario y contraseña que pusimos antes para dejarnos entrar en el servidor:

En ciertas circunstancias, sin embargo, algunos dispositivos o apps se pueden saltar esta protección. Pero es posible evitar que se puedan descargar libros si hacemos una modificación en el fichero de configuración de COPS. Así que lo abrimos:

sudo nano /var/www/html/ebooks/config_local.php

e insertamos la siguiente línea poniéndola a 1 (por defecto, en config_default.php está a 0):

/*
* Setting this parameter to "1" ensure that nobody can access fetch.php
* before accessing index.php or feed.php first.
* BEWARE: Do not touch this if you're not using password, not using PRS-TX
* or not using Aldiko.
*/
$config ['cops_fetch_protect'] = '1';

Por último, vamos al directorio

cd /var/www/html

y editamos el fichero index.nginx-debian.html para que incluya, por ejemplo, alguna información sobre nuestro sitio web, de manera que si un usuario accede a la raíz del sitio (midominio.com:8329), lea dicha información en lugar de recibir un mensaje de error.



Servidor Nginx con Virtual Hosts

El servidor web Nginx puede configurarse para alojar múltiples dominios o Virtual Hosts (servidores virtuales), cada uno de los cuales apuntará a una página web diferente. Veamos a continuación el proceso para lograrlo.

Lo primero que haremos, naturalmente, será instalarlo:

sudo apt install nginx

Comprobamos que se ha instalado correctamente accediendo desde el navegador de nuestro PC a la IP de la Raspberry, lo que nos mostrará esto:

A continuación vamos a editar el fichero de configuración de Nginx:

sudo nano /etc/nginx/nginx.conf

Aquí le indicamos que por razones de seguridad no envíe la versión del servidor en las conexiones HTTP, para lo cual descomentamos esta línea:

server_tokens off;

Para que el cambio surta efecto, reiniciamos el servicio:

sudo service nginx restart

Los ficheros que guardan los registros de acceso al servidor se encuentran en /var/log/nginx y son dos: access.log y error.log. Podemos revisarlos de vez en cuando para comprobar el funcionamiento del servidor.

Vamos a crear los subdirectorios donde se va a guardar la web de cada dominio:

sudo mkdir -p /var/www/html/web1
sudo mkdir -p /var/www/html/web2

A continuación crearemos una página web en cada uno de esos dos subdirectorios. En nuestro caso, haremos una web muy sencilla (index.html) como simple ejemplo:

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

El contenido de esta primera página va a ser el siguiente:

<html>
<head>
   <title>Primera web</title>
</head>
<body>
   <h2>Te encuentras en el dominiouno.org</h2>
</body>
</html>

Ahora creamos otro fichero index.html dentro del segundo subdirectorio:

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

e incluimos un contenido que nos permita diferenciarla:

<html>
<head>
   <title>Segunda web</title>
</head>
<body>
   <h2>Te encuentras en el dominiodos.net</h2>
</body>
</html>

A los dos directorios que hemos creado antes para contener las dos webs, así como a todo lo que contengan, le asignamos el dueño y el grupo adecuados:

cd /var/www/html
sudo chown -R www-data:www-data *
cd

Para obtener los dominios podemos usar un servicio de DDNS como No-ip, por ejemplo.

Nginx ya incluye en el directorio /etc/nginx/sites-available un fichero llamado default que posee una configuración por defecto a modo de plantilla. Así que vamos a usarlo para crear los archivos de configuracción de cada dominio. Podemos darles cualquier nombre, pero para identificarlos mejor, les pondremos el mismo que el de los dominios:

sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/dominiouno.org
sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/dominiodos.net

Ahora editamos el primer fichero:

sudo nano /etc/nginx/sites-available/dominiouno.org

y lo dejamos así:

server {
           listen 80;
           listen [::]:80;

           root /var/www/html/web1;

           index index.html index.htm;

           server_name dominiouno.org;

           location / {
                try_files $uri $uri/ =404;
           }
}

A continuación el segundo fichero:

sudo nano /etc/nginx/sites-available/dominiodos.net

y lo modificamos para que quede así:

server {
           listen 80;
           listen [::]:80;

           root /var/www/html/web2;

           index index.html index.htm;

           server_name dominiodos.net;

           location / {
                try_files $uri $uri/ =404;
           }
}

Terminada la configuración, conviene comprobar que no hemos cometido errores, para lo que escribimos este comando:

sudo nginx -t

El directorio /etc/nginx/sites-availabe, como su nombre indica, alberga los ficheros de configuración en estado de "disponibles", pero no tienen efecto sobre el funcionamiento del servidor. Es el directorio /etc/nginx/sites-enabled el que los convierte en "activos". Por eso el siguiente paso es crear un enlace simbólico de los dos ficheros anteriores al directorio /etc/nginx/sites-enabled para que se activen y surta efecto su contenido:

sudo ln -s /etc/nginx/sites-available/dominiouno.org /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/dominiodos.net /etc/nginx/sites-enabled/

Este sistema de enlaces simbólicos facilita la activación o desactivación de cada página web con tan sólo crear o eliminar su enlace, sin que se pierda la configuración de cada una.

Como no lo vamos a usar, borramos el enlace que ya existe del fichero default:

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

Una vez concluido todo el proceso, reiniciamos el servidor:

sudo systemctl restart nginx

Necesitamos redireccionar en el router el puerto 80 a la IP local de la Raspberry (y abrirlo en el cortafuegos, si lo tenemos instalado), y ya podemos acceder desde cualquier ordenador a las dos páginas web alojadas en nuestro servidor, utilizando para ello el nombre de cada dominio:

dominiouno.org
dominiodos.net

Múltiples webs con un solo dominio

En lugar de usar varios dominios, podermos utilizar uno solo y acceder con él a páginas web distintas alojadas en el mismo servidor. Para lograrlo, lo único que hay que hacer es usar un puerto distinto para cada una de ellas. Así que procederemos a editar los ficheros de configuración que creamos antes para cada una y pondremos en ellos el mismo dominio (por ejemplo dominio-uno.org), pero asignándole puertos diferentes.

Editamos el primer fichero:

sudo nano /etc/nginx/sites-available/dominio-uno.org

y lo dejamos así:

server {
           listen 8085;
           listen [::]:8085;

           root /var/www/html/web1;

           index index.html index.htm;

           server_name midominio.org;

           location / {
                try_files $uri $uri/ =404;
           }
}

A continuación el segundo fichero:

sudo nano /etc/nginx/sites-available/dominio-dos.net

y lo modificamos para que quede así:

server {
           listen 8088;
           listen [::]:8088;

           root /var/www/html/web2;

           index index.html index.htm;

           server_name midominio.org;

           location / {
                try_files $uri $uri/ =404;
           }
}

Una vez más, comprobamos que no hayamos cometido errores:

sudo nginx -t

Tambén editaremos los dos ficheros index.html que creamos antes, y que corresponden a cada web, para que muestren el mensaje apropiado a las nuevas circunstancias:

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

El contenido de esta primera página podría ser similar al de este ejemplo:

<html>
<head>
   <title>Primera web</title>
</head>
<body>
   <h2>Te encuentras en la primera web</h2>
</body>
</html>

Ahora editamos el fichero index.html del segundo subdirectorio:

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

y le ponemos un contenido que nos permita distinguir esta web de la anterior:

<html>
<head>
   <title>Segunda web</title>
</head>
<body>
   <h2>Ahora se muestra la segunda web</h2>
</body>
</html>

Una vez concluido todo el proceso, reiniciamos el servidor:

sudo systemctl restart nginx

En este caso hemos de redireccionar en el router los puertos 8085 y 8088 a la IP local de la Raspberry (y abrirlos en el cortafuegos, si lo tenemos instalado), y ya podemos acceder desde cualquier ordenador a las dos páginas web alojadas en nuestro servidor utilizando un solo nombre de dominio, acompañado ahora del puerto correspondiente a cada una de ellas:

midominio.org:8085
midominio.org:8088


Servidor VPN WireGuard

Una VPN (Virtual Private Network, Red Privada Virtual) es un sistema que nos permitirá conectarnos a la Raspberry Pi desde cualquier lugar de Internet de una manera segura, mediante una conexión cifrada, y tener acceso a toda nuestra red local igual que si estuviéramos en casa. De hecho, una VPN es como una extensión de nuestra red local, pero realizada a través de una red pública (Internet en este caso). Una vez conectados desde el exterior al servidor VPN, nuestro dispositivo pasará a formar parte de la red doméstica y usará el router de nuestra casa para movernos por Internet, siendo por ello el encargado de asignarnos la IP pública correspondiente. Además, cuando nos conectamos a la VPN, todo el tráfico entre el cliente y el servidor (es decir, los datos generados por cualquier servicio o aplicación que usemos) viajarán con un cifrado de alta seguridad, por lo que nadie podrá ver su contenido aunque estemos usando una wifi pública y haya algún hácker espiando el tráfico de datos que circula por ella.

Vamos a instalar un servidor VPN del tipo WireGuard, ya que actualmente se ha convertido en el más usado (por encima de OpenVPN, que veremos después) debido a su mayor rapidez, facilidad de configuración y seguridad. Aunque WireGuard no es difícil de instalar y configurar, resulta mucho más fácil aún si recurrimos a PiVPN, un script que lleva a cabo todo el proceso de una forma simple y sencilla, lo que nos ahorrará el trabajo de realizar manualmente la configuración del servidor.


Requisitos previos

Antes de comenzar con la instalación, tenemos que asegurarnos de haber hecho estas dos cosas:

  1. 1.) Asignarle a la Raspberry Pi una IP estática, tal y como se detalla en este apartado de nuestra web.
  2. 2.) Crear un DNS dinámico o nombre de dominio virtual para poder acceder al servidor VPN desde Internet, algo que podemos hacer de la forma que explicamos en este otro apartado.


Instalación

El proceso de instalación del servidor WireGuard consistirá en realizar estos cuatro pasos:

  1. 1.) Instalar el servidor con PiVPN. Para ello ejecutaremos este script desde la línea de comandos:
    curl -L https://install.pivpn.io | bash
    Durante el proceso de ejecución se nos preguntarán algunas cosas:
  1. [a] Inicialmente el sistema hará ciertas comprobaciones, instalará algunos paquetes y veremos diversas ventanas con información que hemos de aceptar. Se nos preguntará si queremos forzar que las conexiones IPv6 pasen por la VPN (se recomienda Yes). Luego, en la ventana de DHCP Reservation contestamos No para no usar DHCP, sino una IP estática, que se nos mostrará en la siguiente ventana.
  2. [b] El usuario local que va a usarse para la configuración del servidor (lo seleccionamos y pulsamos Ok).
  3. [c] Se nos dará a elegir entre instalar WireGuard o bien OpenVPN (elegimos WireGuard en este caso).
  4. [d] WireGuard emplea el protocolo UDP, así que sólo se nos preguntará el puerto que vamos a usar (51820 por defecto, aunque conviene cambiarlo). El puerto elegido tendremos que abrirlo en el router y redireccionarlo a la IP local de la Raspberry.
  5. [e] Elegimos un servidor de DNS concreto de la lista que se nos ofrece (Quad9, OpenDNS, Level3, Norton, CloudFlare, Google...).
  6. [f] La IP pública o el nombre de dominio que usaremos para acceder al servidor (elegimos DNS Entry).
  7. [g] Un nombre público para nuestro servidor, que será el DNS dinámico (dominio de no-ip en nuestro caso) que creamos anteriormente en el paso 2 de los REQUISITOS PREVIOS.
  8. [h] Si deseamos activar o no las actualizaciones automáticas (Yes por defecto).
  9. [i] Seremos informados sobre cómo añadir un nuevo usuario y, finalmente, se nos preguntará si deseamos reiniciar el sistema (contestamos Yes y en la siguiente ventana pulsamos en Ok para que se reinicie).

  1. 2.) Crear usuarios. Hecho lo anterior, abrimos de nuevo una terminal y añadimos los usuarios que van a acceder al servidor VPN mediante el comando
    pivpn add
    que nos pedirá el nombre del usuario y generará las claves pública y privada correspondientes. Se creará un perfil con la configuración de cada usuario en /etc/wireguard/configs y, además, una copia en /home/piuser/configs para poder transferirlo a otros dispositivos sin problemas de permisos. Cada perfil consta de un fichero con la forma usuario.conf.

    Para acceder a la primera carpeta, hemos de hacerlo como root:
    sudo su
    cd /etc/wireguard/configs
    Finalmente, volvemos a nuestro usuario habitual con
    exit
    Se recomienda crear un usuario distinto por cada dispositivo desde el que vamos a acceder al servidor.

  1. 3.) Instalar los clientes en todos aquellos dispositivos (PCs, portátiles, smartphones o tabletas digitales) desde los que queramos acceder al servidor. Para el sistema Android podemos usar varias apps, como por ejemplo la oficial o bien esta otra. Para iOS también está disponible la app oficial. Y en el caso de macOS y Windows, podremos descargar los clientes desde la web de WireGuard. Además, disponemos de información sobre cómo instalar y configurar los clientes para los distintos sistemas operativos en este sitio.

  1. 4.) Importar las claves. Una vez instalado el cliente en cada dispositivo, desde este tenemos que importar los ficheros que contienen la clave privada de cada usuario (usuario.conf) que vamos a usar para realizar la conexión al servidor y que se encuentran en cualquiera de las dos carpetas que indicamos en el paso 2.).

    - Linux: este proceso podemos hacerlo desde un ordenador con Linux conectándonos a la Raspberry y descargándonos los ficheros de una forma sencilla mediante el cliente FileZilla, o bien desde la terminal, usando el comando scp, como se explica a continuación:
    scp -P xxxx piuser@192.168.1.33:/home/piuser/configs/* /home/usuario
    El argumento -P xxxx es para indicar el puerto en caso de que no usemos el estándar (22) en el servidor SSH de la Raspberry Pi. Si no es nuestro caso, entonces no hace falta escribirlo. Al final del comando, usuario será el que estemos usando en la máquina Linux.

    Pero si ya estamos en la RasPi y lo que deseamos es exportar los archivos a otra máquina Linux, lo haremos así:
    scp -P xxxx /home/piuser/configs/* usuario@192.168.x.xx:/home/usuario
    El argumento -P xxxx correspondería al puerto del servidor SSH de la máquina destino, en caso de que no use el estándar. En la última parte del comando podremos los datos concretos (usuario e IP local) también de la máquina destino.

    - Windows: en lo que respecta a este SO, podemos recurrir al conocido FileZilla o a una aplicación similar: WinSCP, un cliente SFTP/SCP que funciona a través del servidor SSH y que resulta muy práctico para transferir archivos a/desde la Raspberry.

    - Android e iOS: en el caso de los dispositivos móviles, una de las características más interesantes y útiles de PiVPN es que permite generar un código QR con la configuración de cada usuario mediante el comando
    pivpn -qr usuario
    y que luego se puede escanear desde la app móvil (tanto en Android como en iOS), de manera que la importación de las claves es un proceso completamente automático. O si se desea, también se puede utilizar una app de gestión de archivos (como esta para Android) y crear una conexión SFTP hacia la Raspberry.

    Otra posibilidad para transferir los archivos a cualquier dispositivo es hacerlo manualmente copiando los ficheros, por ejemplo, en un pendrive y de ahí pasarlos directamente al PC o, mediante un cable OTG, al smartphone o la tableta digital.

Hecho todo el proceso anterior, ya tenemos todo listo para empezar a utilizar el servidor WireGuard que acabamos de instalar. Ahora bien, si más adelante, por algún motivo, deseamos desinstalarlo, escribiremos esto:

pivpn uninstall

Iptables

Si estamos usando el cortafuegos ufw, en la configuración de WireGuard hemos de incluir un par de reglas de iptables. Para ello editamos el siguiente fichero:

sudo nano /etc/wireguard/wg0.conf

y al final del bloque [Interface] añadiremos las dos reglas (PostUp y PostDown) que se muestran a continuación marcadas en negrita:

[Interface]
PrivateKey = server_privatekey
Address = 10.6.0.1/24
MTU = 1420
ListenPort = 51820
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; iptables -t nat -A POSTROUTING -o wg0 -j MASQUERADE; ip6tables -A FORWARD -i %i -j ACCEPT; ip6tables -A FORWARD -o %i -j ACCEPT; ip6tables -t nat -A POSTROUTING -o he-ipv6 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; iptables -t nat -D POSTROUTING -o wg0 -j MASQUERADE; ip6tables -D FORWARD -i %i -j ACCEPT; ip6tables -D FORWARD -o %i -j ACCEPT; ip6tables -t nat -D POSTROUTING -o he-ipv6 -j MASQUERADE
### begin user_name ###
[Peer]
. . . . . .

Ambas reglas harán que el servidor VPN funcione correctamente tanto con los clientes que usen el protocolo IPv4 como en aquellos que utilicen el más actual, IPv6.

Además, tenemos que hacer una modificación en el siguiente archivo:

sudo nano /etc/sysctl.conf

Buscamos las líneas que se muestran a continuación y, en caso de que la tengan puesta, le quitamos la almohadilla (#), de manera que quede así:

net.ipv4.ip_forward=1
net.ipv6.conf.all.forwarding=1

Y ahora, para leer el archivo y ajustar los valores de la sesión actual, escribimos:

sudo sysctl -p

Por último, abriremos el puerto del servidor WireGuard, el que indicamos más arriba en el punto 1.) [d] de la instalación del mismo:

sudo ufw allow 51820/udp

Por supuesto, también tendremos que abrirlo en el router.


Usuarios

En el apartado 2.) de la instalación vimos cómo crear usuarios. En el caso de que queramos eliminar alguno de ellos, lo primero que debemos hacer es obtener un listado de los mismos, lo que conseguiremos con esta orden:

pivpn list

Luego lo eliminaremos mediante el siguiente comando:

pivpn remove usuario

Si escribimos de nuevo pivpn list veremos que el usuario ya no aparece en la lista. El borrado consiste en eliminar el fichero correspondiente del directorio /etc/wireguard/configs y también la copia existente en /home/piuser/configs.

Por otro lado, en cualquier momento podremos saber los clientes que se encuentran conectados al servidor. Para ello tenemos que ejecutar este comando:

pivpn clients

Se pueden consultar todos los comandos disponibles con

pivpn --help

Aumentar la seguridad

Si viajamos a determinados países (China, Irán, Irak, Rusia, Turquía, Emiratos Árabes Unidos...), los ISP o quien nos proporcione el servicio de Internet (hoteles, cafeterias, bibliotecas, etc.) pueden bloquear los servidores VPN. En el caso de los ISP, esto pueden hacerlo mediante DPI (inspeccion profunda de paquetes), que permite identificar el contenido de un flujo de datos protegido por VPN basándose en una serie de indicadores preestablecidos, pero el coste y la potencia del hardware necesario para ello es muy elevado, lo que puede producir retrasos en la conexión de los demás usuarios. Por eso, lo que suelen hacer con más frecuencia es filtrar los puertos de salida con un firewall en el momento de realizar el handshake (establecimiento de la conexion). El problema de WireGuard es que utiliza forzosamente el protocolo UDP, y el firewall sólo tendría que bloquear este protocolo para impedir su uso. El único puerto UDP que causaría graves problemas si se bloqueara es el 53, ya que se utiliza para las peticiones DNS. Así pues, en estos casos, una posible solucion sería montar el servidor con ese puerto (o bien con otro puerto UDP cualquiera, y en el router, al abrir los puertos, pondremos el 53 de entrada y lo redirigimos al que hayamos elegido en el server); luego, en los clientes, utilizaremos siempre el 53.



WireGuard + Pi-hole

Podemos instalar cada uno de estos dos servidores por separado, de forma individual, y ambos funcionarán correctamente. Pero si deseamos utilizarlos a la vez, simultáneamente, tendremos que hacer algunas modificaciones en su configuración. En caso contrario, nos toparemos con el problema de que Pi-hole no hace su trabajo de bloquear la publicidad cuando nos conectemos a nuestra red local a través de WireGuard. Para que todo funcione como es debido, tendremos que realizar algunos cambios.


1.- Instalar WireGuard y Pi-hole

Primero instalamos WireGuard y luego hacemos lo propio con Pi-hole. Una vez que hayamos acabado con los procesos instalación, pasamos a la siguiente etapa, que es la que nos permitirá usar ambos servicios conjuntamente, de manera que cada uno realice su función de forma correcta.


2.- Modificar la configuración de WireGuard en los clientes

En los dispositivos en los que vayamos a usar el cliente WireGuard + Pi-hole (normalmente, tableta o smartphone), una vez importado el fichero de cada usuario, tendremos puestas las DNS que elegimos durante la instalación (paso 1, apartado [e]), por lo que será necesario cambiarlas manualmente: vamos al cliente y en el apartado Interfaz -- Servidores DNS cambiamos las DNS que aparecen por la IP local de la Raspberry (192.168.1.33).


3.- Modificar la configuración de Pi-hole

Tenemos que establecer la interfaz wg0 del servidor VPN como la interfaz de Pi-hole. Para ello editamos este archivo:

sudo nano /etc/pihole/setupVars.conf

y modificamos la línea existente para que haga referencia a dicha interfaz:

PIHOLE_INTERFACE=wg0

A continuación creamos un nuevo archivo:

sudo nano /etc/dnsmasq.d/02-ovpn.conf

e incluimos en él las dos interfaces de red:

interface=eth0
interface=wg0

Finalmente entramos en la interfaz web de Pi-hole. En el menú de la izquierda, hacemos clic en Settings - pestaña DNS - Interface settings y comprobamos que estén marcadas las peticions de red local (Allow only local requests), que es la configuración recomendada, tal y como se muestra en esta imagen:

No debemos olvidar guardar los cambios pulsando en el botón Save que se encuentra en la parte inferior derecha.

Hecho todo lo anterior, sólo nos queda reiniciar la Raspberry Pi y ya tendremos nuestro servidor WireGuard funcionando correctamente junto a Pi-hole:

sudo reboot

Podemos comprobarlo si visitamos esta web de prueba, cuyo resultado debería ser este:



Servidor proxy

Vamos a instalar y configurar un servidor proxy mediante Privoxy. Un servidor proxy web se sitúa entre un cliente o una red local e Internet. Se utiliza para interceptar el tráfico HTTP y HTTPS, filtrarlo, controlar el acceso mediante una lista de sitios prohibidos o eliminar los rastreadores y la publicidad, al estilo de un sistema AdBlock. Sin embargo, hay que pagar un precio para tener todo eso: la velocidad de navegación se ralentiza.

Procedemos a su instalación de la forma habitual:

sudo apt install privoxy

Configuración inicial

Por defecto, Privoxy aceptará conexiones HTTP y HTTPS sólo desde la Raspberry en la que se está ejecutando. Necesitamos decirle que acepte conexiones de cualquier otra máquina de nuestra red local (o incluso desde fuera de ella, si abrimos en el router el puerto que veremos a continuación). Para ello editamos este fichero:

sudo nano /etc/privoxy/config

Comentamos las dos líneas listen-address y añadimos una nueva apuntando al puerto 8118, de modo que quede así:


El proxy funcionrá bien sin tener que modificar nada más; pero los usuarios avanzados pueden activar la posibilidad de hacer cambios en los archivos de configuración desde la terminal o mediante la interfaz web que veremos más adelante. Para ello hay que poner a 1 el valor de esta variable de entorno:


Realizadas las modificaciones, es necesario reiniciar el servidor:

sudo systemctl restart privoxy

Activar el proxy en el navegador

Para poder hacer uso de este servicio necesitaremos cambiar los ajustes del navegador de los clientes que lo va a usar. En el caso de utilizar Mozilla Firefox, desplegamos el menú de la esquina superior derecha y hacemos clic en Ajustes -- General -- Configuración de red -- Configuración. En la ventana que aparece, seleccionamos el botón de radio Configuración manual del proxy y escribimos la IP de la Raspberry y el puerto 8118. Debajo marcamos la casilla de verificación Usar también este proxy para HTTPS:


La interfaz web

Reiniciamos el navegador y accedemos a esta dirección para comprobar su funcionamiento:

http://config.privoxy.org/

Veremos un mensaje como este:

Esto significa que Privoxy funciona correctamente usando la configuración predeterminada. Estos valores predeterminados serán adecuados en la mayoría de los casos. No obstante, si más arriba, al hacer la configuración básica, pusimos la variable de entorno como enable-edit-actions 1, tendremos la posibilidad de realizar modificaciones. Para ello, haciendo clic en View & change the current configuration se nos mostrará esta pantalla:

Podemos ver las rutas de los archivos de configuración para editarlos manualmente (salvo los ficheros default, que tiene valores por defecto) o hacerlo desde la misma interfaz pulsando en el botón Edit. Si lo hacemos sobre el primero (match-all.action), aparecerán los opciones de edición:

Los tres botones Set to... aumentarán o reducirán la tolerancia del proxy con el filtrado de páginas web. Si pinchamos de nuevo en Edit, podremos ajustar una gran cantidad de parámetros individualmente:


Privoxy se ejecuta a través de un conjunto de filtros que se aplican a las URL mediante una serie de reglas llamadas acciones. Podemos editar los filtros y sus acciones como archivos de texto o utilizar la interfaz web del navegador para realizar cambios, tal y como acabamos de ver. El proxy permite realizar una gran cantidad de modificaciones. En su página web hallaremos una amplia documentación sobre el mismo. Por ejemplo, un Inicio rápido postinstalación o un extenso Manual de usuario.