hits counter

Servidores:



Servidor web Lighttpd + PHP

Lighttpd es posiblemente el servidor web más liviano que hay disponible en la actualidad. Esto significa que consume muy pocos recursos de la máquina en la que se instala. Y por este motivo muchos usuarios lo eligen para montar un servidor web en su Raspberry Pi. Veamos cómo sería el proceso.

Instalamos el servidor:

sudo apt-get install lighttpd

Vamos ahora a cambiar el propietario y el grupo de la carpeta /var/www y a añadir al usuario pi a dicho grupo:

sudo chown www-data:www-data /var/www
sudo chmod 775 /var/www
sudo usermod -a -G www-data pi

Editamos el fichero de configuración de Lighttpd:

sudo nano /etc/lighttpd/lighttpd.conf

Comprobamos que aparecen las dos primeras líneas y que la tercera incluye index.php:

server.username = "www-data"
server.groupname = "www-data"

index-file.names = ("index.html", "index.lighttpd.html", "index.php")

Si no fuera así, las añadimos. Y ahora reiniciamos el servidor:

sudo service lighttpd restart

Si escribimos la IP local de la RasPi en el navegador del PC (http://192.168.1.33), veremos una página web de ejemplo similar a esta:


Esto significa que nuestro servidor web ya está en funcionamiento.


PHP

Instalaremos ahora PHP:

sudo apt-get install php5-common php5-cgi php5

Cargamos el módulo del servidor que permite que funcionen los archivos .php:

sudo lighty-enable-mod fastcgi-php

y reiniciamos de nuevo el servidor:

sudo service lighttpd restart

Ya podemos mostrar ficheros PHP. Para comprobarlo, creamos un archivo de prueba llamado, por ejemplo, prueba.php:

cd /var/www
sudo nano prueba.php

en el que incluiremos este sencillo contenido:

<?php
phpinfo();
?>

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


Las páginas web que queramos mostrar hemos de colocarlas en el directorio /var/www; y además tendremos que abrir el puerto 80 en el router y dirigirlo a la IP local de la RasPi para poder acceder desde Internet al servidor.


Servidor web seguro (https)

Con el servicio ya funcionando, vamos a ir más allá y vamos a crear un servidor web seguro, es decir, del tipo https. En este protocolo se utiliza un canal seguro SSL por el que circula la información entre el servidor web y el navegador del cliente. De esta forma, los datos que se intercambien entre ambos (nombres de usuario, contraseñas,...) viajan cifrados, lo que impide que un atacante que haya podido interceptar la transferencia de datos pueda acceder a esa información.

Creamos los certificados:

sudo mkdir /etc/lighttpd/certs
cd /etc/lighttpd/certs
sudo openssl req -new -x509 -keyout lighttpd.pem -out lighttpd.pem -days 365 -nodes

El sistema nos pedirá una serie de datos (Country Name, State or Province, Locality, Organization, etc.), los introducimos y después cambiamos los permisos del fichero que se ha creado:

sudo chmod 400 lighttpd.pem

Seguidamente, editamos de nuevo el archivo de configuración del servidor:

sudo nano /etc/lighttpd/lighttpd.conf

y añadimos al final del mismo las líneas necesarias para que el servidor web tenga soporte SSL, indicándole el puerto por el que debe aceptar las peticiones así como el directorio donde se encuentran los certificados:

# ssl support
$SERVER["socket"] == ":443" {
ssl.engine = "enable"
ssl.pemfile = "/etc/lighttpd/certs/lighttpd.pem"
}

Lo guardamos (Ctrl+o, Intro, Ctrl+x) y reiniciamos el servidor:

sudo service lighttpd restart

Ahora escribirmos en el navegador de nuestro PC la IP local de la Raspberry usando el protocolo https:

https://192.168.1.33/prueba.php

En el navegador aparecerá una ventana con una advertencia que dirá algo así como Esta conexión no está verificada. Hacemos clic en Entiendo los riesgos o algo parecido y añadimos una excepción. Una vez confirmada la excepción, nos aparecerá la página web de prueba, pero con un candado a la izquierda de la dirección https:


Esto significa que todo ha ido bien y que ya tenemos funcionando nuestro servidor web seguro. Para poder acceder desde Internet, tenemos que abrir el puerto 443 en el router y dirigirlo a la IP local de la RasPi.



Servidor web Nginx + PHP

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 pocos recursos, por lo que es más adecuado para instalarlo en una pequeña placa como la Raspberry Pi.

Instalamos el servidor:

sudo apt-get install nginx

Nginx guarda por defecto las páginas web en el directorio /usr/share/nginx/www, mientras que Apache lo hace en /var/www. Ahora es el momento de decidirnos entre una carpeta u otra. Vamos a optar en este caso por usar la misma ruta que Apache. Para ello tenemos que crear la mencionada carpeta:

sudo mkdir /var/www

A continuación editamos el fichero de configuración del servidor:

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

y nos aseguramos de que queden así las siguientes líneas, haciendo para ello los cambios pertinentes:

listen 80;

root /var/www;
index index.html index.htm;

server_name localhost;

PHP

Hecho lo anterior, ya podemos instalar PHP:

sudo apt-get install php5-fpm

Para que PHP funcione correctamente con Nginx, debemos hacer de nuevo algunas modificaciones en el fichero anterior:

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

En él realizamos los siguientes cambios: añadimos index.php a la línea que se indica en primer lugar, y más abajo descomentamos location ~ \.php$ { y las siguientes líneas que se muestran a continuación:

index index.html index.htm index.php;

location ~ \.php$ {
     fastcgi_split_path_info ^(.+\.php)(/.+)$;
     fastcgi_pass unix:/var/run/php5-fpm.sock;
     fastcgi_index index.php;
     include fastcgi_params;
}

Para comprobar que todo funciona correctamente, creamos un archivo de prueba llamado prueba.php:

cd /var/www
sudo nano prueba.php

en el que incluimos este sencillo contenido:

<?php
phpinfo();
?>

Los guardamos (Ctrl+o, Intro, Ctrl+x) y ya sólo queda reiniciar Nginx y PHP:

sudo service nginx restart
sudo service php5-fpm restart

Como en el apartado anterior, si abrimos en el navegador del PC 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:


Las páginas web que queramos mostrar hemos de colocarlas, como dijimos antes, en el directorio /var/www; y además no debemos olvidar abrir el puerto 80 en el router y dirigirlo a la IP local de la RasPi.

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 servicio.


Servidor web seguro (https)

Como hicimos antes con Lighttpd, vamos a crear también aquí un servidor web seguro, del tipo https, para que la información entre el servidor web y el navegador del cliente circule de forma segura y ningún atacante pueda conocer el contenido de los datos que se transfieran entre ambas máquinas.

Para ello crearemos un directorio en el que guardar las claves/certificados SSL y luego generamos dichas claves:

sudo mkdir /etc/nginx/ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/nginx/ssl/nginx.key -out /etc/nginx/ssl/nginx.crt

El sistema nos pedirá una serie de datos (Country Name, State or Province, Locality, Organization, etc.), los introducimos y continuamos.

Vamos ahora a editar una vez más el fichero de configuración de Nginx:

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

Le añadiremos soporte para los certificados SSL, de modo que incluiremos las siguientes líneas:

# ssl support
listen 443 ssl;
ssl_certificate /etc/nginx/ssl/nginx.crt;
ssl_certificate_key /etc/nginx/ssl/nginx.key;

Lo guardamos (Ctrl+o, Intro, Ctrl+x) y reiniciamos el servidor:

sudo service nginx restart

Ahora escribirmos en el navegador de nuestro PC la IP local de la Raspberry usando el protocolo https:

https://192.168.1.33/prueba.php

En el navegador aparecerá una ventana con una advertencia que dirá algo así como Esta conexión no está verificada. Hacemos clic en Entiendo los riesgos o algo parecido y añadimos una excepción. Una vez confirmada la excepción, nos aparecerá la página web de prueba, pero con un candado a la izquierda de la dirección https:


Esto significa que todo ha ido bien y que ya tenemos funcionando nuestro servidor web seguro. Ahora no debemos olvidar abrir el puerto 443 en el router y dirigirlo a la IP local de la RasPi.



Servidor web LAMP

LAMP es el acrónimo que corresponde a Linux, Apache, MySQL y PHP. Se trata del conjunto de elementos necesario para montar un completo servidor web. Una vez instalado, cualquier cliente, mediante el navegador, podrá conectarse con nuestra Raspberry Pi y ver las páginas web que tengamos guardadas en el servidor.

Puesto que estamos usando el sistema operativo Raspbian en la Raspberry, el primer elemento del conjunto (Linux) ya lo tenemos instalado y no tenemos que preocuparnos de él. Vayamos, pues, con los elementos restantes.

Apache

Apache es probablemente el servidor web más utilizado del mundo. Instalar Apache y dejarlo listo para funcionar no es difícil. Lo primero que hay que hacer es crear un grupo nuevo de usuarios:

sudo groupadd www-data
sudo usermod –a –G www-data www-data

Y lo segundo es instalar el propio servidor:

sudo apt-get install apache2

Le damos un nombre al servidor de nuestra máquina editando el fichero apropiado:

sudo nano /etc/apache2/conf.d/ServerName

y añadiendo dentro de él la siguiente línea:

ServerName raspberry

Lo guardamos (Ctrl+o, Intro, Ctrl+x) y, por último, lo ponemos en marcha:

sudo /etc/init.d/apache2 start

Ya está. Apache está listo para funcionar. 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:


PHP

En segundo lugar instalaremos PHP para poder programar o ejecutar scripts en este lenguaje. Para ello debemos instalar los siguientes paquetes:

sudo apt-get install php5 libapache2-mod-php5 libapache2-mod-perl2 php5-cli php5-cgi php5-common php5-curl

Finalmente reiniciamos el sistema y quedará listo para usar:

sudo reboot

A partir de este momento nuestra Raspberry Pi ya tiene soporte para PHP. Podemos comprobarlo creando un archivo index.php en el directorio /var/www/:

cd /var/www
sudo nano index.php

en el que escribiremos un pequeño código en PHP:

<?php
phpinfo();
?>

Lo guardamos (Ctrl+o, Intro, Ctrl+x) y ahora, si ponemos en el navegador del PC la IP de nuestra RasPi, seguida del nombre del fichero que acabamos de crear (http://192.168.1.33/index.php), tendría que aparecer un cuadro con información detallada sobre la versión de PHP instalada, similar a este:


MySQL

MySQL es un sistema de bases de datos Open Source que sirve para almacenar los todos los datos contenidos en nuestro sitio web. Para su instalación escribimos lo siguiente:

sudo apt-get install mysql-server mysql-client php5-mysql

Durante el proceso se nos pedirá que escribamos una contraseña (conviene anotarla, ya que la necesitaremos más adelante). La escribimos y, una vez terminada la instalación, iniciamos MySQL:

sudo service mysql start

Es conveniente comprobar que la base de datos se ha instalado correctamente. Para ello tecleamos el siguiente comando:

mysql -u root –p

Escribimos la contraseña que definimos anteriormente y, para salir, el comando exit.


phpMyAdmin

Vamos a incluir también phpMyAdmin. Se trata de una utilidad, basada en PHP, que sirve para administrar las bases de datos MySQL por medio de una interfaz web. Para su instalación escribimos el siguiente comando:

sudo apt-get install libapache2-mod-auth-mysql php5-mysql phpmyadmin

Durantre el proceso de instalación se nos preguntará qué servidor web hemos instalado. Seleccionamos Apache con la tecla Espacio y pulsamos Intro. Después nos preguntará si queremos configurar la base de datos; decimos que . Luego tendremos que poner la contraseña que establecimos durante la instalación de MySQL y finalmente nos pedirá que escribamos una nueva contraseña para phpMyAdmin (la anotaremos para no olvidarla).

Una vez finaliza la instalación, tenemos que modificar el siguiente archivo:

sudo nano /etc/php5/apache2/php.ini

En este fichero, y preferiblemente dentro de la sección Dynamic Extensions, insertamos una nueva línea con este contenido:

extension=mysql.so

Guardamos el archivo (Ctrl+o, Intro, Ctrl+x) y ejecutamos estos dos comandos para acabar el proceso:

sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf.d/phpmyadmin.conf
sudo /etc/init.d/apache2 restart

Y ahora, para acceder a la interfaz de phpMyAdmin, escribiremos 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 la contraseña, la que pusimos cuando instalamos phpMyAdmin.

Hay que tener en cuenta dos cosas:

  1. 1.) Como hemos visto, las páginas web o php que queramos mostrar hay que copiarlas en el directorio /var/www.
  2. 2.) Si deseamos que los demás puedan ver nuestra página web desde Internet, debemos abrir el puerto 80 en el router y redirigir el tráfico del mismo a la IP local de la Raspberry.



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 de 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-get update
    sudo apt-get upgrade
  4. 4.) Ejecutamos estos dos comandos para instalar y preparar el uso de CUPS:
    sudo apt-get 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

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-get 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.



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-get install proftpd

