PiServer con Docker – Parte 3: Instalación de Pi-Hole.

En el primer tutorial que hemos hecho en esta serie, hemos visto cómo podemos instalar correctamente el último sistema operativo a una Raspberry. El segundo artículo era mucho más teórico y en él hemos aprendido qué es Docker, para qué sirve, ventajas que tiene y también lo hemos instalado en nuestra Raspberry (o en nuestro Debian, que también hemos enseñado cómo se instala en ese sistema), de forma que el dispositivo ha quedado preparado para poder añadirle todos los Dockers que queramos.

Ahora vamos a empezar la juerga. En este artículo vamos a instalar nuestro primer Docker, y recordad que aunque estoy orientando este tutorial a Raspberrys, es aplicable también a cualquier dispositivo que use una distribución Linux derivada de Debian (Ubuntu Server, por ejemplo). El objetivo es tener un servidor doméstico que nos haga un montón de cosas en nuestro hogar, y creo que empezar instalando «Pi-Hole» es un buen comienzo.

Me suena eso de Pi-hole. ¿No lo habíamos instalado ya en otro artículo?

Sí Usuario Anónimo. Lo habíamos instalado en este tutorial, pero de forma tradicional, sin usar docker. En este caso vamos a usar esta tecnología para usarlo y mantenerlo «encapsulado», de forma que no interfiera en otros procesos. En concreto usaremos docker compose tanto en este como en los siguientes tutoriales. Usaremos esta primera instalación como guía principal para los artículos posteriores en los que no nos vamos a parar tanto en explicaciones.

Para los que no lo conozcan, Pi-hole es un programa que actúa en nuestra red como servidor de DNS, pero es un servidor de DNS muy especial, porque lo que hace es quitarnos la publicidad de las aplicaciones de todos los dispositivos de nuestro hogar. Incluso en dispositivos en los que es imposible instalar un bloqueador de publicidad (como en una televisión) nos permite que el dispositivo no muestre publicidad en ningún momento. Es más: imagínate que invitas a alguien a tu casa y le das la contraseña del WiFi. Por el simple hecho de conectarse a tu WiFi, esa persona ya estaría navegando sin publicidad.

Pues sí que mola. Pues hala: dinos ya cómo se instala que tú en seguida te dispersas. 

Tal y cómo dije, vamos a seguir la misma estructura en las instalaciones posteriores, así que tened los puntos principales de este artículo siempre bien claros.

0) Creamos una carpeta llamada «Dockers» dentro de la carpeta de nuestro usuario.

Y sí… a este punto le he puesto el número cero porque sólo lo vamos a hacer en este tutorial. En los siguientes tutoriales esta carpeta ya estará creada (pero aún así lo seguiremos recordando por si alguien no quiere leerse todas las guías).

Primero nos conectamos por SSH a nuestra raspberry (he explicado al final de la primera guía cómo se hacía). En cuanto nos hayamos conectado, deberíamos estar en la carpeta home de nuestro usuario, es decir, en la siguente ruta:

/home/usuario

y en el prompt debería aparecer algo como esto:

miusuario@miRaspberry:~ $

Ahí lo que vamos a hacer es crear una nueva carpeta llamada «Dockers». Es en esa carpeta dónde vamos a poner todas las configuraciones y los volúmenes de todos nuestros Dockers, no sólo del Pi-hole, sino de todos los que hagamos en el futuro (si es necesario, recordad qué es un volumen de un docker consultando el segundo artículo de esta serie de tutoriales). La carpeta la crearemos con el siguiente comando.

mkdir docker

1) Dentro de «docker» creamos la carpeta «pihole» y su estructura.

Perfecto. Ahora vamos a preparar todas las carpetas y configuraciones que necesita pi-hole. Vamos a entrar dentro de la carpeta «dockers» con este comando.

cd docker

… y vamos a crear dentro de esa carpeta otra más que se va a llamar «pihole» y también entraremos en ella. Lo hacemos con estos dos comandos.

mkdir pihole
cd pihole

