Tutoriales, noticias y soluciones informáticas

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.

Nube P2P
  • 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! 
Amigos viendo contenido descargado en P2P

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.

Share

10 comentarios

  1. Jose Miguel

    Hecho y funcionando, gracias de nuevo.

    Una pena que la web ui de Amule sea tan mala. Metes algo en el campo de búsqueda y le das a buscar y hace un page reload lento para acabar mostrando …. nada! Incluso desaparece el texto de la caja de búsqueda. Y te da la sensación de que no está haciendo nada o de que no funciona. Sin embargo haces un refresh manual de la página y ya muestra resultados de la búsqueda (o sea que si que funcionaba). Y así con cualquier cosa que toques en su web ui.

    La web ui de Transmission es cojonuda, refresca automáticamente sin transición visible, de modo que ves el progreso prácticamente en tiempo real y cualquier cosa que toques actualiza inmediatamente y sin transición entre reloads apreciable.

    Gracias y sigue instalándonos dockers. Un saludo.

    • Marcos

      A lo mejor no creerías que la web de Amule es tan mala si hubieras probado la que tiene en la instalación oficial (sin docker). Es bastante más cutre que la que obtenemos en esta instalación. Aunque aún así, para que vamos a decir otra cosa… en el fondo es bastante mala. Por eso siempre recomiendo instalar en el equipo que va a conectarse con ese servidor de aMule el «aMule GUI». Tendrás exactamente el mismo interfaz de usuario que si hubieras instalado aMule (o eMule) localmente en el ordenador y con la ventaja de que no tienes que dejarlo encendido horas y horas para hacer una descarga completa. Dejas encendida la raspberry, que consume casi nada y listo.

      Transmission sí tiene una web mucho más digna. Aunque… llámame rarito si quieres, pero me gusta mucho más el aMule. Tiene búsquedas integradas, cuando buscas algo tienes muchas más cosas dónde elegir, encuentras cosas mucho más raras (típico programa libre de hace mil años que no lo encuentras en ningún sitio), no tienes que entrar en ninguna web para buscar las cosas, y en los tiempos que corren alcanza casi siempre la misma velocidad que Transmission.

      • Jose Miguel

        Bueno. Gracias a ti he desconectado mi vieja Rpi 3b+ con Seafile, transmission, navidrome, nginx-proxy, pihole, fail2ban y algo más (todo instalado directamente en el OS) y he sacado una Rpi 4 de 4gb de RAM que un día usé de Desktop y que acabé metiendo en un cajón. De momento tengo todos los dockers que has publicado más Seafile-docker, que es imprescindible para mí de momento, y navidrome, también en su docker.

        Es decir, no sólo he instalado lo que has publicado sino que he hecho otras instalaciones en docker siguiendo tus «reglas» ( variables y archivos .env). Mirando los docker-composer.yml del proyecto, claro.
        Bueno, samba y fail2ban corren sobre el OS. No creo necesario ni conveniente que sea de otra forma.
        Además la Rpi 4 arranca desde SSD, sin tarjeta. Y la diferencia es muy grande. O sea, muy contento. Te debo un par de comidas con su aperitivo y café-copas.

        • Marcos

          El siguiente tutorial (que casi está terminado y lo más probable será que lo programe para que se publique el lunes) será un poco de transición instalando Plex, pero en el siguiente vamos a ver cómo se instala precisamente nginx proxy, que va a ser fundamental para los siguientes que veamos. Posiblemente ese tarde un poco más en publicarse, ya que tendré que explicar todo lo relativo a la publicación de una web en internet (puertos, certificados, protocolos, etc…). Me alegra que todo el rollazo que estoy publicando le pueda servir a alguien.

  2. leo

    Todo instalado correctamente, el tema es que al desplegarlo, me salio la pantallita azul con el mensaje: Daemons using outdated libraries, y me preguntaba que servicios queria reiniciar….
    le he dado a cancelar y ha seguido sin problemas.
    No la he liado, verdad? jejeje
    Muchas gracias por este nuevo episodio, a la espera del proximo (mi favorito)

  3. M.L

    que gran trabajo, he seguido todos los pasos y perfecto, espero algun dia hagas una parte de como instalar plex un saludo

    • Marcos

      Sale mañana a las 8:30. Está el artículo listo y programado para publicarse a esa hora

      • M.L

        que maravilla, llevo dias toqueteando la raspberry5 nunca había tenido una y la verdad que las posibilidades son muchas he visto muchos tutoriales en youtube y algún que otro blog le he instalado y desinstalado cosas por probar y tal pero lo que mas quiero es ponerle un servidor plex asi que nada a esperar hasta mañana. te felicito este es la mejor guia en castellano que he encontrado muy buena explicación y didáctica para poder aprender gracias

  4. Yepaswepas

    Gracias por seguir con la saga. Me dejo transmission preparado, pero en la 3B no funciona esa imagen por ser solo para 64 bits. Estoy pendiente de pillar una 5, para entonces espero tener disco nvme que de paso servirá para almacenar las descargas, que ando con una sd de 16Gb jejeje

    • Yepaswepas

      Me auto corrijo. Elegi el sistema de 32 porque solo tiene 1gb de ram. Asi que me toca esperar la nueva.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

© 2024 Flopy.es

Tema por Anders NorenArriba ↑

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.

ACEPTAR
Aviso de cookies