PiServer con Docker – Parte 6: Ejercicios de despliegue de Docker usando gestores de descargas P2P

Después de unos cuantos tutoriales ya hemos aprendido a hacer un montón de cosas con Docker en nuestra Raspberry. Os las resumo antes de empezar.

• Parte 1: Hemos instalado el sistema operativo a una Raspberry
• Parte 2: Hemos explicado qué es Docker y sus componentes, y hemos instalado en nuestro equipo Docker y Docker compose.
• Parte 3: Hemos instalado nuestro primer Docker (Esto lo podemos hacer en una Raspberry o en un ordenador con cualquier Linux derivado de Debian o Ubuntu)
• Parte 4: Hemos explicado unos cuantos comandos útiles para resolver problemas y gestionar nuestros Dockers.
• Parte 5: Le hemos instalado un VPN a nuestra Raspberry con un gestor web de usuarios incluído (Casi na).

En este tutorial vamos a aprender a instalar con docker dos de los sistemas de descargas P2P más utilizados: aMule (que es muy similar al mítico eMule) y Transmission (que sirve para descargar archivos Torrent).

¡¡Pero qué dices!! ¡¡Esos sistemas de descargas son ilegales!! Son para bajarse cosas piratas como programas, películas y videojuegos y cosas así. ¡Policía! 

Quieto parao, Usuario Anónimo. Acepto que determinadas personas interesadas y que toman partido en difundir este tipo de bulos intenten hacernos creer todas estas cosas que dices, pero ese razonamiento es lo mismo que decir que por tener cuchillos en mi cocina soy un asesino. Con aMule y Transmission puedes descargarte un montón de cosas legales. De hecho la mayoría de distribuciones Linux en sus propias páginas oficiales suelen tener un enlace para descargártelas a través de un cliente de Bit Torrent, al igual que muchos programas de software libre. Así que dejemos las cosas claras. Son programas útiles y legales. Eso sí: desde aquí os pido que no os bajéis contenido pirata con estos programas ni con ningún otro.

volvamos a lo que nos interesa. En esta ocasión vamos a plantear este artículo como un ejercicio. Os voy a poner en cada uno de los casos un archivo de docker compose tal cual se distribuye por el desarrollador de turno y vosotros tendréis que saber cómo modificarlo para que además de funcionar, sea completamente seguro y guarde los archivos descargados dónde nosotros queremos. Con todo lo que hemos visto seguro que no tendréis problemas. Me pararé mucho más con el primer ejercicio y en el segundo sólo os daré el «enunciado» y la solución.

Ejercicio 1: despliegue de aMule.

Al igual que pasó con Wireguard, aMule no tiene una imagen de Docker oficial, así que usaremos la imagen que más se está usando para desplegarlo. La podemos obtener de esta web.

https://github.com/ngosang/docker-amule

En esa web podemos ir a la zona docker-compose.yml y veremos que el código del archivo es el siguiente:

version: '2.1'
services:
  amule:
    image: ngosang/amule
    container_name: amule
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/London
      - GUI_PWD=<fill_password>
      - WEBUI_PWD=<fill_password>
      - MOD_AUTO_RESTART_ENABLED=true
      - MOD_AUTO_RESTART_CRON=0 6 * * *
      - MOD_AUTO_SHARE_ENABLED=false
      - MOD_AUTO_SHARE_DIRECTORIES=/incoming;/my_movies
      - MOD_FIX_KAD_GRAPH_ENABLED=true
      - MOD_FIX_KAD_BOOTSTRAP_ENABLED=true
    ports:
      - "4711:4711" # web ui
      - "4712:4712" # remote gui, webserver, cmd ...
      - "4662:4662" # ed2k tcp
      - "4665:4665/udp" # ed2k global search udp (tcp port +3)
      - "4672:4672/udp" # ed2k udp
    volumes:
      - <fill_amule_configuration_path>:/home/amule/.aMule
      - <fill_amule_completed_downloads_path>:/incoming
      - <fill_amule_incomplete_downloads_path>:/temp
    restart: unless-stopped