Para que os situéis. Ahora mismo estamos en la ruta /home/miusuario/docker/pihole. Es ahí dónde vamos a poner todo lo que necesita pi-hole para funcionar. Este docker en concreto necesita dos carpetas dónde almacenar datos. las vamos a llamar «etc-dnsmasq.d» y «etc-pihole».

Para, para, que ya me he perdido. Cuando hago un docker ¿Cómo sé qué carpetas necesito crear dentro de la carpeta del Docker?

En cada caso hay que mirar siempre en la documentación del docker que vamos a instalar. Ahí nos dirán qué carpetas hay que crear. Tú no te preocupes por el momento. Lo veremos en este mismo artículo más adelante. De momento quédate con que en este caso hay que crear estas dos carpetas y lo haremos con este comando:

mkdir etc-dnsmasq.d && mkdir etc-pihole

Con esto tenemos la estructura de carpetas listas para almacenar lo que necesitamos.

2) Creamos el archivo .yml con la configuración del docker.

Tal y cómo os dije en el anterior artículo, para instalar algo con docker compose vamos a necesitar crear un archivo .yml con su configuración. Docker compose va a leerlo y siguiendo las instrucciones del archivo va a descargar y desplegar nuestro docker. Cuando nos interese instalar algo con docker, normalmente es lo que nos dan, así a palo seco. Pero yo prefiero examinarlo y siempre os lo voy a dar optimizado y modificado para que todas las instalaciones sean exactamente iguales.

Vale. Y si busco un Docker cualquiera para instalar, ese archivo ¿De dónde lo saco? He encontrado un sitio donde hay gente que crea sus propios Dockers, algunos realmente chulos, que...

¡Para! ¡Para! A ver… para no meter la pata, es más que recomendable usar siempre los archivos de instalación (las imágenes) de los propios desarrolladores de las aplicaciones. Hay gente que se crea sus propios Dockers que pueden funcionar perfectamente, pero que luego quedan sin mantener y no reciben actualizaciones y pueden causar problemas. Eso está perfectamente ilustrado en este maravilloso vídeo.

Como se te va la olla. Tienes que hacértelo mirar algún día. 

En todo caso para que no pase el desastre que se indica en el vídeo, sobre todo en instalaciones importantes, intenta no instalar cosas que no vengan de los desarrolladores oficiales porque…

Para un momento. Me dices que no instale nada que no venga de un desarrollador oficial ¿y tú, que no eres desarrollador oficial, me estás diciendo cómo instalar Pi-hole? Te he pillao, bacalao. ¿Nos quieres meter un virus a todos?

Para nada. El problema no viene por bajarte un archivo de configuración .yml que puede estar mejor o peor hecho. El problema puede venir porque ese archivo es factible que no esté usando imágenes oficiales. Una imagen que no es oficial depende del desarrollador de turno que la haya adaptado y puede desde tener errores hasta algún virus metido a propósito. En todo caso hay que ser justos: también hay algunas que no dan ningún problemas y están bien mantenidas por los que las adaptan. Os digo dentro de un momento dónde podemos ver si una imagen es la oficial.

Antes vamos a empezar creando el archivo .yml y lo haremos con el siguiente comando.

sudo nano docker-compose.yml

Se nos abrirá un editor. Debemos pegar exactamente este texto dentro. No modifiquéis ni una coma.

version: "3"

services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    # Para DHCP se recomienda eliminar estos puertos y poner esto en su lugar: network_mode: "host"
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "67:67/udp"
      - "8091:80/tcp"
    environment:
      TZ: $TZ
      WEBPASSWORD: $WEBPASSWORD
      FTLCONF_LOCAL_IPV4: $DIRECCIONIP
    volumes:
      - $DOCKERDIR/pihole/etc-pihole:/etc/pihole
      - $DOCKERDIR/pihole/etc-dnsmasq.d:/etc/dnsmasq.d
    cap_add:
      - NET_ADMIN
    restart: unless-stopped

Vamos a pulsar «Control» + «o» para guardar cambios y luego «Control» + «x» para salir. Pero antes de seguir con el próximo punto vamos a analizar las partes más interesantes de este archivo.

