hits counter

Servidores:



Servidor web Nginx + PHP + SSL

Aunque Apache es el servidor web más usado en Internet, tiene el inconveniente de que está pensado para máquinas con un hardware potente. Nginx, por el contrario, es un servidor web que consume menos recursos, por lo que es más adecuado para instalarlo en una pequeña placa como la Raspberry Pi. Su consumo de RAM es inferior al de Apache, 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:


Instalar PHP

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

sudo apt install php7.3 php7.3-common php7.3-fpm php7.3-mysql php7.3-xml php7.3-cli php7.3-curl php7.3-gd php7.3-json php7.3-mbstring php7.3-zip

Vamos a editar la configuración de PHP para hacer un cambio:

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

Buscamos dentro las siguientes líneas (con Ctrl+w) y las modificamos (o descomentamos, según el caso) de manera que queden así:

cgi.fix_pathinfo=1
memory_limit = 256M

Ahora editamos otro fichero para indicarle a Nginx que se encargue de servir también archivos PHP:

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

Para ello incluimos index.php en la lista y además descomentamos 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 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/php7.3-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
}

Comprobamos que, tras los cambios, no recibimos ningún mensaje de error:

sudo nginx -t

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

sudo nano /etc/nginx/nginx.conf

Aquí le indicamos dos cosas: que utilice todos los núcleos de la CPU (podemos averiguar su número con el comando grep processor /proc/cpuinfo | wc -l) y que, por razones de seguridad, no envíe la versión del servidor en las conexiones HTTP:

worker_processes 4;
server_tokens off;

Terminada la configuración, reiniciamos ambos servicios:

sudo service php7.3-fpm restart
sudo service nginx restart

Para comprobar que todo funciona correctamente, en la ruta /var/www/html creamos un archivo de prueba llamado, por ejemplo, prueba.php:

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

en el que incluiremos este sencillo contenido:

<?php
phpinfo();
?>

Si accedemos desde el navegador del PC a la IP local de la Raspberry, seguida del nombre del fichero PHP que hemos creado antes (http://192.168.1.33/prueba.php), nos aparecerá un cuadro con información detallada sobre la versión de PHP instalada:


Una vez comprobado su funcionamiento, por razones de seguridad es conveniente eliminarlo:

sudo rm prueba.php

Las páginas web que queramos mostrar hemos de guardarlas, como acabamos de ver, en el directorio /var/www/html. 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.


Certificado SSL

Con lo hecho hasta aquí vamos a poder usar nuestro servidor Nginx bajo el protocolo HTTP. Pero si queremos convertirlo en un servidor web seguro, hay que usar el protocolo HTTPS. Lo conseguiremos añadiendo un Certificado SSL de Let's Encrypt.




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 Raspbian, 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 o nombre de dominio virtual 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

PHP

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

sudo apt install php7.3 php7.3-common libapache2-mod-php7.3 php7.3-mysql php7.3-xml php7.3-cli php7.3-curl php7.3-gd php7.3-json php7.3-mbstring php7.3-zip

Y reiniciamos de nuevo el servidor web:

sudo systemctl restart apache2

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 en el directorio /var/www/html. 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

Raspbian, 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 cabría esperar, MariaDB no nos pide que pongamos una contraseña de administrador durante su instalación, así que tendremos que dar un rodeo para añadirla:

sudo mysql_secure_installation

Lo que nos dará como resultado lo siguiente:

Enter current password for root (enter for none):                                 [Pulsamos Enter]
Set root password? [Y/n]                        [pulsamos 'Y' para poner una nueva password]
New password:                                       [Ponemos una contraseña y la anotamos]
Re-enter new password:

IMPORTANTE: no olvidemos anotar la contraseña de root que acabamos de poner. La vamos a necesitar un poco más adelante para crear una base de datos y también al final para entrar en phpMyAdmin.

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

A continuación actualizamos el sistema:

sudo mysql -u root

Como respuesta a este comando, escribiremos lo que se indica a continuación en negrita:

MariaDB [(none)]> USE mysql;
MariaDB [mysql]> UPDATE user SET plugin='' WHERE user='root';
MariaDB [mysql]> FLUSH PRIVILEGES;
MariaDB [mysql]> exit;

El último paso es crear la base de datos y el usuario con su contraseña:

mysql -u root -p

Como antes, aquí también escribimos las órdenes que se muestran en negrita, cambiando mi_password por una contraseña (que anotaremos, ya que vamos a usarla después para configurar WordPress):

Enter password:                [la del administrador (root), que anotamos 2 pasos 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' IDENTIFIED BY 'mi_password';
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 y borramos todo lo que ya no es necesario:

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
sudo rm index.html

Luego le cambiamos el dueño y el grupo:

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

Hecho lo anterior, ya podemos pasar a su configuración. 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 pasamos a una nueva 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 dichos datos: nombre de la base de datos (wordpress), nombre de usuario (wp_user) y contraseña (la que anotamos más arriba). Los dos últimos 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 Ejecutar la instalación.

Una última ventana nos pedirá 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. Podemos entra en el panel de administración escribiendo en el navegador el dominio de la Raspberry seguido de /wp-login.php:

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

Una vez entremos en nuestro flamante CMS, lo primero que haremos será cambiar la opción que viene seleccionada por defecto en los ajustes de los enlaces permanentes (Simple) por la que se muestra en esta imagen (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 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 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.) Conectamos el cable de la impresora a uno de los puertos USB de la RasPi y encendemos ambas máquinas.
  2. 2.) Si no lo tenemos hecho ya antes, debemos asignar una IP fija a la Raspberry, tal y como se explica aquí.
  3. 3.) Procedemos entonces a actualizar el sistema operativo de la forma habitual:
    sudo apt update
    sudo apt upgrade
  4. 4.) Ejecutamos estos dos comandos para instalar y preparar el uso de CUPS:
    sudo apt install printer-driver-gutenprint
    sudo usermod -a -G lpadmin pi
  5. 5.) Desde el escritorio de la RasPi, abrimos el navegador y escribimos la direción
    localhost:631
    para entrar en la interfaz web de CUPS a través del puerto 631.
  6. 6.) 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 otro PC, escribiendo su IP:
    192.168.1.33:631
    Finalmente pulsamos en el botón "Cambiar configuración" para que se activen ambas opciones.
  7. 7.) En la misma pestaña "Administración", en el apartado Impresoras, ahora pulsamos en el botón "Añadir impresora":
  8.      Se nos pedira el usuario y contraseña de acceso a la Raspberry.
  9. 8.) Seleccionamos nuestra impresora en la parte superior (Impresoras locales) y pulsamos en el botón "Siguiente".
  10. 9.) 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. 10.) 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".
    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 e instalarlo manualmente en la Raspberry.
  12. 11.) En la pestaña "Impresoras" debe de aparecer ya la impresora que hayamos seleccionado y configurado 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. Las propiedades de la impresora mostrarán algo como esto:

En el caso de Windows, en cambio, la cosa es más complicada. La impresora compartida no aparecerá por sí misma en los "dispositivos e impresoras" del Panel de control. Tendremos que añadirla nosotros manualmente. Para ello, seguiremos estos pasos:

  1. 1.) Nos vamos al Panel de control - Hardware y sonido - Ver dispositivos e impresoras - Agregar impresora.
  2. 2.) En la ventana que aparece, pulsamos abajo en "La impresora no está en la lista".
  3. 3.) Elegimos "Seleccionar una impresora compartida por nombre" y escrbimos lo siguiente:
    http://192.168.1.33:631/printers/HLL2300D
    sustituyendo 192.168.1.33 por la IP local de nuestra RasPi, y HLL2300D por el nombre de nuestra impresora tal y como aparecía anteriormente en CUPS.
  4. 4.) Pulsamos en el botón "Siguiente" y la seleccionamos en la lista de impresoras, si aparece. Si no aparece en esta lista, pulsamos en el botón "Usar disco" y buscamos la carpeta donde tenemos guardados los drivers para Windows de nuestra impresora.
  5. 5.) Ahora en "Ver dispositivos e impresoras" ya aparecerá y la podremos establecer como impresora predeterminada e imprimir en ella con normalidad.