No os pongáis a crear el archivo aún. Poned el código en un bloc de notas y pensad qué haríais vosotros para desplegarlo. El ejercicio es hacer lo siguiente:

1. Saber qué carpetas debemos crear para los datos que use el docker (volúmenes).
2. Modificar el archivo docker-compose-yml para que los volúmenes apunten a dónde queramos nosotros.
3. Modificarlo de nuevo para usar variables de entorno tanto para volúmenes como para datos sensibles.
4. Crear el archivo de variables de entorno y darle seguridad.
5. Desplegar el programa.
6. Hacer un script para actualizar el docker.

Así que Id pensando cómo haríais todo eso antes de mirar la solución de cada apartado. Apuntad todo en un block de notas y comparadlo con todo lo que vamos a poner aquí.

1.- Carpetas que vamos a crear.

Si habéis estado atentos a los tutoriales anteriores, habréis visto que las carpetas que necesitamos normalmente están en el apartado «volumes», así que debemos centrarnos en estas tres líneas.

      - <fill_amule_configuration_path>:/home/amule/.aMule
      - <fill_amule_completed_downloads_path>:/incoming
      - <fill_amule_incomplete_downloads_path>:/temp

Veamos para que sirven estas tres carpetas en una instalación estándar de aMule.

• /home/amule/.aMule: como podéis ver, aMule durante la instalación nos crea una carpeta de usuario en el sistema (llamada amule) y dentro de ella crea otra carpeta oculta (llamada .aMule). Es ahí dónde aMule guarda todas sus configuraciones (no las crea en /etc, que es el sitio habitual para estas cosas).
• /incoming: es el lugar dónde aMule guarda todas las cosas que ha terminado de descargar y que está compartiendo con otros usuarios.
• /temp: es el lugar donde, temporalmente, aMule va guardando los archivos que está descargando y que están incompletos. Cuando están completos se mueven a la carpeta /incoming.

Espera, pero en el apartado "environments" veo esta línea: 

MOD_AUTO_SHARE_DIRECTORIES=/incoming;/my_movies

Ahí hay más carpetas. 

Efectivamente, pero esa línea define qué carpetas van a compartirse para que otros usuarios puedan descargar contenido que estamos compartiendo. Serían carpetas que ya están creadas dentro del propio Docker, no los volúmenes que vamos a crear (aunque luego esas carpetas apunten a los volúmenes). No es algo que vayamos a mirar ahora mismo porque repito que esa línea no define volúmenes, pero en todo caso te adelanto que luego sí que revisaremos qué pasa con ésta línea.

Sabiendo para qué sirven esas tres carpetas, vamos a crear una carpeta llamada config en la que vaya toda la configuración del programa, otra llamada completadas en las que vamos a poner las descargas completadas y una última llamada incompletas en la que estarán las descargas que aún están en curso. Así que vamos a ir a la carpeta docker que habíamos creado en /home/<nuestro_usuario> (si no habéis hecho los anteriores tutoriales, deberíais crear la carpeta con el comando sudo mkdir docker). Ahí crearemos primero la carpeta en la que vamos a almacenar todo lo del aMule, y dentro de ella crearemos esas tres carpetas. Lo haremos todo con estos tres comandos.

mkdir amule
cd amule
mkdir config && mkdir completadas && mkdir incompletas

2.- Modifico el docker-compose-yml para que los volúmenes apunten a las rutas que hemos definido.

Vamos a ignorar de momento las variables de entorno. Nos centraremos en la zona de Volúmenes. Si no usásemos las variables de entorno ¿Cómo modificaríais el archivo docker-compose.yml para que los volumenes apunten a esas carpetas recién creadas?