• container_name: pihole –> Aquí se indica el nombre que le vamos a dar al contenedor que se va a crear. Le vamos a llamar pihole.
• image: pihole/pihole:latest –> Aquí se dice qué imagen se va a usar para generar el contenedor. Tal y cómo os dije hace un rato, siempre hay que intentar usar imágenes del desarrollador principal. En este caso, los desarrolladores de pi-hole ponen a disposición del público su docker en esta dirección: https://hub.docker.com/r/pihole/pihole . Y fijaos que a mitad de página nos ofrecen su «docker compose» y que la imagen que usan es la misma que uso yo.

Pues sí. Pero sin embargo veo modificaciones en algunas partes del código. 

Efectivamente. Lo que suelo hacer es modificarlo para darle un extra de seguridad al código (cosa que muchos desarrolladores no hacen, como es el caso). Si os fijáis, en algunas partes del código que he puesto yo aparecen símbolos de dólar ($). En esa parte del código, el desarrollador oficial indica que hay que modificar el archivo docker-compose.yml para poner los datos personalizados de la instalación (idioma, usuarios, contraseñas, etc…). Yo sin embargo nunca os voy a recomendar poner las contraseñas en el archivo de docker compose y siempre uso variables. Por eso mis archivos «docker-compose.yml» siempre están retocados. Prefiero que pongáis ese archivo tal cual lo publico, sin modificar, y luego esas variables se pongan por fuera en un archivo de variables de entorno.

¿Y por qué haces eso? ¿Por ahorrarte escribir unas líneas en los tutoriales? ¡Pues vaya!

Para nada Usuario Anónimo. Lo hago por seguridad. Esas partes, como ya te dije, tienen información sensible (contraseñas, direcciones ip, etc…). Si esas contraseñas las pones en un archivo a parte, en variables de entorno, y evitas que cualquier usuario pueda leer a ese archivo, reduces la posibilidad de que alguien con malas intenciones pueda acceder a ellas fácilmente (porque si no, alguien que se hubiera colado en el sistema podría verlas simplemente abriendo el archivo docker-compose.yml, que está visible y accesible). Como ya dije, vamos a hacer las cosas bien desde el principio y hacerlo como os digo es darle un extra de seguridad a nuestra instalación. En este caso en concreto podemos ver dos partes diferenciadas con esas variables que he hecho. Por un lado están las de la zona «environment», que son éstas.

    environment:
      TZ: $TZ
      WEBPASSWORD: $WEBPASSWORD
      FTLCONF_LOCAL_IPV4: $DIRECCIONIP

Como supondrás, en las dos últimas definiremos una contraseña y una dirección ip. En la línea que pone «TZ» definiremos el código del país en el que estamos. Todo eso lo veremos en el próximo punto.

Pero también verás que he puesto un símbolo de dolar en otra parte, que es ésta.

    volumes:
      - $DOCKERDIR/pihole/etc-pihole:/etc/pihole
      - $DOCKERDIR/pihole/etc-dnsmasq.d:/etc/dnsmasq.d

Seguro que el nombre de esta sección te suena. Efectivamente, son los volúmenes de los que hemos hablado en el artículo anterior. En esas líneas estamos definiendo dónde va a ir escribiendo datos este Docker en concreto. Básicamente lo que le estamos diciendo al Docker es lo siguiente: todo lo que en una instalación directa lo escribías en /etc/pihole, ahora lo vas a escribir en una carpeta que se llama «etc-pihole» que está situada en un sitio… que te voy a decir luego en variables de entorno. Y lo mismo para la carpeta que inicialmente estaba en /etc/dnsmasq.d. Por eso en el inicio del tutorial creamos esas dos carpetas (ahora sabes de dónde salen y por qué os las mandé crear).

La forma de proceder que tengo es: antes de instalar un docker-compose.yml miro los volúmenes que usa. Sabiéndolos, creo manualmente las carpetas para esos volúmenes y modifico el archivo para poner la ruta luego en variables de entorno.