Servidor VPN PPTP

Una VPN (Virtual Private Network, Red Privada Virtual) nos permitirá conectarnos a la Raspberry Pi desde Internet de una manera segura, mediante una conexión cifrada, y tener acceso a nuestra red local igual que si estuviéramos en casa. De hecho, una VPN es como una extensión de nuestra red local doméstica, pero realizada a través de una red pública (Internet en este caso), lo que nos permite establecer una conexión virtual entre el cliente y el servidor con la funcionalidad y seguridad de una red privada. Una vez conectados a la VPN, todo el tráfico entre el servidor y el cliente (es decir, el tráfico generado por cualquier servicio o aplicación que usemos) viajará cifrado.

Vamos a instalar un servidor VPN del tipo PPTP (Point to Point Tunneling Protocol), ya que es muy fácil de configurar, es rápido y además existen clientes tanto para ordenadores (Windows, Linux u OSX) como para tabletas y smartphones (Android e iOS). Un servidor PPTP emplea cifrado MPPE (Microsoft Point to Point Encryption) de 128 bits y el protocolo de autentificación MS-CHAPv2 (Microsoft Challenge Handshake Authentication Protocol), que, aunque no son tan seguros como los empleados en OpenVPN, por ejemplo, ofrecen una seguridad más que suficiente para un usuario doméstico. La fortaleza de este sistema se basa en utilizar una buena contraseña que sea capaz de resistir un ataque de diccionario.

Lo primero que haremos será instalar el paquete pptpd:

sudo apt install pptpd

Luego editamos el fichero de configuración /etc/pptpd.conf:

sudo nano /etc/pptpd.conf

Tenemos que asegurarnos de que dicho fichero contenga, descomentadas, las siguientes líneas:

localip 192.168.1.33
remoteip 192.168.1.210-220

La primera línea (localip) es la dirección IP local del servidor en nuestra Raspberry Pi, mientras que la segunda (remoteip) es el rango de direcciones IP que el servidor asignará a los clientes que se conecten por VPN. Ello implica, naturalmente, que las direcciones IP especificadas deben estar en consonancia con las usadas en nuestra red local.

Después modificaremos el fichero de configuración de opciones del demonio pptpd (/etc/ppp/pptpd-options):

sudo nano /etc/ppp/pptpd-options

Aquí, si lo deseamos, podemos cambiar el nombre del servidor (que por defecto es pptpd) por otro distinto, por ejemplo:

name mivpn

Luego, más abajo, debemos comprobar que las siguientes líneas estén descomentadas, añadiendo en las dos últimas unas DNS válidas (en este caso hemos usado las de Google):

require-mschap-v2
require-mppe-128
.............
ms-dns 8.8.8.8
ms-dns 8.8.4.4

A continuación editaremos el archivo /etc/ppp/chap-secrets:

sudo nano /etc/ppp/chap-secrets

En él añadiremos el nombre del usuario que vamos a utilizar para acceder, el nombre del servidor (que debe coincidir con el indicado en el fichero anterior), la contraseña del usuario y la IP asignada al mismo, que podemos sustituir por un asterisco (*) para que sea el propio servidor el que le asigne una IP dentro del rango que especificamos antes. Hay que tener en cuenta que los espacios se introducen mediante la tecla tabulador:

usuario          mivpn           contraseña          *

Podemos incluir varios usuarios, cada uno en una línea distinta, que serán específicos del servicio VPN, por lo que no tienen por qué coincidir (ni los nombres ni sus contraseñas) con los usuarios que ya tengamos definidos en el sistema.

Antes de poner en marcha el servidor, abrimos el fichero /etc/sysctl.conf:

sudo nano /etc/sysctl.conf

y nos aseguraremos de que la siguiente línea esté descomentada para que el sistema sea capaz de redirigir los datos entre nuestro dispositivo y la red local:

net.ipv4.ip_forward=1

Una vez guardado el archivo (Ctrl+o, Intro, Ctrl+x), ya podemos conectarnos con los demás equipos que forman nuestra red VPN, pero no podremos salir desde ella a Internet. Para lograrlo, hay que introducir una regla en iptables, así que editamos el fichero correspondiente:

sudo nano /etc/rc.local

y añadimos casi al final la siguiente línea:

iptables -t nat -­A POSTROUTING ­-s 192.168.1.0/24 ­-o eth0 ­-j MASQUERADE

Debe quedar así:


donde 192.168.1.0/24 representa toda nuestra red local y eth0, la interfaz de salida a Internet que estamos usando (en este caso, el adaptador Ethernet).

Guardamos los cambios y reiniciamos el servicio:

sudo service pptpd restart
sudo sysctl -p

Finalmente abriremos el puerto 1723 en el router, dirigiéndolo a la IP local de la RasPi para permitir el acceso desde Internet. También lo abriremos en el cortafuegos, si lo tenemos instalado, y con ello ya tendremos nuestro servidor VPN totalmente configurado y listo para acceder a él.

IMPORTANTE: el servidor permanecerá activo hasta que se apague la Raspberry, pero no se ejecuta automáticamente tras cada arranque de la máquina, por lo que habrá que iniciar el servicio manualmente cuando queramos usarlo:

sudo service pptpd start

Y si por cualquier motivo en algún momento deseamos desactivarlo, simplemente lo detenemos:

sudo service pptpd stop

Configurar los clientes

A partir de este momento nos será posible acceder fácilmente al servidor usando, por ejemplo, nuestro smartphone o tableta. En el caso de Android, lo haremos a través de Ajustes - Conexiones de red - Más redes - VPN, donde podemos añadir un perfil y luego activarlo cada vez que deseemos conectar con el servidor VPN de la Raspberry Pi. Para ello, añadimos una nueva VPN, le ponemos un nombre, seleccionamos el tipo PPTP, escribimos la dirección del servidor, marcamos "Cifrado PPP (MPPE)", marcamos también "Mostrar opciones avanzadas" y aquí rellenamos las dos últimas: en "Servidores DNS" podemos poner, por ejemplo, el de Google (8.8.8.8); y en "Rutas de desvío" indicaremos nuestra red local (192.168.1.0/24).

Si vamos a usar Windows, la configuración es bastante más compleja, así que lo explicaremos incluyendo algunas capturas de pantalla. Tendremos que ir al Panel de Control - Redes e Internet - Centro de redes y recursos compartidos. Pulsamos en "Configurar una nueva conexión o red" y luego en "Conectarse a un área de trabajo":


Pulsamos el botón "Siguiente" y luego hacemos clic en "Usar mi conexión a Internet (VPN)". En la nueva ventana escribimos la dirección del servidor y un nombre cualquiera para identificar la conexión VPN que estamos creando:


Una vez creada, debemos volver al "Centro de redes y recursos compartidos"; allí hacemos clic en el margen izquierdo en "Cambiar configuración del adaptador" y aparecerá la conexión VPN que acabamos de crear. Pulsamos sobre ella con el botón derecho del ratón y elegimos "Propiedades". En la pestaña "Seguridad" haremos los cambios pertinentes para que quede así:


Luego pinchamos en la pestaña "Funciones de red", marcamos el "Protocolo de Internet 4 (TCP/IPv4)" y hacemos clic en el botón "Propiedades"; volvemos a pinchar en el botón "Propiedades avanzadas" de la siguiente ventana y a continuación, en la pestaña "Configuración de IP", desmarcamos la casilla de verificación "Usar la puerta de enlace predeterminada en la red remota", de modo que quede así:


Ya sólo hay que hacer clic en el botón "Aceptar" varias veces hasta volver a las "Conexiones de red". Entonces la conexión VPN estará lista para usarse.

Por último, en Ubuntu iremos a las "Conexiones de red" y selecionamos la pestaña "VPN". Hacemos clic en el botón "Añadir", dejamos seleccionado el "Protocolo de túnel punto a punto (PPTP)"y hacemos clic en el botón "Crear":


En "Pasarela" escribimos la dirección del servidor, y más abajo, el usuario y la contraseña:


Luego hacemos clic en el botón "Avanzado" y seleccionamos las opciones necesarias para que quede así:


Le damos a "Aceptar" y luego a "Guardar". Ya tenemos la conexión VPN creada.




Servidor OpenVPN

Recordemos, como dijimos antes, que 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 local 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 "esnifando" tráfico en la misma.

Como también indicamos en el apartado anterior, montar un servidor VPN mediante OpenVPN es mucho más seguro que hacerlo utilizando el protocolo PPTP. Pero OpenVPN tiene en contra el problema de la complejidad a la hora de realizar su instalación y configuración. Sin embargo, podemos obviar este problema si recurrimos a PiVPN, un script que lleva a cabo todo el proceso de una forma simple y sencilla, lo que nos ahorra el trabajo de realizar manualmente, y paso a paso, toda la compleja configuración del servidor.