Pues muy sencillo. En la parte de la izquierda deberíamos poner la ruta a cada una de las carpetas que acabamos de crear. Nos quedaría la zona inferior similar a esto.

      - /home/<user_de_linux>/docker/amule/config:/home/amule/.aMule
      - /home/<user_de_linux>/docker/amule/completadas:/incoming
      - /home/<user_de_linux>/docker/amule/incompletas:/temp

Aún no hemos terminado. Esto es lo que quiere el desarrollador que hagamos y con esto, el apartado de volúmenes quedaría correctamente configurado. Pero no llegaría a los estándares de seguridad que quiero que tengáis. Vamos a ver cómo hacer todo esto (y algo más) con variables de entorno.

3.- Creo variables de entorno y hago el docker-compose.yml final.

Tal y cómo hicimos en los anteriores tutoriales, vamos a ver qué cosas nos puede interesar poner en el el archivo de variables de entorno (que estará securizado para que nadie pueda entrar en él). Ahí pondremos las configuraciones que posiblemente tengamos que tocar en algún momento, las contraseñas y los volúmenes. Así que primero vamos a identificar todo lo que vamos a sacar del docker-compose.yml .

En el apartado «environment», creo que es positivo sacar estas variables.

• TZ=Europe/London: Esto es algo que debemos modificar para indicar la zona horaria en la que se hace la instalación.
• GUI_PWD=<fill_password>: Aquí debemos poner la contraseña para acceder desde el «Amule GUI», que es un programa para controlar desde nuestro ordenador habitual todo lo que hace nuestro servidor de aMule.
• WEBUI_PWD=<fill_password>: Aquí debemos poner la contraseña con la que podremos acceder a la web que va a generar nuestro aMule.

Vamos a apuntar esos tres puntos para sacarlos fuera del docker-compose.yml. Tenemos un punto más con carpetas dentro de «environment», que es el siguiente:

MOD_AUTO_SHARE_DIRECTORIES=/incoming;/my_movies

Ojo: esta línea no está definiendo volúmenes. Define una configuración dentro del Docker que indica qué carpetas van a estar compartidas para que otros usuarios de aMule puedan descargarse cosas de nuestra instalación.

Personalmente, tener varias carpetas para descargas tal y cómo define el archivo por defecto se me hace confuso, así que simplemente modifico esta línea en el propio docker-compose.yml y la dejo así (no voy a ponerla en variables de entorno).

MOD_AUTO_SHARE_DIRECTORIES=/incoming

No lo entiendo. ¿Y por qué no pones esa configuración también en el archivo que vamos a hacer de variables de entorno? Ya que estamos...

Podría hacerlo perfectamente, Usuario Anónimo, y de hecho si alguien lo hace el Docker funcionaría perfectamente y no tendría nada que objetar. Sin embargo no va a aportar nada de seguridad el poner esa línea fuera. La carpeta «incoming» es una carpeta propia de aMule y además, más abajo en el docker-compose.yml vamos a decir que la vamos a mapear a otra ruta. Otro motivo por el que no voy a añadir esa línea al archivo de variables de entorno es que no quiero pasar a ese archivo configuraciones que no me parecen relevantes para la seguridad ni para la comodidad de la instalación (son cosas que ni siquiera voy a modificar de la configuración de este docker). No tenemos que pasar todo a variables. Sólo pasamos lo que nos interesa modificar o por seguridad. Como quiero que todos uséis sólo la carpeta «incoming» y no quiero que modifiquéis esa configuración, esa línea la dejo en el docker-compose.yml modificada como yo quiero y no la saco a las variables de entorno.

Vale: ya tenemos identificadas qué líneas vamos a pasar a variables de entorno: las tres que acabamos de poner del apartado «environment» y las del apartado «volumes». Pero… Fijaos en los volúmenes. Os los voy a poner de nuevo.

- /home/<user_de_linux>/docker/amule/config:/home/amule/.aMule
- /home/<user_de_linux>/docker/amule/completadas:/incoming
- /home/<user_de_linux>/docker/amule/incompletas:/temp