Pero no os ofusquéis. Los que quieran ir directo al grano, sólo haced lo que os dije antes: creáis el archivo docker-compose.yml, le ponéis dentro el código tal cual y guardáis cambios.

Otra parte del docker que es conveniente saber qué es y cómo se usa es la parte de los puertos. En este caso es la siguiente:

    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "67:67/udp"
      - "8091:80/tcp"

Si os fijáis, estamos definiendo parejas de puertos que va a usar este Docker en concreto. En cada línea, el primer número (el de la izquierda) es el puerto por el que va a salir la comunicación hacia nuestro equipo real (la raspberry). El puerto de la derecha es el puerto que usa en el Docker. Es un poco complicado de explicar, así que os lo voy a detallar con el último puerto, que como veis tiene los dos números diferentes .

El puerto 80 es un puerto que se usa para publicar páginas webs que no son seguras. Si yo creo una página web en mi equipo, puedo mapear el puerto 80 del router hacia mi equipo y la página web estará accesible a través de internet.

Pi-hole crea una página web interna para que podamos configurarlo a gusto. Por defecto, en una instalación normal de pi-hole, para entrar en esa web, sólo tendríamos que poner la ip de nuestra máquina en un navegador de esta forma (es un ejemplo):

https://192.168.1.15

Sin embargo, cuando se trata de puertos que generan páginas web y sobre todo cuando vamos a meter varios dockers en la máquina, es preferible cambiar el puerto de salida y poner uno «random». En este caso hemos usado el 8091, por lo que para acceder a la configuración de nuestro pi-hole, cuando lo tengamos instalado lo haremos a través de una dirección similar a esto.

https://192.168.1.15:8091

(y sí… es algo que tampoco hace el desarrollador del docker pero sí lo vamos a hacer nosotros).

¿Y por qué te pones a cambiar esas cosas que el desarrollador no recomienda? A ver si nos vas a meter en el lío del que hablaba el "experto" del vídeo de arriba. 

Todo tiene un sentido, Usuario Anónimo. Recuerda que nuestro objetivo no es poner un único Docker con pi-hole en la raspberry, sino poner múltiples Dockers, y ya te digo que va a haber unos cuantos que quieran generar una página web en el mismo puerto. ¿Qué es lo que se hace entonces? Pues se resuelve de una forma muy sencilla, que es poniendo un docker a mayores con un «proxy». Lo que hará es recoger esas peticiones de distintos puertos y mandarlas todas por el puerto 80. Si no lo hacemos así, va a haber varios dockers intentando salir a la vez por el mismo puerto y la habremos liado. Por eso nos interesa reservar ese puerto para más adelante.

Por ahora, como acabamos de empezar no me interesa meternos en líos de proxys, y además la web que genera pi-hole no debería interesarnos publicarla directamente en internet. Es sólo para uso interno, así que por ahora simplemente vamos a cambiarle de puerto y dejarlo así. Eso sí… ya os adelanto que unos cuantos artículos más adelante instalaremos algún proxy (veremos cómo instalar «Nginx proxy» y haremos una pequeña introducción de «Traefik»).

Después de todas estas explicaciones continuemos con la instalación.

3) Creamos un archivo oculto de variables de entorno.

Tal y cómo os dije, el archivo de variables de entorno va a contener esas «cosas» del archivo «.yml» a las que les hemos puesto un símbolo de dólar. Vamos a crear este archivo.

Recordad que estamos en la ruta «/home/miusuario/docker/pihole». Desde ahí tecleamos el siguiente comando para crear las variables de entorno

sudo nano .env

Oye: te falta el nombre de archivo. Sólo has puesto la extensión. De nada. 

Cómo te gusta llevarme la contraria. ¡Pues no! No falta nada. En linux un archivo oculto es uno que no tiene nombre, sólo extensión. En el editor que nos sale al escribir ese comando, pegamos lo siguiente.

DOCKERDIR=/home/usuario/docker
TZ=Europe/Madrid
WEBPASSWORD=passwordseguraparaaccederalaweb
DIRECCIONIP=192.168.1.15