Durante el proceso de instalacción se nos preguntará 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 pendrive que se encuentra conectado a la Raspberry y montado en la ruta /media/pen (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/pen                                     [directorio de montaje del pendrive]
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/pen/ftp/musica
/media/pen/ftp/elibros
/media/pen/ftp/fotos
/media/pen/ftp/recibidos

En las tres primeras pondremos todos los ficheros o 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

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/pen/ftp) y además le asignaremos un intérprete de comandos falso (/bin/false), de modo que quede así:

ftp:x:111:65534::/media/pen/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/pen/ftp
DefaultChdir                   /media/pen/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                         25010  25090

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

También controlaremos 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       4 "Sólo se admiten 4 conexiones por Host/IP."
MaxClientsPerUser       4 "Sólo se admiten 4 conexiones por usuario."
# Intentos de inicio de sesión permitidos
MaxLoginAttempts       3

Al final del archivo añadimos este fragmento, 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):

<Directory /media/pen/ftp>
   <Limit WRITE STOR>
	 DenyAll
   </Limit>
   <Limit READ>   
	 AllowAll	  
   </Limit>		  
</Directory>  

Mediante este otro fragmento, configuraremos la subcarpeta recibidos, en la que se almacenarán los ficheros que los usuarios envíen al servidor, para lo que definiremos los permisos apropiados en la misma (se podrán enviar ficheros, pero no se podrá descargar de ella):

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

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 25010 al 25090) 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]



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-get -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, vamos a utilizar un pendrive 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/pen, sólo tendremos que crear dentro de ella una carpeta específica para almacenar las descargas y otorgarle luego los permisos adecuados:

cd /media/pen
sudo mkdir descargas
sudo chmod 777 descargas

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

sudo nano /var/lib/transmission-daemon/info/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-username y rpc-password convendría poner un nombre y una contraseña distintos de los que aparecen por defecto. En cuanto a peer-port y rcp-port estos 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.

"download-dir": "/media/pen/descargas",
"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 a nuestro gusto. Aquí podemos modificar, por ejemplo, el puerto que queremos usar para las descargas; dicho puerto debemos abrirlo luego en el router.

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, es posible descargarla e instalarla directamente desde Google Play.


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/pen/descargas/

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

sudo /etc/init.d/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-get 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.


Configurar el servicio

A continuación editamos el fichero de configuración de Samba:

sudo nano /etc/samba/smb.conf

En él vamos a modificar un par de detalles relativos a la seguridad. En primer lugar buscamos la línea que comienza por hosts allow y la descomentamos, quitándole la almohadilla (#). Si no existe, la podemos crear en el apartado #### Networking #### y escribiremos una IP o un rango de IPs de nuestra red local al que permitiremos la conexión:

hosts allow = 192.168.1.0/24 127.0.0.1

En este ejemplo permitimos la conexión a la propia RasPi (127.0.0.1 o localhost, algo que siempre hay que incluir al final) y también a todos los dispositivos de nuestra LAN (192.168.1.0/24), es decir, a todas las IPs de la red local al completo.

En el caso de que deseemos permitir el acceso sólo a una o a varias IPs concretas, debemos indicarlas explícitamente:

hosts allow = 192.168.1.35 192.168.1.36 192.168.1.40 127.0.0.1

Si, por el contrario, quisiéramos denegar el acceso a alguna IP específica (o a varias de ellas), haríamos lo mismo, indicarlas también explícitamente, así:

hosts deny = 192.168.1.20 192.168.1.21 192.168.1.42

En las últimas versiones de Samba ya no se incluye la directiva a la que nos vamos a referir a continuación, así que no es necesario hacer nada y podemos saltarnos este paso; pero si estamos usando una versión más antigua, será necesario hacerlo. Se trata de buscar la sección que contiene el texto ##### Authentication ##### y, dentro de ella, nos encontraremos con la línea

# security = user

Lo que haremos, si existe dicha línea, será quitarle la almohadilla, de modo que quede así:

security = user

Esto hace que Samba nos pida el nombre de usuario y la contraseña para acceder a los recursos compartidos.


Compartir carpetas

Vamos ahora 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 guardar 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 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 = 0777
directory mask = 0777

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 más arriba). A este usuario se le conceden permisos tanto de lectura como de escritura (read only = no, writeable = yes). Para que los permisos de escritura de Samba sobre el recurso compartido sean efectivos, deben coincidir con los permisos que posee la carpeta en el sistema de ficheros de Raspbian.

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