¿Os fijáis que los tres empiezan por la misma ruta? Puedo hacer todo más sencillo si en lugar de «mapear» tres rutas distintas, sólo lo hago con la parte que es igual en las tres líneas.

Vale… sabemos ya todo lo que hay que pasar a volúmenes. Vamos a rehacer primero el docker-compose.yml poniendo todos esos cambios. Recordad que si vamos a sacar algo hacia afuera, hay que poner un símbolo de dolar ($) y ponerle un nombre a esa variable. Pensad bien cómo lo haríais. Os dejo cómo lo hago yo aquí abajo (sería el contenido definitivo que debéis pegar en el archivo). Recordad: teclead primero sudo nano docker-compose.yml y luego poned este texto en el archivo.

version: "2.1"
services:
  amule:
    image: ngosang/amule
    container_name: amule
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=$TZ
      - GUI_PWD=$GUI_PWD
      - WEBUI_PWD=$WEBUI_PWD
      - MOD_AUTO_RESTART_ENABLED=true
      - MOD_AUTO_RESTART_CRON=0 6 * * *
      - MOD_AUTO_SHARE_ENABLED=false
      - MOD_AUTO_SHARE_DIRECTORIES=/incoming
      - MOD_FIX_KAD_GRAPH_ENABLED=true
      - MOD_FIX_KAD_BOOTSTRAP_ENABLED=true
    ports:
      - "4711:4711" # web
      - "4712:4712" # remote gui, cmd ...
      - "4662:4662" # ed2k tcp
      - "4665:4665/udp" # ed2k global search udp (tcp port +3)
      - "4672:4672/udp" # ed2k udp
    volumes:
      - ${DOCKERDIR}/amule/config:/home/amule/.aMule
      - ${DOCKERDIR}/amule/completadas:/incoming
      - ${DOCKERDIR}/amule/incompletas:/temp
    restart: unless-stopped

Y no os olvidéis de teclear Control + O para guardar cambios y luego Control + X para salir de nano.

Una duda: Yo le he puesto nombres diferentes a las variables

No pasa nada. Yo renombro las variables con el nombre que aparece en la parte izquierda de la igualdad. Si en lugar de «$GUI_PWD» has puesto «$ClavedelGUI» va a funcionarte igualmente (Siempre que ese nombre que has puesto en la variable luego esté en el archivo que crearemos en el siguiente apartado, claro).

¿Y por qué en el apartado "${DOCKERDIR}" no pones también la carpeta  "amule"?

Para homogeneizar un poco todos mis dockers. Así, en todos y cada uno de ellos, la variable ${DOCKERDIR} en el archivo .env es siempre la misma. Si os fijáis luego, cuando creemos el archivo .env, esa variable en los tutoriales siempre es la misma, sea cual sea el Docker.

¿Y por qué esa variable en el docker-compose.yml va entre llaves y las otras no?

Eso es más complicado de explicar. Para que me entendáis: digamos que es por un requerimiento de la versión 2 de Docker. En Docker Compose, en «environment» siempre definimos variables de entorno dentro del contenedor. Si las queremos sacar hacia fuera, las variables se definen simplemente utilizando el prefijo $, ya que Docker Compose sabe que estas son variables de entorno (no pueden ser otra cosa) y las maneja de manera adecuada.

Por otro lado, en «volumes» lo que definimos son rutas de directorios que se montarán en el contenedor (por defecto no usamos variables). En esta zona, la versión 2 de Docker necesita que se especifiquen las rutas completas usando algo como «${}» para que Docker Compose pueda expandir correctamente las variables y reemplazarlas por sus valores correspondientes durante la ejecución. Si no lo hacemos así, Docker se va a hacer un lío y no va a saber que son variables que necesitan ser expandidas en una ruta de directorio.

¡¡¡¡Ahhh...vaaaale!!!! Ahora lo capto.

(nota mental. No lo entiendo. Para instalar Pi-hole no ha hecho nada de eso. Este tío cada vez hace una cosa distinta). 