Y en este archivo sí que debemos modificar TODAS las líneas con los parámetros de nuestra instalación.

• DOCKERDIR: Debemos poner la ruta hacia la carpeta «docker». Si os fijáis, sólamente hay que cambiar la palabra «usuario» por el nombre del usuario de la raspberry. Eso le dirá la ruta correcta al archivo docker_compose.yml para acceder a los volúmenes que hemos creado.
• TZ: Debéis poner la localización de vuestra instalación (para que la fecha sea correcta). Si estáis en algún sitio de la España peninsular ya os sirve lo que está, pero os doy posibles valores de algunos sitios en los que se habla español por si leeis esto desde algún otro lado:
  • Atlantic/Canary (Islas Canarias)
  • América/México_City (México)
  • America/Bogota (Colombia)
  • America/Buenos_Aires (Argentina)
  • America/Santiago (Chile)
  • America/Lima (Perú)
  • America/Caracas (Venezuela)
  • America/La_Paz (Bolivia)
  • America/Los_Angeles (California, Estados Unidos)
  • America/New_York (Nueva York, Estados Unidos)

... sitios en los que se habla español... y me mete a Estados Unidos. Jeje. Qué cachondo.

• WEBPASSWORD: Es la password que necesitaréis para acceder a la web de gestión de pi-hole. Os ruego que seáis seguros con estas cosas. Cambiad la que os dejo y poned una que cumpla todo esto:
  • Que sea larga
  • Tenga letras mayúsculas
  • Tenga letras minúsculas
  • Tenga números
  • Tenga símbolos
  • No hayáis utilizado en ningún otro sitio y que sea relativamente complicada.

Vaya... yo iba a poner de contraseña "mi_ex", pero es muy fácil y se ve que también un poco corta, así que...

¡¡Usuario Anónimo!! ¡Si sigues así te echo!

• DIRECCIONIP: Poned la dirección ip de vuestra Raspberry (la definimos en el primer tutorial).

Cuando hayáis terminado de escribir todos esos cambios, pulsamos «Control» + «o» para guardarlos y «Control» + «x» para salir del editor de texto.

4) Protegemos el archivo de variables de entorno.

Como estamos haciendo las cosas bien desde el principio no nos va a llegar sólo con poner las variables en un archivo a parte, sino que vamos a hacer que nadie más que nosotros pueda ver ese archivo. Desde la carpeta en la que estamos escribimos el siguiente comando.

sudo chmod 600 .env

Este comando sirve para decirle al sistema que ningún usuario más que nosotros podrá ver o editar el archivo. Así de simple.

Recapitulemos. Ahora tenemos una ruta llamada así:

/home/usuario/docker/pihole

En esa ruta hay tres «cosas» que nosotros podemos ver con el comando «ls», que son:

• docker-compose.yml –> Es un archivo para generar nuestro docker.
• etc-dnsmasq.d –> Es una carpeta
• etc-pihole –> Es otra carpeta.

Si vemos todos los archivos (incluso los ocultos) con el comando ls -l -a -h, nos aparecerá un archivo oculto a mayores que es:

• .env –> Es un archivo oculto con variables de entorno.

Vamos ahora por fin a desplegar la máquina.

5) Desplegamos la máquina

Desde el directorio «pihole», ejecutamos el siguiente comando:

sudo docker-compose -p "pihole" up -d

Vamos a ver qué significa cada uno de los componentes de ese comando.

• «sudo»: Es para ejecutar el comando con privilegios elevados (como diríamos en Windows, «ejecutarlo como administrador»).
• «docker-compose»: Este es el comando que se utiliza para interactuar con Docker Compose. En esta ocasión lo usaremos para desplegar el Docker que nos interesa.
• «-p «pihole»»: Esta opción se utiliza para especificar el nombre del proyecto para Docker Compose. En este caso, el nombre del proyecto va a ser «pihole».
• «up»: Este es un subcomando de «docker-compose» que se utiliza para crear y comenzar a ejecutar los servicios que hemos indicado en el archivo docker-compose.yml. Vamos, que este comando inicia (o levanta) el contenedor que nos interesa.
• «-d»: Esta opción se utiliza junto con el comando «up» y se utiliza para ejecutar los contenedores en segundo plano (la «d» viene de se ejecuta en modo «detached»).