sudo /etc/init.d/samba 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, tendremos que usar 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 del usuario, es decir, /home/pi en nuestro caso. Si queremos evitar esto, podemos añadir al fichero de configuración de Samba los datos necesarios para que no comparta esa carpeta. Lo haremos como se muestra a continuación, indicando en el path el directorio o carpeta del usuario:

[pi]
comment = directorio del usuario
path = /home/pi
browseable = no
writeable = no
read only = yes
guest ok = no
public = no

Lo fundamental se encuentra en la línea browseable = no, que es la que realmente impide que se muestre la carpeta.

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

sudo /etc/init.d/samba 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 = 0777
directory mask = 0777
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 /etc/init.d/samba 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-get 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 los dos puertos USB de la RasPi, por lo que nos quedaría así:

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

La A de la primera línea significa 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, como en la segunda línea, 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 en este primer arranque mediante este comando:

sudo service minidlna force-reload

Si no funciona, podemos hacerlo a la fuerza, borrando la base de datos que almacena el contenido y reiniciando el servicio:

sudo minidlna -R
sudo service minidlna restart

Ya hemos ido viendo algunos de los parámetros que admite el servicio: 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 en el cortafuegos que estemos usando.

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 proyecto para convertir la Raspberry Pi en un servidor de DNS capaz de filtrar y bloquear la publicidad a nivel de red. Una vez configurado el sistema, sólo tenemos 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 por la Raspberry y esta actuará como un filtro antipublicidad, al estilo de las extensiones "adblock" de los navegadores, pero con la gran ventaja de que nos servirá para todos los aparatos que tengamos conectados a la red local.

El proceso de instalación y configuración es muy sencillo y consta de sólo cuatro pasos:

  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, aquí (en los primeros tres apartados) 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.
  3. 3.) Instalar Pi-hole, para lo cual basta con ejecutar este script desde la línea de comandos:
    curl -sSL https://install.pi-hole.net | bash
    Tendremos que esperar a que termine de instalarse y configurarse todo lo necesario para que Pi-hole funcione correctamenete, lo que tardará unos minutos. Durante este proceso se nos preguntarán algunas cosas, pero bastará con aceptar y continuar para que todo quede perfectamente configurado.
  4. 4.) 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...).

Comprobaremos que el sistema está en marcha accediendo a la interfaz web de administración, lo que podemos hacer de dos formas: bien escribiendo en el navegador del PC la dirección IP de la RasPi o bien entrando desde el propio Pi-hole:

http://192.168.1.33/admin
http://pi.hole/admin

Y cuando exista una nueva versión, nos será posible actualizar desde la línea de comandos mediante esta simple orden:

pihole -up