A ver… no lo hecho en la instalación de Pi-hole porque su archivo docker-compose.yml estaba en una versión superior que no necesita nada de esto. Si te fijas, todos los docker compose indican al principio con qué versión se han hecho. El Pi-hole lo hemos hecho con la versión 3, al igual que el WG-Easy. Sin embargo, el desarrollador ha hecho este archivo con la versión 2.1. La versión 3 tiene toda esta problemática resuelta, pero la versión 2 de docker aún no, por lo que si se usan variables en los volúmenes, con esta versión hay que usar obligatoriamente las llaves.

4.- Creamos el archivo de variables de entorno y le damos seguridad.

Vamos primero a listar todas las líneas del docker-compose.yml en las que vamos a usar variables de entorno. Serán todas éstas.

TZ=$TZ
GUI_PWD=$GUI_PWD
WEBUI_PWD=$WEBUI_PW
${DOCKERDIR}/amule/config:/home/amule/.aMule
${DOCKERDIR}/amule/completadas:/incoming
${DOCKERDIR}/amule/incompletas:/temp

Pero recordad que las tres últimas líneas usan la misma variable. Así que realmente serán sólo 4 variables que hay que definir. Pensad un poco cómo sería el archivo de variables de entorno (.env) y después seguid leyendo.

Yo, por costumbre, siempre pongo arriba de todo la variable donde defino en qué ruta se almacenan los volúmenes. Tal y cómo lo hago, siempre es igual en todos los Docker que creo (por simple comodidad), así que la primera línea es sencilla.