Hay quien acorta esta sentencia y pone sólo «docker-compose up -d» y deja que el nombre se defina sólo. Yo es que soy un poco repelente y prefiero definirlo yo mismo. ¡Qué le voy a hacer!

Dejamos que se ejecute el comando (vamos a ver cómo se descarga la imagen y se crea el contenedor) y después de un tiempo ¡¡Ya tenemos nuestro primer Docker funcionando!!

Si quieres acceder al interfaz de configuración de Pi-hole, puedes acceder a él a través de la ip de vuestra Raspberry, usando una dirección similar a ésta:

https://192.168.1.15:8091

(Evidentemente, sustituyendo la ip por la ip de vuestra Raspberry).

Resumamos los puntos que hemos hecho (Como os he dicho, en los siguientes tutoriales serán los mismos)

1. Creamos un directorio para nuestro docker dentro de la carpeta «dockers». Lo hemos llamado «pihole».
2. Creamos las carpetas dentro de pi-hole para los volúmenes de este docker. En este caso eran las carpetas etc-dnsmasq.d y etc-pihole.
3. Creamos un archivo docker-compose.yml y le pegamos el contenido que os he puesto.
4. Creamos un archivo .env, pegamos el contenido que os he puesto y le ponemos los datos de la instalación (contraseñas, etc…)
5. Le damos seguridad a ese archivo.
6. Desplegamos la máquina escribiendo un único comando.

No es tan difícil y la ventaja es que SIEMPRE SIEMPRE SIEMPRE el procedimiento es igual a la hora de desplegar cualquier Docker. Puede haber Dockers más complejos, con más variables, etc… pero el esquema para desplegar cualquier docker es siempre el mismo.

Y ahora que está instalado pi-hole ¿Cómo lo configuro?

Pues de la misma forma que si hubieras hecho una instalación normal. Como el proceso de configuración de pi-hole ya lo expliqué en este tutorial en su día, os remito a él. A partir del punto 3 se os explica cómo configurar vuestro router para que use las dns que otorga el pi-hole y cómo poner más listas de filtrado.

Y con esto terminamos. No os olvidéis de darle a like, suscribios al canal y...

¡Aún no terminamos! Vamos a explicar algo que nunca se comenta a la hora de instalar un docker.

6) ¿Cómo se actualiza este Docker?

Sí. Está muy bien montar un docker y que todo funcione, pero ¿Y si sale una versión nueva de Pi-hole? ¿Cómo se actualiza? Pues es muy sencillo, pero a mi personalmente me gusta automatizarlo con un pequeño script que ya de paso actualice todo el sistema operativo.

Vamos a irnos a la carpeta home del usuario. Podemos irnos tecleando dos veces «cd ..» pero vamos a hacerlo con un comando que me mola mucho usar. Es éste:

cd ~

¡Quieto parao! ¿Cómo has puesto esa raya ondulada? Estoy buscando por el teclado y no la veo. 

Esa raya ondulada se llama «virgulilla» y es lo que ponemos encima de la letra eñe. Para escribirla puedes hacerlo de dos formas. Escribes primero «cd» y un espacio. Luego pulsas la tecla «alt» y mientras la mantienes pulsada escribes el número 126, o también en windows puedes ponerla pulsando la tecla «Alt Gr» y mientras la mantienes pulsada pulsas el número 4 y luego pulsas un espacio. En todo caso es una forma muy rápida de llegar a la carpeta «home» desde cualquier lugar.

Una vez que estemos en la carpeta «home» vamos a crear un script que nos actualice tanto el sistema operativo como el Docker que acabamos de crear.

Escribimos el siguiente comando:

sudo nano actualizar.sh

Ahora copiamos el siguiente texto y lo pegamos en el editor. Pero ojo: modificad la quinta línea para poner la ruta correcta la la carpeta «pihole». Si habéis seguido el tutorial al pie de la letrae, únicamente tenéis que modificar la palaba «usuario» por vuestro usuario.