Requisitos previos

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

  1. 1.) Instalar y configurar el Sistema Operativo. Necesitamos tener instalado un SO, como puede ser Raspbian (preferiblemente, aunque se pueden usar también otros sistemas). Para los que no tengan experiencia previa con la Raspberry, en los primeros apartados del menú Sistema explicamos cómo hacer todo el proceso: instalar el SO, acceder por SSH a la RasPi y realizar una configuración básica de la misma.
  2. 2.) Asignarle a la Raspberry Pi una IP estática, tal y como se detalla en este apartado de nuestra web.
  3. 3.) 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 OpenVPN 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.dev | 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 nos ofrecerá información que hemos de aceptar. Al final mostrará la IP estática que hemos configurado previamente y el Gateway (indicamos ).
  2. [b] El usuario local que va a usarse para la configuración del servidor (pi por defecto).
  3. [c] Si deseamos activar o no las actualizaciones automáticas ( por defecto).
  4. [d] El protocolo que queremos emplear (UDP o TCP, preferiblemente el primero), así como el puerto (1194 por defecto, aunque conviene cambiarlo).
  5. [e] Si queremos utilizar autentificación con clave de curva elíptica. Es necesario que los clientes soporten esto; así que, en caso de duda, elegir No.
  6. [f] El nivel de cifrado que deseamos usar, que será diferente según lo que hayamos elegido en el punto anterior (256/2048 bits, según el caso, son los recomendados). La creación de las claves de cifrado (si hemos optado antes por no usar clave de curva elíptica) es un proceso bastante lento y puede tardar varios minutos.
  7. [g] El tipo de dominio que usaremos para acceder al servidor (elegimos DNS Entry).
  8. [h] 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 3.
  9. [i] Elegimos un servidor de DNS concreto de la lista que se nos ofrece (Google, OpenDNS,...).
  10. [j] Se nos preguntará si deseamos agregar un dominio de búsqueda personalizado. Contestamos No.
  11. [k] Seremos informados sobre cómo añadir un nuevo usuario y, finalmente, se nos preguntará si deseamos reiniciar el sistema (contestamos ) y aceptamos.

  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, cuántos días debe durar el certificado (1080 por defecto) y su correspondiente contraseña. De esta manera se generará la clave privada del usuario que acabamos de crear, que se guardará en la carpeta /home/pi/ovpns y que consta de un fichero con la forma nombre_usuario.ovpn.

  1. 3.) Instalar los clientes en todos aquellos dispositivos (PCs, portátiles, smartphones o tabletas) desde los que queramos acceder al servidor. Para el sistema Android podemos usar varias apps, como por ejemplo la oficial o bien esta otra, que es algo más complicada de configurar. Para iOS también está disponible la app oficial. En el caso de Linux podremos configurar el cliente como se indica aquí. Y en lo que respecta a Windows, el cliente lo podremos descargar desde este enlace y luego nos conectaremos según se explica en esta guía.

  1. 4.) Importar las claves. Una vez instalado el cliente correspondiente en cada dispositivo, desde este tenemos que importar los distintos ficheros que contienen la clave privada de cada usuario (nombre_usuario.ovpn) que vamos a usar para realizar la conexión al servidor y que se encuentran, como vimos antes, en la carpeta /home/pi/ovpns de la RasPi.

    Este proceso podemos hacerlo desde un ordenador con Linux conectándonos a la Raspberry y descargándonos los ficheros mediante el comando scp:
    scp -P xxxx pi@192.168.1.33:/home/pi/ovpns/* /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.

    Pero si ya estamos en la RasPi y lo que deseamos es exportar los archivos a otra máquina Linux, entonces el comando sería:
    scp -P xxxx /home/pi/ovpns/* usuario@192.168.1.28:/home/usuario
    Como antes, 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 lo que respecta a Windows, podemos recurrir a la aplicación WinSCP, que es un cliente SFTP/SCP (es decir, un sistema FTP seguro) que funciona a través del servidor SSH y que resulta muy práctico para transferir archivos a/desde la Raspberry, siendo además muy fácil de usar. Es similar a usar el comando scp de Linux, pero en modo gráfico.

    En el caso de Android, podríamos recurrir a una app parecida a la de Windows: AndFTP. En última instancia, en caso de tener problemas con esta aplicación, siempre podremos hacerlo "manualmente" copiando los ficheros en un pendrive y de ahí pasarlos al smartphone o la tableta mediante un cable OTG.

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

pivpn uninstall

Usuarios

En el apartado 2.) hemos visto 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

Y luego, mediante el siguiente comando, revocaremos su certificado, lo que implica que dicho usuario ya no podrá volver a conectarse al servidor VPN:

pivpn revoke nombre_usuario

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



Servidor FTP

Para compartir archivos desde fuera de la red local, es decir, desde Internet, no hay nada mejor que 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 carpetas que deseemos compartir; la última (recibidos) la dejaremos vacía para que los usuarios nos envíen a nosotros sus ficheros.


Usuario de acceso

Al instalar proftpd se crea por defecto un usuario llamado ftp. Este será el usuario habitual para el acceso a nuestro servidor, que podrá entrar únicamente en las carpetas que hemos creado anteriormente. Editamos el fichero /etc/passwd:

sudo nano /etc/passwd

nos vamos al final del mismo y comprobamos que dicho usuario tenga puesto su directorio correspondiente (en este caso, /media/hdusb/ftp) y además le asignaremos un intérprete de comandos falso (/bin/false), de modo que quede así:

ftp:x:111:65534::/media/hdusb/ftp:/bin/false

Guardamos los cambios realizados (Ctrl+o, Intro, Ctrl+x) y continuamos.

Lo anterior implica que tenemos que añadir el mencionado intérprete de comandos (/bin/false) al final del fichero /etc/shells. Así que editamos dicho fichero:

sudo nano /etc/shells

y lo añadimos al final del mismo. Hecho esto, guardamos de nuevo los cambios (Ctrl+o, Intro, Ctrl+x).

Ya sólo nos queda poner una contraseña al usuario ftp, pues no queremos permitir accesos anónimos en nuestro servidor:

sudo passwd ftp

y escribimos la contraseña dos veces.


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 proceder a configurar el servidor editando el fichero proftpd.conf:

cd /etc/proftpd
sudo nano proftpd.conf

Como medida de seguridad, comprobaremos que estén presentes las siguientes líneas, que hacen que todos los usuarios que accedan al servicio queden enjaulados en la carpeta que hemos creado antes para que contenga el árbol de directorios del servidor:

DefaultRoot                            /media/hdusb/ftp
DefaultChdir                           /media/hdusb/ftp

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

RootLogin                               off

Modificaremos la línea PassivePorts, que se refiere al rango de puertos pasivos que usará el servidor. La descomentamos, quitándole la almohadilla (#), y ponemos el rango que creamos adecuado; por ejemplo este:

PassivePorts                           25000 30000

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

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

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

También configuraremos el tamaño máximo de los archivos de descarga/subida, poniendo limitaciones al usuario ftp y sin ninguna limitación para el resto:

# Limitaciones de los archivos de descarga y subida
MaxRetrieveFileSize                 100 Gb user ftp
MaxRetrieveFileSize                 *
MaxStoreFileSize                     50 Gb user ftp
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 ftp
     AllowUser jcarlos
     DenyAll
</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 (Ctrl+o, Intro, Ctrl+x).


Puesta en marcha

Ahora ponemos en marcha el servidor FTP y comprobaremos que no haya ningún error:

sudo service proftpd restart

Es posible que obtengamos un error relativo a "memcache". Si es así, tendremos que editar el fichero /etc/proftpd/modules.conf:

sudo nano /etc/proftpd/modules.conf

En él buscamos la línea LoadModule mod_tls_memcache.c y la comentamos, colocándole delante el signo de la almohadilla (#), de modo que quede así:

#LoadModule mod_tls_memcache.c

Guardamos el fichero (Ctrl+o, Intro, Ctrl+x) y reiniciamos de nuevo el servidor:

sudo service proftpd restart

Como siempre, recordemos que tenemos que abrir los puertos pasivos indicados antes (del 25000 al 30000) y los puertos 20 y 21 en el router, redireccionándolos a la IP local de la Raspberry Pi para permitir el acceso desde Internet. Si tenemos instalado un cortafuegos, también debemos abrirlos en el mismo.

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 del server, 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]



Transmission

Transmission es una aplicación cliente-servidor para el intercambio de archivos torrents en redes P2P. Existen distintas versiones de este programa. Nosotros vamos a instalar la que se maneja a través del navegador mediante una interfaz web. Esta versión se instala en el sistema como un servicio o "demonio" (daemon en inglés), por lo que consume muy pocos recursos, además de poseer la ventaja añadida de que podemos usarlo sin tener un escritorio instalado en Raspbian.

Para su instalación simplemente escribiremos este comando:

sudo apt -y install transmission-daemon

Una vez instalado, arrancará automáticamente, así que para configurarlo adecuadamente, antes hay que detenerlo:

sudo service transmission-daemon stop

Como lugar donde guardar los torrents, podemos utilizar un disco duro USB conectado a la Raspberry Pi (si no lo tenemos instalado, aquí se explica cómo formatearlo y montarlo). Suponiendo que lo tenemos montado en la ruta /media/hdusb, sólo tendremos que crear dentro de ella una carpeta específica para almacenar las descargas y otorgarle luego los permisos adecuados:

cd /media/hdusb
sudo mkdir torrents
sudo chmod 777 torrents

Hecho lo anterior, ya podemos llevar a cabo la configuración del servicio. Para ello editamos el fichero correspondiente:

sudo nano /etc/transmission-daemon/settings.json

Las líneas indicadas a continuación son las que debemos editar en este fichero. Al hacerlo, hay que tener en cuenta que, por motivos de seguridad, en rpc-password y rpc-username deberíamos poner una contraseña y un nombre distintos de los que aparecen por defecto. El tamaño de la memoria caché (cache-size-mb) conviene aumentarlo, pues así se tendrán que hacer menos accesos al dispositivo de almacenamiento (aunque, por contra, aumentará el consumo de memoria RAM). En cuanto a peer-port y rcp-port, estos parámetros corresponden, respectivamente, al puerto de conexión para las descargas de torrents y al puerto de acceso a la interfaz web de Transmission. Podemos cambiarlos o dejar los que vienen por defecto. Tras estos cambios, el resultado sería este:

“cache-size-mb”: 12,
"download-dir": "/media/hdusb/torrents",
"incomplete-dir-enabled": false,
"peer-port": 44027,
"rpc-authentication-required": true,
"rpc-bind-address": “0.0.0.0″,
"rpc-enabled": true,
"rpc-password": "contraseña",
"rcp-port": 9091,
"rpc-username": "nombre",
"rpc-whitelist-enabled": false,

Guardamos el fichero con los cambios realizados (Ctrl+o, Intro, Ctrl+x), arrancamos de nuevo el servicio:

sudo service transmission-daemon start

y ya podemos acceder mediante el navegador del PC a la interfaz web de descargas de Transmission, escribiendo como dirección la IP local de nuestra Raspberry, seguida por dos puntos (:) y el puerto 9091 indicado antes. Así:

http://192.168.1.33:9091

En la parte superior veremos una barra de iconos:

El primero por la izquierda es el que nos permite añadir los torrents, bien sea examinando nuestro disco duro hasta localizar el fichero o bien escribiendo directamente su URL.

En la parte inferior tenemos otra barra con varios iconos más pequeños:

El segundo por la izquierda (el que representa una herramienta) es el que nos permite configurar Transmission de una forma gráfica. Pero aquí (contrariamente al fichero de configuración que vimos antes) las posibilidades de configuración son más limitadas. Entre las cosas que podemos modificar está, por ejemplo, el puerto para las descargas, que, como es de rigor, deberemos redireccionar en el router a la IP de la RasPi.

Además de usar el navegador, también podemos utilizar una aplicación externa llamada Remote Transmission para gestionar las descargas. En el caso de Windows, se puede bajar de SourceForge, y si usamos un smartphone o una tableta con sistema operativo Android, podemos descargar esta misma app desde Google Play (Remote Transmission) o, si lo preferimos, usar alguna otra de las muchas existentes, como por ejemplo (Transmission Remote), que es muy similar a la anterior. Es cuestión de probar varias y quedarnos con la que nos resulte más cómoda de usar.


Recibir un email al terminar las descargas

Algo muy interesante que podríamos añadir ahora es la posibilidad de recibir un correo electrónico cuando se hayan descargado cada uno de los torrents que se están bajando. Dicho correo nos indicará el nombre del fichero o carpeta que se acaba de descargar en nuestra Raspberry.

Para lograrlo, lo primero que hemos de hacer es seguir los pasos para instalar un sistema de envío de correos desde la terminal. Una vez hecho esto, detenemos Transmission para realizar algunos cambios:

sudo service transmission-daemon stop

Vamos a editar el fichero de configuración:

sudo nano /var/lib/transmission-daemon/info/settings.json

y a modificar estas dos líneas, de manera que queden así:

"script-torrent-done-enabled": true,
"script-torrent-done-filename": "/usr/local/bin/aviso.sh",

Creamos (en la ruta indicada en la línea anterior) el fichero que enviará el aviso por email:

cd /usr/local/bin/
sudo nano aviso.sh

cuyo contenido será este:

#!/bin/bash
echo "$TR_TORRENT_NAME descargado" | mail -s "Transmission" micorreo@gmail.com

Ahora le cambiamos los permisos y el dueño al archivo que acabamos de crear:

sudo chmod 755 aviso.sh
sudo chown pi aviso.sh

Cambiaremos también el propietario por defecto de las descargas. Para ello editamos el siguiente fichero:

sudo nano /etc/init.d/transmission-daemon

y dentro del mismo modificamos el usuario que, en adelante, será el dueño de las descargas:

USER=pi

Por último, cambiamos el propietario de los ficheros de configuración y de la carpeta de descargas:

sudo chown pi -R /var/lib/transmission-daemon/info/
sudo chown pi -R /etc/transmission-daemon/settings.json
sudo chown pi -R /media/hdusb/torrents/

No debemos olvidar reiniciar el servicio antes de poder usar Transmission de nuevo:

sudo service transmission-daemon restart



Samba

Samba es un servicio libre que implementa el protocolo de archivos compartidos de Microsoft Windows, llamado SMB o CIFS en los sistemas UNIX/Linux. Este protocolo nos va a permitir compartir archivos y carpetas con los demás ordenadores de nuestra red.

Vamos, pues, a instalar el servidor y a crear una carpeta en la Raspberry para poner en ella todo aquello que queramos compartir con cualquiera de los demás ordenadores de nuestra red local, de manera que estos puedan acceder a dichos recursos compartidos.

Primero instalamos Samba:

sudo apt install samba samba-common-bin

Dado que pi es el usuario por defecto del sistema Raspbian, vamos a aprovechar y lo añadimos también a Samba:

sudo smbpasswd -a pi

Nos pedirá una contraseña. Escribimos la misma que tenemos ya establecida para el usuario pi en el sistema.

Si tenemos más usuario creados en el sistema, podemos añadirlos también, si lo deseamos, de la misma forma que lo hemos hecho con el anterior.


Compartir carpetas

Para ello, editamos el fichero de configuración de Samba:

sudo nano /etc/samba/smb.conf

Vamos a compartir una carpeta y hacerla pública. Supongamos que tenemos una carpeta en nuestro directorio personal con archivos de música (/home/pi/musica) y queremos compartirla con los demás usuarios de la red. Nos vamos al final del fichero de configuración de Samba y añadimos estas líneas:

[musica]
comment = carpeta para compartir música
path = /home/pi/musica
browseable = yes
read only = yes
writeable = no
guest ok = yes
public = yes

Como se puede observar, los usuarios que accedan a la carpeta podrán ver y descargar archivos, pero no pueden hacer modificaciones en ella (read only = yes, writeable = no).

En el caso de que quisiéramos compartir un disco duro conectado a la Raspberry, lo haríamos igual que en el ejemplo anterior, sólo que en este caso tendríamos que cambiar la identificacióin de la carpeta que queremos compartir, usando un nombre apropiado que nos sirva de referencia ([nombre_carpeta]), un comentario descriptivo de la misma (comment) e indicar luego su ruta exacta (path):

[hdusb]
comment = carpeta para compartir el disco duro
. . . . . . . . . .
path = /media/hdusb
. . . . . . . . . .

Así compartiríamos todo el contenido del dispositivo. Pero si queremos acceder sólo a una carpeta del mismo (y sus correspondientes subcarpetas, si las hay), escribiríamos esto otro:

[datoshd]
comment = compartir la carpeta "datos" del HD
. . . . . . . . . .
path = /media/hdusb/datos
. . . . . . . . . .

Por otra parte, en caso de que queramos que la carpeta sea privada y que sólo el/los usuario/s autorizados accedan a la misma, podríamos hacer estos cambios:

[musica]
comment = carpeta para guardar música
path = /home/pi/musica
browseable = yes
read only = no
writeable = yes
guest ok = no
public = no
valid users = pi
admin users = pi
create mask = 0644
directory mask = 0755

En este caso sólo se admite el acceso del usuario pi, aunque podríamos añadir más usuarios (siempre que hayan sido creados antes del modo que vimos al principio). A este usuario se le conceden permisos tanto de lectura como de escritura (read only = no, writeable = yes). Y por otro lado, create mask y directory mask se refieren a los permisos para la creación de nuevos ficheros y carpetas, respectivamente, desde Samba. Para que los permisos de escritura sobre el recurso compartido sean efectivos, deben coincidir con los permisos que posee la carpeta en el sistema de ficheros de Raspbian. De no ser así, se aplicarán los permisos más restrictivos.

Ya sólo queda guardar el archivo de configuración (Ctrl+o, Intro, Ctrl+x) y reiniciar el servidor:

sudo service smbd restart

Ahora la carpeta estará compartida y podremos usarla para intercambiar ficheros con otros ordenadores de nuestra red. Podemos comprobarlo accediendo a la carpeta mediante la IP local de la Raspberry. En el Explorador de Archivos de Windows, la RasPi aparecerá en la sección de Red; y también podremos acceder escribiendo directamente su IP en la barra superior, así:

\\192.168.1.33

Si la carpeta es privada, para tener acceso a la misma debemos escribir un nombre de usuario y contraeña que hayamos autorizado previamente en el momento de definir dicha carpeta.


Evitar compartir la carpeta de usuario

Normalmente, cuando instalamos el servidor Samba se comparte por defecto la carpeta de los usuarios (/home/pi en nuestro caso). Si queremos evitar esto, tenemos que hacer algunos cambios en el fichero de configuración:

sudo nano /etc/samba/smb.conf

Buscamos con Ctrl+w la línea [homes] y comentamos (con ; o con #), a partir de aquí, todos los valores referentes al directorio home de los usuarios:

#[homes]
#     comment = Home Directories
#     browseable = no
. . . . . .
#     read only = yes
. . . . . .
#     create mask = 0700
. . . . . .
#     directory mask = 0700
. . . . . .
#     valid users = %S

Ahora tendremos que reiniciar el servidor para que los cambios surtan efecto:

sudo service smbd restart

Añadir una papelera

Una interesante utilidad que podemos añadir a Samba es una papelera, lo que nos permitirá recuperar archivos o carpetas que hayamos borrado previamente, ya sea de forma voluntaria o accidental. Tomando el mismo ejemplo que hemos usado antes para crear una carpeta privada, bastará con añadir cuatro líneas al final (las escritas en negrita) para crear la papelera, de modo que quedará así:

[musica]
comment = carpeta para guardar música
path = /home/pi/musica
browseable = yes
read only = no
writeable = yes
guest ok = no
public = no
valid users = pi
admin users = pi
create mask = 0644
directory mask = 0755
vfs object = recycle
recycle:repository = papelera
recycle:keeptree = true
recycle:versions = true

Como es habitual, tendremos que reiniciar de nuevo el servicio para que los cambios surtan efecto:

sudo service smbd restart

AVISO: Es posible que la carpeta que contiene la papelera no se cree hasta que borremos algún elemento por primera vez.




DLNA

Según la Wikipedia, "DLNA (Digital Living Network Alliance) o Alianza para el estilo de vida digital en red, en español, es una asociación de fabricantes de electrónica e informática sin ánimo de lucro fundada por Sony en junio de 2003. Su objetivo es definir directrices de interoperabilidad que permitan compartir medios digitales entre dispositivos de consumo como ordenadores, impresoras, cámaras, teléfono móviles y otros dispositivos multimedia." Se trata, pues, de crear un sistema para transmitir contenido multimedia (vídeos, películas, música o fotos) a través de la red y que pueda ser reproducido en dispositivos como PCs, smart TV, videoconsolas, tabletas o smartphones.

Como es obvio, lo primero que haremos es instalar el servidor DLNA en nuestra Raspberry. Debido a su escaso consumo de recursos, vamos a elegir para ello el servidor miniDLNA:

sudo apt install minidlna

Una vez instalado, debemos proceder a la configuración del servidor:

sudo nano /etc/minidlna.conf

En el fichero de configuración buscamos la línea en la que se indica dónde se encuentran ubicados nuestros archivos multimedia. Será una línea similar a esta:

media_dir=/var/lib/minidlna

Naturalmente, deberemos cambiarla por el directorio (o directorios, si son varios) donde cada uno tenga guardados sus archivos. En nuestro caso, tenemos un disco duro USB y un pendrive conectados a dos de los puertos USB de la RasPi, con sendas carpetas que incluyen, respectivamente, películas y música, por lo que nos quedaría así:

media_dir=V,/media/hdusb/peliculas
media_dir=A,/media/pen/musica

La V de la primera línea significa vídeo y la A de la segunda, audio. Y es que la configuración admite filtros de indexación de contenidos: A para audio, V para vídeo y P para fotos. Si no indicamos nada, se indexará todo.

Ahora le daremos un nombre al servidor, para que cuando accedamos a él desde otro dispositivo nos sea fácil de encontrar. Para ello bajamos unas líneas hasta que localizamos la siguiente:

#friendly_name=

Descomentamos la línea quitándole la almohadilla (#) y añadimos el nombre que queramos darle a nuestro servidor DLNA:

friendly_name=RPi DLNA Server

Ahora, un poco más abajo, le decimos que automáticamente vaya añadiendo el nuevo contenido que metamos en las carpetas indicadas antes, para lo que descomentamos también estas dos líneas, poniendo en la segunda el intervalo de tiempo (en segundos):

inotify=yes
notify_interval=600

Guardamos el fichero (Ctrl+o, Intro, Ctrl+x) y ya tenemos el servidor listo para funcionar, así que lo arrancamos:

sudo service minidlna start

La indexación de contenidos hemos de hacerla manualmente mediante este comando:

sudo service minidlna force-reload

Como es habitual en cualquier servicio, el servidor DLNA admite distintos parámetros: podemos detenerlo (stop), iniciarlo (start), conocer su estado (status) o reiniciarlo después de haber hecho alguna modificación en la configuración (restart):

sudo service minidlna parámetro

Finalmente, no hay que olvidar abrir el puerto 8200/TCP si estamos usando un cortafuegos.

Es posible utilizar una gran cantidad de clientes para acceder al servidor DLNA que acabamos de instalar en nuestra Raspberry Pi. En Windows podríamos usar Windows Media Center o el propio Reproductor multimedia del sistema; en el caso de Android, DLNA Player o bien MediaHouse UPnP / DLNA Browser, por poner un par de ejemplos. Y si tenemos una Smart TV también podremos acceder desde ella a los contenidos del servidor.




Pi-hole

Pi-hole es un sistema para convertir la Raspberry Pi en un servidor de DNS caché capaz de filtrar y bloquear la publicidad a nivel de red. Una vez instalado y configurado, sólo tendremos que poner la IP local de la RasPi como servidor de DNS en el router o bien ponerla manualmente en cada dispositivo de nuestra red local. Las peticiones DNS pasarán entonces por la Raspberry y esta actuará como un filtro antipublicidad, al estilo de las extensiones "adblock" de los navegadores, pero con varias ventajas añadidas sobre estos:

  1. 1ª) Servirá para todos los aparatos que tengamos conectados a nuestra LAN (sin necesidad de instalar nada extra en ellos).
  2. 2ª) Las webs que visitemos no serán capaces de detectar que estamos bloqueando su publicidad.
  3. 3ª) También sirve para detener algunos intentos de instalar malware que realizan ciertas webs maliciosas.
  4. 4ª) Ofrece la posiblidad de bloquear aquellas páginas web que no queramos que visiten nuestros hijos o la gente que esté conectada a nuestra red local.
  5. 5ª) Incluso bloquea la publicidad de las apps gratuitas que tengamos instaladas en el smartphone o la tableta.


Requisitos previos

Antes de instalar Pi-hole tenemos que cumplir estos dos requisitos:

  1. 1.) Instalar y configurar el Sistema Operativo. Necesitamos tener instalado un SO, como puede ser Raspbian (preferiblemente, aunque se pueden usar también otros sistemas). Para los que no tengan experiencia previa con la RasPi, en los primeros apartados del menú Sistema explicamos cómo hacer todo el proceso: instalar el SO, acceder por SSH a la Raspberry y realizar una configuración básica de la misma.
  2. 2.) Asignarle a la Raspberry Pi una IP estática, tal y como se detalla en este apartado de nuestra web.

Instalación

El proceso de instalación y configuración consta de dos pasos:

  1. 1.) Instalar Pi-hole. En el caso de que usemos la Raspberry Pi 2/3 ejecutaremos este script desde la línea de comandos:
    curl -sSL https://install.pi-hole.net | bash
    Si en lugar de una Raspberry 2/3 estamos usando un modelo más antiguo (por ejemplo, la versión 1/1B+), entonces debemos utilizar este otro script:
    curl -L https://install.pi-hole.net | bash

    NOTA: También es posible realizar la instalación mediante este otro método, que primero descarga el script y después lo ejecuta:
    wget -O basic-install.sh https://install.pi-hole.net
    sudo bash basic-install.sh
    Inicialmente se harán ciertas comprobaciones y se instalarán varios paquetes. Después simplemente se nos informará de algunos detalles, con lo que bastará con aceptar y continuar.
  1. [a] En caso de que tengamos varias interfaces de red, lo primero que se nos preguntará es la interfaz que deseamos usar (por defecto será eth0).
  2. [b] El servidor de DNS que preferimos (Google, OpenDNS,...).
  3. [c] Un conjunto de sitios que poseen listas de bloqueo (aparecen seleccionados todos por defecto).
  4. [d] Los protocolos que se utilizarán (IPv4 e IPv6), marcados ambos por defecto.
  5. [e] Si queremos usar la IP estática previamente configurada y el Gateway (indicamos ).
  6. [f] También si deseamos instalar la interfaz de administración web (recomendado On).
  7. [g] O si se instala el servidor web lighttpd (On es lo recomendado).
  8. [h] Si queremos activar el fichero log de peticiones (una vez más se recomienda On).
  9. [i] Finalmente, el modo de privacidad para FTL (0 Show everything por defecto).
  10. [j] Comenzará la instalación de los paquetes, y tras ello, se nos indicará la contraseña de acceso a las distintas opciones disponibles en el menú de la interfaz web de la aplicación.

  1. ATENCIÓN: Si al final de la instalación diera un error relativo a FTL y no apareciera la ventana con la contraseña de acceso (lo que indicaría que Pi-hole no se ha instalado correctamente), hay que desinstalarlo (pihole uninstall), reiniciar la RasPi e instalar de nuevo. Pero si no funciona el comando de desinstalación, entonces reiniciamos el sistema y reinstalaremos de nuevo directamente, sin más. Puede que aun así no podamos reinstalar porque el error de instalación anterior nos ha dejado sin conexión a Internet; entonces, para poder hacer la reinstalación, previamente habrá que editar el fichero /etc/dhcpcd.conf y poner un servidor de DNS válido (por ejemplo, static domain_name_servers=8.8.8.8).

  1. 2.) Usar Pi-hole como servidor DNS predeterminado, lo que podremos hacer, como dijimos al principio, de dos maneras: o bien poniendo la IP de la Raspberry Pi como servidor de DNS en el router (en lugar de las DNS que suele traer por defecto, que serán las de nuestro ISP) o bien poner dicha IP manualmente como servidor DNS en cada uno de los dispositivos conectados a nuestra red local (PCs, portátiles, Smart TV, smartphones, tabletas...).

Interfaz web y contraseña

Para comprobar que el sistema está en marcha podemos acceder a la interfaz web de administración desde el navegador de la propia Raspberry:

http://localhost/admin

o bien escribiendo la dirección IP local de la RasPi en el navegador de cualquier otro dispositivo conectado a nuestra LAN:

http://192.168.1.33/admin

Aquí podremos iniciar sesión (Login) y tener acceso a un menú con las distintas posibilidades que nos ofrece Pi-hole.

Para cambiar la contraseña de inicio de sesión de la interfaz web usaremos este comando desde la terminal:

pihole -a -p contraseña

Actualizar, desinstalar, reinstalar

Cuando exista una nueva versión de Pi-hole, nos será posible actualizar, también desde la terminal, mediante la siguiente orden:

pihole -up

Y si por algún motivo tenemos la necesidad de desinstalar, usaremos este comando:

pihole uninstall

Durante la desinstalación, cuando se nos pregunte "Do you wish to go through each dependency for removal?... [Y/n]", contestaremos negativamente (n) y una vez acabado el proceso, reiniciamos el sistema.

Si tras la desinstalacción queremos volver a reinstalar, sólo tenemos que ejecutar de nuevo el script que indicamos al principio:

curl -sSL https://install.pi-hole.net | bash



OpenVPN + Pi-hole

Más arriba hemos visto cómo instalar cada uno de estos dos servidores. Usándolos por separado, de forma individual, ambos funcionan correctamente. Pero si deseamos utilizarlos a la vez, 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 OpenVPN. Para que todo funcione como debe, tendremos que realizar algunos cambios.


1.- Instalar OpenVPN y conocer su IP

Instalamos OpenVPN y, una vez terminado el proceso, averiguamos su dirección IP:

ip a show dev tun0

Esto nos devolverá una serie de líneas de texto, una de las cuales será similar a esta:

inet 10.8.0.1/24 brd 10.8.0.255 scope global tun0

En ella vemos que la dirección IP del servidor VPN es 10.8.0.1


2.- Instalar Pi-hole

En el apartado anterior ya vimos como instalar Pi-hole. Una vez finalizado el proceso de instalación, pasamos a la siguiente etapa, que es la que nos permitirá usar ambos servicios conjuntamente, de manera que cada uno haga correctamente su función.


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

Hasta ahora habremos observado que ambos servicios funcionan bien de forma independiente, pero si nos conectamos al servidor VPN y usamos el navegador, comprobaremos que los anuncios no están siendo bloqueados. Esto es así porque el servidor de DNS definido en la configuración de OpenVPN no es el adecuado para esta situación. Para remediarlo, debemos modificar la configuración del servidor VPN para que haga referencia a la subred que éste utiliza por defecto. Para ello editamos el siguiente fichero:

sudo nano /etc/openvpn/server.conf

En él modificamos las dos líneas que se muestran a continuación: en la primera sustituimos la IP existente por la IP de la interfaz tun0 que averiguamos más arriba; la segunda la comentamos (ponemos el carácter # al comienzo), de forma que ambas queden así:

push "dhcp-option DNS 10.8.0.1"
#push "dhcp-option DNS 8.8.4.4"

Además de esto, debemos establecer la interfaz tun0 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, de manera que quede así:

PIHOLE_INTERFACE=tun0

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=tun0

Finalmente, entramos en la interfaz web de Pi-hole y hacemos clic en Login - Settings - menú DNS y activamos todas las interfaces de red (Listen on all interfaces), 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.


4.- Configurar el cortafuegos ufw

Si estemos usando el cortafuegos ufw, al instalar OpenVPN + Pi-hole hay que tener en cuenta que necesitamos modificar algunas cosas para que el sistema funcione correctamente. Primero debemos permitir que el servidor redirija tráfico. Esto es esencial para la funcionalidad que queremos que nuestro servidor VPN proporcione. Podemos ajustar esta configuración modificando el siguiente archivo:

sudo nano /etc/sysctl.conf

Entonces buscamos una línea como la que se muestra a continuación y, en caso de que la tenga puesta, le quitamos la almohadilla (#), de manera que quede así:

net.ipv4.ip_forward=1

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

sudo sysctl -p

También modificaremos el archivo de reglas del cortafuegos para configurar el enmascaramiento, un concepto de iptables que proporciona NAT dinámico para enrutar correctamente las conexiones de los clientes.

Pero antes de abrir el archivo de configuración del firewall para agregar enmascaramiento, necesitamos encontrar la interfaz de red pública de nuestra máquina. Para ello, escribimos:

ip route | grep default

Lo que nos devolverá lo siguiente:

default via 192.168.1.1 dev eth0 src 192.168.1.33 metric 320

La interfaz pública es la que aparece después de la palabra dev. En nuestro caso es eth0.

Una vez sepamos el nombre de la interfaz, abrimos el siguiente archivo:

sudo nano /etc/ufw/before.rules

Este archivo controla la configuración que se debe establecer antes de que se carguen las reglas convencionales de ufw. En él incluiremos la parte que a continuación destacamos en negrita:

#
# rules.before
#
# Rules that should be run before the ufw command line added rules.
# Custom rules should be added to one of these chains:
#   ufw-before-input
#   ufw-before-output
#   ufw-before-forward
#

# START OPENVPN RULES
# NAT table rules
*nat
:POSTROUTING ACCEPT [0:0] 
# Allow traffic from OpenVPN client to eth0
-A POSTROUTING -s 10.8.0.0/8 -o eth0 -j MASQUERADE
COMMIT
# END OPENVPN RULES

# Don't delete these required lines, otherwise there will be errors
*filter
........

Una vez guardado el archivo, tenemos que decirle a ufw que permita también los paquetes enviados por defecto. Para ello abriremos este otro archivo:

sudo nano /etc/default/ufw

En él buscamos la directiva DEFAULT_FORWARD_POLICY y cambiamos el valor DROP por ACCEPT, de manera que quede así:

DEFAULT_FORWARD_POLICY="ACCEPT"

Guardamos los cambios y abrimos el puerto del servidor OpenVPN, el que indicamos más arriba en el punto 1.) [d] de la instalación del mismo:

sudo ufw allow 1194/udp

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

Además debemos abrir (pero en este caso solamente en el cortafuegos, NO en el router) los dos puertos relativos a Pi-hole: el puerto 53 UDP, para que dnsmasq resuelva las peticiones DNS, y el puerto 80 TCP para poder acceder a la interfaz web mediante lighttpd:

sudo ufw allow 53/udp
sudo ufw allow 80/tcp

Es necesario deshabilitar y volver a habilitar ufw para que surtan efecto los cambios que hemos realizado en los archivos anteriores:

sudo ufw disable
sudo ufw enable

Puede darse el caso de que el cortafuegos no se active en los sucesivos arranques o reinicios de la Raspberry, en cuyo caso será necesario ejecutar este comando para solucionar el problema:

sudo systemctl disable netfilter-persistent

Hecho todo lo anterior, sólo nos queda reiniciar la Raspberry Pi y ya tendremos nuestro servidor OpenVPN funcionando correctamente junto a Pi-hole. Podemos comprobarlo si visitamos esta web de prueba, cuyo resultado debería ser este:




aMule

aMule es un programa cliente-servidor para el intercambio de ficheros P2P, libre y multiplataforma, que funciona tanto con la red eDonkey como con Kademlia. Esta aplicación es el resultado de portar el cliente eMule de Windows al sistema operativo Linux.

Lo instalamos con este comando:

sudo apt install amule amule-daemon

Veremos que se van a instalar una gran cantidad de paquetes, debido a las muchas dependencias que posee esta aplicación, sobre todo si usamos la versión Lite de Raspbian.

Tenemos que crear un usuario específico para el programa:

sudo adduser amule

De los datos que se nos piden, el más importante es la contraseña, que tendremos que escribir dos veces. Luego ponemos un nombre (amule mismo, por ejemplo). El resto lo podemos dejar por defecto pulsando Intro.


Configuración inicial

Vamos a comenzar la configuración editando un primer fichero:

sudo nano /etc/default/amule-daemon

En él configuramos dos líneas que están sin completar, y lo haremos de la siguiente forma:

AMULED_USER="amule"
AMULED_HOME="/home/amule"

Ya podemos arrancar el servicio:

sudo service amule-daemon start

Ahora generaremos la contraseña para acceder a la interfaz web de aMule y su correspondiente código md5:

echo -n contraseña_amule | md5sum

Es muy importante que apuntemos la contraseña elegida y el código md5 generado (sin el - final). Luego reiniciamos la Raspberry:

sudo reboot

A continuación nos desplazamos a la subcarpeta oculta que hay dentro del /home del nuevo usuario que hemos creado antes:

cd /home/amule/.aMule

Aquí se encuentra el fichero de configuración de aMule, que vamos a editar:

sudo nano amule.conf

Buscamos las siguientes líneas (con Ctrl+w) y las dejamos configuradas tal y como se indica a continuación:

AcceptExternalConnections=1
ECPassword=ef2738329ac3318daf3f3737372be             [código md5 generado antes]
[WebServer]
Enabled=1
Password=ef2738329ac3318daf3f3737372be                [el mismo código md5 anterior]
Port=8011                                                                        [ponemos un puerto distinto del 80]

Acabada la configuración, reiniciamos de nuevo:

sudo reboot

Interfaz web de aMule

Ya podemos entrar en la interfaz web de aMule escribiendo su IP y el puerto 8011 que indicamos antes en la configuración:

http://192.168.1.33:8011

Nos pedirá la contraseña (la que anotamos antes) y, tras escribirla y pulsar en Submit, aparecerá una página similar a esta:

En los botones de arriba se pueden ver qué archivos nos estamos bajando, gestionar los servidores en los que estamos conectados, buscar y bajar archivos nuevos… y realizar una configuración muy básica pinchando en configuration (arriba, en el menú de iconos, a la derecha).


Configuración por medio de un programa cliente

Sin embargo, para poder llevar a cabo una configuración mucho más completa y detallada será necesario bajarnos el cliente que se corresponda con el sistema operativo que usemos habitualmente:

  1. 1.- Para Windows podemos descargar la versión 2.3.1 desde este enlace y ejecutar el archivo AmuleGUI.exe que se encuentra entre la lista de ficheros.
  2. 2.- En el caso de Linux instalaremos, desde los repositorios, el paquete amule-utils-gui.

Cuando ejecutemos el cliente (el de Windows en nuestro caso), aparecerá una ventana como esta:

Introducimos los datos referidos a la IP de la Raspberry, el puerto (dejamos el que viene por defecto) y la contraseña. Al pulsar en el botón Connect veremos esto:

Para configurar correctamente aMule pinchamos en el icono Preferences. Se nos abrirá una ventana y en ella tendremos que hacer las modificaciones necesarias e introducir los datos requeridos para que el servicio funcione de la forma que esperamos.

En el apartado Connection indicamos el ancho de banda para las descargas y las subidas. También debemos poner los puertos que usaremos; podemos dejar los que vienen por defecto o cambiarlos (siempre dentro del rango entre el 4500 y el 5000): el puerto Standard TCP Port, el UDP port for server requests (el sistema suma automáticamente 3 al anterior) y el Extended UDP Port. Estos puertos, naturalmente, tendremos que abrirlos en el router y redirigirlos a la IP de la Raspberry.


Carpeta de descargas y carpetas compartidas

Antes de seguir con el proceso de configuración, conviene hacer un par de cosas. En primer lugar, debemos saber que aMule tiene configurada una carpeta por defecto en la que almacena las descargas, que está en la siguiente ruta:

/home/amule/.aMule/Incoming

Sin embargo, lo lógico es usar un disco duro USB conectado a nuestra máquina, ya que de esta forma tendremos una gran capacidad de almacenamiento y además evitaremos que se dañe prematuramente la tarjeta microSD por los constantes accesos a la misma. En el menú Trucos de esta web se explica cómo hacer este proceso (localizar la unidad de HD, formatearla y montarla en una carpeta).

En nuestra caso vamos a usar un HD USB, que montaremos en la ruta /media/hdusb, y ahí crearemos una carpeta específica para guardar todo lo que descarguemos:

cd /media/hdusb
sudo mkdir amule
sudo chmod 777 amule

Por otro lado, también sería muy útil y práctico instalar el servidor Samba para poder acceder a los ficheros descargados por aMule desde cualquier dispositivo de nuestra red local. Podemos hacerlo fácilmente como explicamos aquí.

Una vez realizado todo lo anteror, ya podemos volver al cliente y configurar el directorio o carpeta de descargas. En el apartado Directories escribimos la Destination folder for downloads y la Folder for temporary download files, que en nuestro caso será la misma, la que hemos creado antes (/media/hdusb/amule), como se puede ver en la imagen de más abajo.

En Shared folders aparecerán las carpetas que deseamos compartir. Para añadir dichas carpetas, detenemos momentáneamente el servicio:

sudo service amule-daemon stop

Creamos la carpeta (o carpetas) compartida:

cd /media/hdusb
sudo mkdir compartidos

Luego editamos el siguiente fichero:

sudo nano /home/amule/.aMule/shareddir.dat

y escribimos una línea con la ruta completa de cada carpeta compartida:

/media/hdusb/compartidos

Guardamos los cambios y arrancamos de nuevo el servicio:

sudo service amule-daemon start

Entramos en el cliente y en Preferences - Directories ahora veremos tanto la capeta de descargas como la carpeta compartida que acabamos de añadir:

Además, en el menú superior de iconos, en Shared files, aparecerán, una vez que hayan sido indexados, todos los ficheros que estamos compartiendo:

Por supuesto, en la carpeta compartida podemos añadir nuevos ficheros o borrarlos. Cuando hagamos esto, será necesario actualizar el listado que se muestra aquí pulsando en el botón Reload que se encuentra a la derecha de la ventana.


Finalizando la configuración desde el cliente

Volvemos de nuevo a Preferences y en el apartado Files activamos las 3 últimas casillas consecutivas que se muestran en esta imagen:

Después accedemos al apartado Security. Aquí, opcionalmente, podemos activar la casilla Accept only obfuscated connections, lo nos proporcionará fuentes de descarga más seguras, pero como contrapartida obtendremos un número mucho menor de ellas, por lo que queda al criterio de cada uno el activarla o no. Lo que sí haremos, más abajo, es marcar las casillas Filter clients y Filter servers. Justo debajo de esta última escribimos la siguiente URL:

http://upd.emule-security.org/ipfilter.zip

Este fichero ZIP contiene una larga lista de instituciones u organismos (como la SGAE española o la ASCAP norteamericana) que espían a los usuarios de programas P2P para saber qué descargan.

Finalmentee, en el apartado Servers activamos la casilla Auto-update server list at startup, pinchamos en el botón List y escribimos la siguiente URL que contiene una lista de servidores:

http://upd.emule-security.org/server.met

Ya sólo nos queda salir del cliente y reiniciar el servicio para empezar a usar aMule:

sudo service amule-daemon restart

Problemas de inicio y solución

Algunos usuarios se encuentran con el problema de que el servicio no se inicia correctamente durante el arranque de la Raspberry y, como consecuencia, tampoco es posible ejecutar el cliente (ni en Windows ni en Linux). Podemos percatarnos también de este problema si entramos en la interfaz web y pulsamos en el enlace de configuration que hay a la derecha del menú de iconos: aparecerán todas las casillas como "undefined".

La solución radica, cada vez que se arranque la Raspberry Pi, en parar el demonio (sudo service amule-daemon stop), esperar unos 60 segundos aproximadamente y volver a iniciarlo (sudo service amule-daemon start). Dado que este proceso es bastante tedioso si lo hacemos manualmente, lo mejor es automatizarlo: creamos un script con las instrucciones anteriores y lo ejecutamos en cada reinicio por medio de cron. Lo haremos de esta forma:

  1. 1.- En /home/pi creamos un fichero de script llamado amule.sh con este contenido:
    #!/bin/bash
    sudo service amule-daemon stop
    sleep 60
    sudo service amule-daemon start
  2. 2.- Le damos permiso de ejecución:
    chmod u+x amule.sh
  3. 3.- Editamos el fichero de configuración de cron:
    crontab -e
    y, al final del mismo, añadimos una línea para que se ejecute el script cada vez que se inicie la Raspberry:
    @reboot /home/pi/amule.sh > /dev/null 2>&1

A partir de ahora, tras cada arranque, damos tiempo a que se inicie correctamente el servicio y ya podremos acceder a aMule a través del cliente.