Las siguientes líneas simplemente deben tener el nombre de la variable y el valor que le vamos a dar, así que al final, lo que debemos hacer es, primero crear el arhivo de variables de entorno con este comando (recordad que debéis ejecutarlo dentro de la capeta /home/<tu_usuario>/docker/amule.

sudo nano .env

Y el contenido del archivo debería ser éste:

DOCKERDIR=/home/<nuestro-usuario>/docker
TZ=Europe/Madrid
GUI_PWD=claveparaentrarenelgui
WEBUI_PWD=claveparaentrarenlaweb

Evidentemente, en <nuestro-usuario> poned el usuario con el que estéis haciendo login en la Raspberry y cambiad las tres últimas variables por los valores que necesitáis (y sed creativos con las contraseñas. No reutilicéis nunca contraseñas que ya estéis usando en otros servicios).

Para darle seguridad al archivo (que nadie pueda acceder a él) simplemente debemos ejecutar este comando.

sudo chmod 600 .env

Con esto tendremos nuestro Docker a punto de caramelo para ser desplegado

5.- Despliegue del docker de aMule.

Esto seguro que a estas alturas lo domináis.

Debemos situarnos en la carpeta /home/<nuestro_usuario>/docker/amule y desde ahí ejecutamos esto.

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

O si somos muy vagos y dejamos que se ponga el nombre por defecto, pondremos esto otro.

sudo docker-compose up -d

Una vez que se termine el despliegue se podrá acceder al interface web de aMule desde la web http://<mi.dirección.ip>:4711

¡Qué bien! Antes sin docker era un lío, porque había que mapear puertos y... 

No te montes películas Usuario Anónimo. Por supuesto que debemos mapear puertos en nuestro router. En concreto debemos mapear los puertos 4662 TCP, 4665 UDP y 4672 UDP hacia la ip local de nuestra raspberry. Que se monte una aplicación en concreto con Docker no evita que tengamos que mapear puertos. Pero una vez que controlas Docker, tanto la instalación como el mantenimiento posterior de la aplicación es mucho más sencillo. Con esos puertos mapeados tendremos siempre ID alta y la máxima velocidad posible. Ah, y por cierto… al igual que en el tutorial de WG-Easy no vamos a hacer esa web disponible desde fuera. Para mi sería un riesgo de seguridad.

Vale... pero esto ahora ¿cómo se usa?

Esto ya lo explicamos en el anterior tutorial en el que explicábamos cómo instalar aMule sin docker. Os recomiendo mirar en ese artículo el punto 7 para saber cómo funciona la web (aunque la web que nos crea este Docker está hipervitaminada comparada con la habitual de aMule), el punto 8 para saber cómo configurar el aMule GUI (que es el programa que podéis instalar en vuestro ordenador para controlar el aMule como si estuviera instalado localmente) y el punto 10 para saber cómo compartir la carpeta dónde se van a almacenar las descargas (para poder acceder a ella desde otros ordenadores).

6.- Creamos un script para actualizar Docker.

No nos podemos olvidar de este punto. Hasta ahora, si habéis seguido todos los tutoriales, deberíais tener esto en un archivo llamado actualizar.sh en la carpeta de vuestro usuario, que podemos ver con el comando sudo nano actualizar.sh . El archivo por el momento (sin añadir cambios) es así.

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

Seguro que un vistazo rápido os dirá cómo añadir el Docker del aMule para que se actualice junto con los otros dockers. Sólo tenéis que añadir una línea que dirija al script a la carpeta dónde está el docker-compose.yml del aMule y luego copiar los cuatro comandos que actualizan el docker que nos interesa. El archivo quedaría así.

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

Si no hemos hecho ninguno de los tutoriales anteriores, nos quedaríamos sólo con la primera parte del archivo, dónde se actualiza el sistema operativo, y con la última dónde se actualiza el aMule, por lo que nos quedaría de esta otra forma.

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

Como siempre, usamos Control + O para guardar los cambios y Control + X para salir de «nano». Y si estamos creando el archivo por primera vez, le daríamos facultades para que pudiera ser ejecutado con el comando sudo chmod +x actualizar.sh . Y evidentemente podríamos ejecutarlo con el comando ./actualizar.sh .

Con esto ya tenemos el aMule completamente funcional. Vamos a hacer otro ejercicio de despliegue exactamente igual pero con otro programa similar. A ver qué tal os sale.

Ejercicio 2: despliegue de Transmission.

Transmission es un conocido programa para poder descargar archivos a través del protocolo Bit Torrent (Sí… los archivos Torrent que tan famosos han sido hace unos cuantos años). Vamos a desplegar este programa en la raspberry. Una vez que dejemos todo funcionando, al igual que con el aMule vamos a poder controlarlo sin problemas desde nuestro ordenador habitual con un programa cliente.

Al igual que en el caso anterior, os voy a dejar un archivo docker-compose.yml y debéis hacer todo el proceso para instalarlo de forma efectiva y segura. El contenido del archivo es éste.

version: "3"
services:
  transmission:
    image: ghcr.io/linuxserver/transmission
    container_name: Transmission
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Madrid
      - TRANSMISSION_WEB_HOME=/kettu/
      - USER=empalador
      - PASS=nocturno
    volumes:
      - ~/docker/transmission/config:/config
      - ~/docker/transmission/descargas:/downloads
      - ~/docker/transmission/descargas:/watch
    ports:
      - 9091:9091
      - 51413:51413
      - 51413:51413/udp
    restart: unless-stopped

Pensad como haríais todo el proceso (fijaos en la versión del archivo, los volúmenes y qué variables os interesa pasar al archivo .env). En esta ocasión os pongo directamente la forma que tengo yo de modificarlo.

1.- Creamos la estructura de volúmenes dentro de la carpeta «dockers».

En la carpeta /home/<nuestro_usuario>/dockers vamos a crear las tres carpetas que se indican en el apartado «volumes». Para ello, desde esa carpeta, debemos teclear estos comandos.

mkdir transmission
cd transmission
mkdir config && mkdir downloads && mkdir watch

2.- Creamos el archivo modificado de docker compose.

Dentro de la carpeta transmission creamos el archivo de docker compose con el comando sudo nano docker-compose.yml y ponemos en él el siguiente código.

version: "3"
services:
  transmission:
    image: ghcr.io/linuxserver/transmission
    container_name: transmission
    environment:
      PUID: 1000
      PGID: 1000
      TZ: $TZ
      USER: $USUARIO
      PASS: $CLAVE
    volumes:
      - $DOCKERDIR/transmission/config:/config
      - $DOCKERDIR/transmission/downloads:/downloads
      - $DOCKERDIR/transmission/watch:/watch
    ports:
      - 9091:9091
      - 51413:51413
      - 51413:51413/udp
    restart: unless-stopped

Fijaos que además de los volúmenes he puesto tres variables de entorno, muy similares a las que usamos en el caso del aMule. Y como la versión del docker compose es la 3, no vamos a necesitar poner llaves a las variables que usemos dentro del apartado «volumes».

3.- Creo el archivo de variables de entorno y lo protejo.

En la carpeta dónde he creado el archivo de docker compose, creo el archivo de variables de entorno con el comando sudo nano .env y le pongo este contenido.

DOCKERDIR=/home/<nuestro-usuario>/docker
TZ=Europe/Madrid
USUARIO=usuarioparaweb
CLAVE=contraseñaparaweb

No me cansaré nunca de decirlo: por favor, usad contraseñas seguras y que no hayáis usado nunca antes.

Ese archivo debo protegerlo para que nadie pueda entrar en él. Lo hago con el comando sudo chmod 600 .env .

4.- Desplegamos la máquina.

Desde esa misma carpeta ejecuto este comando para desplegar el docker.

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

Una vez desplegado, puedo comprobar que el docker funciona correctamente accediendo al panel de control de la web que está en la direccion https://<ip-de-la-raspberry>:9091

Para que funcione todo correctamente, debo también mapear en el router el puerto 51413 TCP y UDP hacia la ip de la Raspberry.

El uso de Transmission desde el interfaz web o desde la aplicación de escritorio lo podéis aprender el en punto 5 y 6 de esta página.

5.- Actualización de este docker.

Como siempre, actualizar este docker es añadir una línea más a nuestro archivo actualizar.sh que está situado en la carpeta de nuestro usuario. Le hacemos un nano actualizar.sh para entrar en él y lo dejamos más o menos así:

sudo apt-get update -y
sudo apt-get dist-upgrade -y
sudo apt-get autoremove -y
sudo apt-get autoclean -y
cd /home/<tu_usuario>/docker/pihole
sudo docker-compose pull
sudo docker-compose up -d --remove-orphans
sudo docker image prune -f
cd /home/<tu_usuario>/docker/wireguard
sudo docker-compose pull
sudo docker-compose up -d --remove-orphans
sudo docker image prune -f
sudo shutdown -r now
cd /home/<tu_usuario>/docker/amule
sudo docker-compose pull
sudo docker-compose up -d --remove-orphans
sudo docker image prune -f
sudo shutdown -r now
cd /home/<tu_usuario>/docker/transmission
sudo docker-compose pull
sudo docker-compose up -d --remove-orphans
sudo docker image prune -f
sudo shutdown -r now

Pulsamos Control + O para guardar cambios y Control + X para salir de nano. Si no hemos instalado nada de lo anterior, el archivo sería mucho más corto. Sería algo como ésto.

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

Después de hacerle un chmod +x actualizar.sh que lo convierte en ejecutable, podríamos ejecutarlo con el comando ./actualizar.sh .

Como veis, una vez que estamos acostumbrados al formato de este tipo de archivos, casi siempre el despliegue se realiza de la misma forma.

¿Qué tal os han salido los ejercicios? Sé que la mayoría de la gente no se pone a hacer tanta historia con variables de entorno y cosas así, pero esta es una forma más segura de hacer un despliegue de Docker Compose. ¿Ha habido algún punto que os haya salido mal y que no comprendáis? Estaré atento a vuestros comentarios.