sudo apt-get update -y
sudo apt-get dist-upgrade -y
sudo apt-get autoremove -y
sudo apt-get autoclean -y
cd /home/usuario/docker/pihole
sudo docker-compose pull
sudo docker-compose up -d --remove-orphans
sudo docker image prune -f
sudo shutdown -r now

Por último pulsamos como siempre «Control» + «o» para guardar cambios y «Control» + «x» para salir del editor.

¿Qué es lo que hace este código? Pues vamos a explicar línea por línea:

• Las dos primeras líneas ya las explicamos en el primer artículo sobre docker: sirven para actualizar el sistema operativo y el software instalado (no lo que hay dentro de docker). Le ponemos a cada una de las líneas el «-y» al final para que no nos pregunte si deseamos instalar las actualizaciones y las instale directamente.
• sudo apt-get autoremove -y –> Este comando elimina automáticamente los paquetes de software que fueron instalados como dependencias de otros paquetes, pero que ya no son necesarios. Digamos… que hace limpieza en el sistema.
• sudo apt-get autoclean -y –> Cuando instalas o actualizas paquetes, se almacena una copia de estos paquetes en la caché del sistema para evitar tener que volver a descargarlos si son necesarios nuevamente en el futuro. Este comando elimina las versiones antiguas de estos paquetes del caché, dejando solo las versiones más recientes. En cristiano: También hace limpieza al sistema.
• cd /home/usuario/docker/pihole –> Este comando seguro que también sabéis qué hace: Nos sitúa en la carpeta dónde hemos instalado el archivo .yml del Pi-hole. De nuevo os recuerdo: en esta línea cambiad la palabra «usuario» por el usuario de vuestra Raspberry para que pueda ir a la ruta correcta u obtendréis un error.
• sudo docker-compose pull –> Actualiza las imágenes a las que pueda hacer referencia el archivo docker-compose.yml. Y sí, digo «las» en lugar de «la» porque puede que ese docker use varias imágenes de varios componentes distintos (veremos este caso en otras instalaciones).
• sudo docker-compose up -d –remove-orphans –> Siguiendo las instrucciones de las imágenes que ha actualizado el comando anterior, crea y comienza a ejecutar los contenedores definidos en el archivo docker-compose.yml. El argumento "-d» indica que los contenedores deben ejecutarse en segundo plano. «--remove-orphans» elimina los contenedores que ya no están definidos en el archivo docker-compose.yml (puede que una actualización los haya eliminado. Recuerdo que me ha pasado por ejemplo con Vikunja). En cristiano: Levanta de nuevo los contenedores pero basándose en las imágenes recién descargadas con el comando anterior.
• sudo docker image prune -f –> Este comando simplemente elimina imágenes de Docker no utilizadas (las que no están asociadas con ningún contenedor en ejecución). El argumento «-f» indica que no se va a pedir confirmación al usuario.
• sudo shutdown -r now –> Reinicia toda la rasberry. El argumento «-r» indica que se reinicie y el argumento «now» indica que se haga en el momento de la ejecución del comando.

¿Como vamos a hacer para ejecutar ese archivo? Primero debemos hacerlo ejecutable con este comando:

sudo chmod +x actualizar.sh

Y luego, cuando queramos ejecutar el actualizador, lo haríamos con este comando:

./actualizar.sh

Y ahora sí que sí. Con esto ya hemos explicado cómo se instala este Docker en concreto, entendiendo para qué sirve cada uno de los comandos. En el próximo artículo veremos comandos que nos servirán para arreglar posibles problemas con nuestros dockers y luego instalaremos con el mismo método un servidor de VPN, pero ya no nos vamos a parar tanto a explicar cada una de las cosas que estamos haciendo e iremos más al grano.

Ahora es vuestro turno ¿Habéis tenido problemas para seguir el tutorial? ¿Tenéis alguna duda con algún comando o queréis aportar alguna modificación? Estoy deseando leer vuestros comentarios.