Guía de instalación de aMule 3.1.0 con la nueva interfaz web en Raspberry pi

Hace ya un tiempo publiqué en este blog una guía para compilar aMule 3.0.1 en una Raspberry Pi. Aquella entrada sigue siendo válida como referencia, pero el equipo de desarrollo de aMule ha lanzado la versión 3.1.0, y esta vez sí que estamos ante un salto importante. No es solo un cambio de número: trae un nuevo daemon con API REST, una interfaz web moderna que reemplaza al antiguo amuleweb, mejoras notables en el motor de descargas y un plus de seguridad que se agradece.

En esta guía vamos a hacer una instalación completa desde cero en una Raspberry Pi 5 con Debian 13 (Trixie), aprovechando todas las mejoras y siguiendo las buenas prácticas que ya aplicábamos antes: usuario dedicado, permisos compartidos mediante SGID y servicios systemd.

Si vienes de la guía anterior, verás que el esqueleto es el mismo, pero con las novedades integradas.

¡¡Vamos al lío!!

¿Qué hay de nuevo en aMule 3.1.0?

Antes de empezar, un repaso rápido a lo más relevante, porque justifica de sobra la actualización:

amuleapi: un nuevo daemon que expone una API REST y sirve una interfaz web completamente nueva. Es responsive, tiene modo claro/oscuro, actualizaciones en tiempo real vía SSE y permite gestionar todo aMule desde el navegador, incluyendo la descarga directa de archivos terminados.
Modo «Endgame» mejorado: los bloques finales se solicitan a múltiples fuentes a la vez, evitando el clásico estancamiento al 99%.
Cifrado en las conexiones externas (EC): la comunicación entre amuled y los clientes remotos (amulegui, amuleapi) ahora está cifrada con ChaCha20-Poly1305 o AES-128-GCM.
Fuga de memoria corregida en el daemon, algo que notábamos mucho en ejecuciones prolongadas.
Listas modernas en la GUI de escritorio, migradas a wxDataViewCtrl.
Límites de Kad aumentados y profundidad de peticiones ajustada dinámicamente según el ancho de banda.

Si todo esto te parece suficienteSuficiente. Vamos a instalarlo.

Este manual se compone de los siguientes pasos:

Instalación de dependencias
Creación del usuario dedicado amule
Preparación de directorios y permisos compartidos (SGID)
Descarga del código fuente
Configuración de la compilación con CMake
Compilación e instalación
Primer arranque de amuled y generación de configuración
Servicios systemd
Acceso a la nueva interfaz web
Gestión de los servicios

Requisitos previos

Raspberry Pi 5 con Debian 13 (Trixie).
Disco externo (en mi caso, un disco mécanico de 1 TB montado en /media/Disco_1TB) donde guardaremos descargas y temporales. Ajusta las rutas a tu caso.
Acceso a terminal con un usuario con privilegios sudo (en mi caso, raspberry).
WireGuard en Raspberry PI, VPN casera, segura y gratuita. (opcional, pero recomendable)

1. Instalación de dependencias

Lo primero, como siempre, dejar el sistema al día:

sudo apt update && sudo apt full-upgrade -y

aMule 3.1.0 sigue usando wxWidgets 3.2 y Crypto++ 8.1, así que las dependencias son las mismas que en la versión anterior. Instalamos todo lo necesario para compilar con soporte completo:

sudo apt install -y \
  binutils-dev \
  build-essential \
  cmake \
  gettext \
  git \
  libayatana-appindicator3-dev \
  libboost-all-dev \
  libcrypto++-dev \
  libgd-dev \
  libglib2.0-dev \
  libmaxminddb-dev \
  libreadline-dev \
  libupnp-dev \
  libwxgtk3.2-dev \
  pkg-config \
  wx3.2-headers \
  zlib1g-dev

Si tienes cualquier duda sobre las dependencias, la documentación oficial de compilación las lista todas.

2. Creación del usuario dedicado `amule`

Este es un paso crítico que ya aplicábamos en la guía anterior:
aMule no debe ejecutarse con tu usuario personal. Le creamos una cuenta de sistema dedicada, sin shell de login y con su propio directorio home.
Así, si alguien comprometiera el daemon, no tendría acceso al resto del sistema.

sudo adduser --system --group --home /home/amule --shell /usr/sbin/nologin amule

--system: cuenta de sistema, no de persona.
--group: crea también el grupo amule.
--home /home/amule: home dedicado, donde vivirá toda la configuración de aMule.
--shell /usr/sbin/nologin: bloquea cualquier intento de login con esta cuenta.

3. Preparación de directorios y permisos compartidos (SGID)

Si vas a usar un disco duro externo para tus descargas, es posible que necesites echar un vistazo a la Guía completa: Montar particiones al inicio en Debian

Para que tú, desde tu usuario raspberry, puedas gestionar las descargas sin pelearte con permisos, usaremos el truco del bit SGID sobre las carpetas compartidas. Así todos los archivos que cree aMule heredarán el grupo amule y tú podrás acceder a ellos por pertenencia a ese grupo.

Primero, añade tu usuario al grupo amule:

sudo usermod -aG amule raspberry

Importante: cierra la sesión y vuelve a entrar, o ejecuta newgrp amule en la terminal, para que el sistema reconozca el nuevo grupo. Si no, los permisos no se aplicarán hasta el próximo login.

Ahora crea las carpetas de descargas en el disco externo (ajusta la ruta /media/Disco_1TB/aMule a tu caso):

sudo mkdir -p /media/Disco_1TB/aMule/Incoming
sudo mkdir -p /media/Disco_1TB/aMule/Temp

Asigna la propiedad al usuario y grupo amule, aplica permisos 775 y activa el bit SGID:

sudo chown -R amule:amule /media/Disco_1TB/aMule
sudo chmod -R 775 /media/Disco_1TB/aMule
sudo chmod g+s /media/Disco_1TB/aMule
sudo chmod g+s /media/Disco_1TB/aMule/Incoming
sudo chmod g+s /media/Disco_1TB/aMule/Temp

Con esto, cualquier archivo nuevo que se cree dentro heredará automáticamente el grupo amule, y tú podrás gestionarlo sin problemas.

4. Descarga del código fuente

Clonamos el repositorio oficial y nos situamos en la rama de la versión 3.1.0:

cd ~
git clone --branch 3.1.0 https://github.com/amule-org/amule.git amule-3.1.0
cd amule-3.1.0

Nota: Git te avisará de que estás en estado «detached HEAD». Es totalmente normal: estás apuntando a una etiqueta (tag) concreta, no a una rama. No es un error y no afecta a la compilación.

5. Configuración de la compilación con CMake

Aquí está una de las ventajas de compilar en casa: podemos optimizar el binario específicamente para la arquitectura de la Raspberry Pi 5. Usamos las mismas banderas que ya conoces, que exprimen el Cortex-A76 y las extensiones criptográficas:

cmake -B build \
  -DCMAKE_BUILD_TYPE=RelWithDebInfo \
  -DCMAKE_C_FLAGS="-O3 -march=armv8.2-a+crypto -mtune=cortex-a76 -pipe" \
  -DCMAKE_CXX_FLAGS="-O3 -march=armv8.2-a+crypto -mtune=cortex-a76 -pipe" \
  -DBUILD_MONOLITHIC=NO \
  -DBUILD_DAEMON=YES \
  -DBUILD_AMULECMD=YES \
  -DBUILD_AMULEAPI=YES \
  -DBUILD_REMOTEGUI=YES \
  -DENABLE_UPNP=YES \
  -DCMAKE_INSTALL_PREFIX=/usr/local

Un par de aclaraciones sobre las opciones:

BUILD_MONOLITHIC=NO: no compilamos la GUI de escritorio monolítica, porque en un servidor headless no tiene sentido. Esto ahorra tiempo y recursos.
BUILD_AMULEAPI=YES: activamos el nuevo daemon, la joya de esta versión.
CMAKE_INSTALL_PREFIX=/usr/local: instalamos los binarios en /usr/local/bin, fuera de los paquetes del sistema.

6. Compilación e instalación

Lanzamos la compilación usando todos los núcleos disponibles:

cmake --build build -j"$(nproc)"

En la Raspberry Pi 5 esto tardará un rato, así que paciencia.

Cuando termine:

sudo cmake --install build

Esto instalará los binarios (amuled, amuleapi, amulecmd, amulegui) en /usr/local/bin.

7. Primer arranque de `amuled` y generación de configuración

Ahora vamos a hacer un primer arranque del daemon como el usuario amule para que genere su configuración por defecto:

sudo -u amule amuled -f

Verás que se crea el directorio /home/amule/.aMule/ con el archivo amule.conf y otros.

En este punto aMule se cerrará solo, es totalmente normal.

7.1. Configuración de `amule.conf`

Editamos el archivo de configuración con el usuario correcto para no tener problemas de permisos:

sudo -u amule nano /home/amule/.aMule/amule.conf

Los ajustes que necesitas revisar son:

Sección `[eMule]`

Clave	Valor recomendado	Descripción
`Nick`	`MiPi5` (o el que prefieras)	Tu identidad en la red.
`Port`	`4662`	Puerto TCP de eD2k. Ábrelo en el router para tener High ID.
`UDPPort`	`4672`	Puerto UDP para eD2k y Kad. Ábrelo también.
`Address`	(vacío)	Dirección local a la que se ata. Vacío = cualquier interfaz.
`MaxUpload`	1024 (ejemplo)	Límite de subida en kB/s. `0` = sin límite.
`MaxDownload`	`0`	Límite de bajada. `0` = sin límite.
`SlotAllocation`	`10`	Velocidad objetivo por cada slot.

Sección `[ExternalConnect]`

Esta sección es crítica: es la que permite que amuleapi y amulegui se comuniquen con amuled.

Clave	Valor	Descripción
`AcceptExternalConnections`	`1`	Imprescindible. Activa EC.
`ECPort`	`4712`	Puerto donde `amuled` escucha a clientes remotos.
`ECPassword`	(hash MD5)	Ver más abajo cómo generarlo.

Genera el hash MD5 de la contraseña EC con:

echo -n "MiClaveEC" | md5sum | cut -d ' ' -f 1

Copia el resultado y pégalo en ECPassword. Guarda bien la contraseña en claro porque la vas a necesitar después.

Sección `[Directories]`

Clave	Valor
`IncomingDir`	`/media/Disco_1TB/aMule/Incoming`
`TempDir`	`/media/Disco_1TB/aMule/Temp`

Guarda el archivo y sal.

7.2. Configuración de `amuleapi`

Ahora toca configurar el nuevo daemon. Primero establecemos la contraseña de administrador de la interfaz web:

sudo -u amule amuleapi --set-admin-pass="TuContraseñaWeb"

Opcionalmente, también podemos crear una de invitado (solo lectura):

sudo -u amule amuleapi --set-guest-pass="OtraContraseña"

Ahora editamos la configuración de amuleapi:

sudo -u amule nano /home/amule/.aMule/amuleapi.conf

La sección [EC] es la que conecta amuleapi con amuled. Aquí la contraseña va en texto plano (la misma que hasheaste antes para amule.conf):

[Server]
BindAddress=127.0.0.1
Port=4713
AllowCORS=0

[EC]
Host=127.0.0.1
Port=4712
Password=MiClaveEC
Encryption=1

Ojo: [Server] BindAddress=127.0.0.1 deja la web accesible solo desde la propia Raspberry Pi. Eso es lo que queremos si vamos a poner un proxy inverso con TLS delante. Si vas a acceder directamente desde tu red local, cambia a 0.0.0.0. Y si vas a exponerla a internet, imprescindible usar HTTPS mediante un proxy inverso.

8. Servicios systemd

Creamos dos servicios: uno para amuled y otro para amuleapi. Ambos se ejecutarán como el usuario amule.

8.1. Servicio `amuled`

sudo nano /etc/systemd/system/amuled.service

[Unit]
Description=aMule Daemon
After=network.target network-online.target
Wants=network-online.target

[Service]
Type=forking
User=amule
Group=amule
Environment="HOME=/home/amule"
ExecStart=/usr/local/bin/amuled -f
Restart=on-failure
RestartSec=10
LimitNOFILE=65536
KillMode=control-group
KillSignal=SIGTERM

[Install]
WantedBy=multi-user.target

8.2. Servicio `amuleapi`

sudo nano /etc/systemd/system/amuleapi.service

[Unit]
Description=aMule API & Web UI
After=network.target amuled.service
Requires=amuled.service

[Service]
Type=simple
User=amule
Group=amule
Environment="HOME=/home/amule"
ExecStart=/usr/local/bin/amuleapi
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Habilitamos y arrancamos ambos:

sudo systemctl daemon-reload
sudo systemctl enable --now amuled.service
sudo systemctl enable --now amuleapi.service

Verificamos que están corriendo:

sudo systemctl status amuled.service
sudo systemctl status amuleapi.service

Y si queremos ver logs en vivo:

sudo journalctl -u amuled -f
sudo journalctl -u amuleapi -f

9. Acceso a la nueva interfaz web

Desde un navegador en tu red local, visita:

http://IP_DE_LA_RASPBERRY:4713

Introduce la contraseña de administrador que configuraste antes. La interfaz es completamente funcional: gestiona descargas, búsqueda, estadísticas, preferencias, archivos compartidos… Todo desde el navegador, con actualizaciones en tiempo real.

Si quieres probar la API REST desde la terminal:

curl -X POST http://localhost:4713/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"password":"TuContraseñaWeb"}'

Recibirás un token JWT que podrás usar en el resto de endpoints.

9.1. Acceso desde fuera de casa.

Si quieres controlar aMule desde fuera de tu red local, tienes dos opciones:

⚠️ 9.1.a. Abrir el puerto 4713 en el router (no recomendado)

Esta es la vía rápida: la misma que muchos usábamos con el antiguo amuleweb. Consiste en exponer amuleapi directamente a internet abriendo el puerto en el router. Técnicamente funciona, pero tiene un problema serio: amuleapi habla HTTP en texto plano, sin cifrado.

Los pasos serían estos:

Edita amuleapi.conf para que escuche en todas las interfaces de red en lugar de solo en localhost:

sudo -u amule nano /home/amule/.aMule/amuleapi.conf

Y cambia la sección [Server]:ini

[Server]
BindAddress=0.0.0.0 
Port=4713

Reinicia el servicio para aplicar el cambio:

sudo systemctl restart amuleapi.service

Redirige el puerto 4713 en tu router, la forma de hacerlo dependerá de cada modelo de router

Accede desde fuera (por ejemplo)

http://tu-dominio.duckdns.org:4713

¿Por qué no te lo recomiendo? Por varios motivos que conviene tener claros:

Tus credenciales viajan en claro. Cualquiera que intercepte el tráfico (tu operadora, un WiFi público desde el que te conectes, un atacante en tu misma red) puede leer tu contraseña de administrador y tomar el control de tu aMule.
Los bots escanean internet constantemente. En cuanto abres un puerto, empiezan a llegar intentos de login automatizados. amuleapi tiene protección contra fuerza bruta (LoginFailureThreshold=5 en 60 segundos, con bloqueo de 300 segundos), pero no es infalible.
Superficie de ataque directa. Cualquier vulnerabilidad que se descubra en amuleapi queda expuesta directamente a internet, sin ninguna capa intermedia que filtre.

En definitiva, es lo que hacíamos con amuleweb, y funcionaba. Pero hoy no tiene sentido asumir ese riesgo cuando existen alternativas mejores y casi igual de cómodas.

✅ 9.1.b. Acceder a través de tu VPN WireGuard (recomendado)

Esta es la opción que yo mismo uso y la que te recomiendo sin dudarlo. Si ya tienes montada una VPN WireGuard en tu Raspberry Pi —como expliqué en la entrada WireGuard en Raspberry Pi: VPN casera, segura y gratuita—, ya tienes hecha la mitad del trabajo.

La idea es muy sencilla: en lugar de exponer amuleapi a internet, te conectas primero a tu VPN y luego accedes a la interfaz web como si estuvieras dentro de tu red local. Todo el tráfico viaja cifrado por el túnel de WireGuard, así que no hay ningún riesgo de interceptación.

Ventajas frente a abrir el puerto:

Cifrado de extremo a extremo. Todo el tráfico entre tu dispositivo y la Raspberry Pi viaja cifrado por WireGuard, sin necesidad de certificados SSL ni proxies inversos.
No expones ningún servicio a internet. amuleapi sigue escuchando solo en la interfaz de la VPN. Los bots y escáneres no tienen nada a lo que atacar.
Una sola puerta de entrada. Ya tienes WireGuard como punto de acceso seguro a tu red doméstica. Aprovecharlo para aMule es lo lógico.
Funciona desde cualquier dispositivo: móvil, portátil, tablet… Solo necesitas el cliente WireGuard y tu configuración.

Pasos a seguir:

Conéctate a tu VPN desde el dispositivo que vayas a usar (móvil, portátil…). Verifica que tienes conexión navegando a cualquier web.

Ajusta amuleapi.conf para que escuche en la interfaz de la VPN. Como tu servidor WireGuard usa la IP 10.0.0.1, debes indicarle esa dirección:

sudo -u amule nano /home/amule/.aMule/amuleapi.conf

Y deja la sección [Server] así:

[Server]
BindAddress=10.0.0.1
Port=4713

Nota: Podrías usar BindAddress=0.0.0.0 para escuchar en todas las interfaces, pero limitarlo a la IP de la VPN es más seguro, porque la única vía de acceso será el túnel. Lo malo de esto es que no podrás entrar localmente desde ningún dispositivo que esté fuera de la VPN, así que dejalo como mejor se ajuste a tus necesidades

Reinicia el servicio:

sudo systemctl restart amuleapi.service

Accede desde el navegador, ya conectado a la VPN, con la dirección privada de tu Raspberry Pi:

http://10.0.0.1:4713

Introduce tu contraseña de administrador y tendrás acceso completo a la interfaz web de aMule.

Un detalle práctico: como todo va por el túnel de WireGuard, la velocidad de acceso a la interfaz dependerá de tu conexión, pero para gestionar descargas y navegar por las listas va más que sobrado.

9.1.c. Alternativa intermedia: túnel SSH

Si en algún momento no quieres (o no puedes) usar la VPN, también puedes crear un túnel SSH desde tu equipo remoto:

ssh -L 4713:localhost:4713 raspberry@ip-de-tu-raspberry

🧘 En resumen

Y después acceder en el navegador a http://localhost:4713. Funciona igual de bien, viaja cifrado dentro del túnel SSH, y no requiere abrir ningún puerto en el router. Es un buen plan B cuando no tengas la VPN a mano.

Opción	Cifrado	Puertos abiertos	Riesgo	Recomendación
Abrir puerto 4713	❌ No	Sí (4713)	Alto	❌ No recomendado
VPN WireGuard	✅ Sí	No	Ninguno	✅ Muy recomendado
Túnel SSH	✅ Sí	No	Ninguno	✅ Buen plan B

Si ya tienes la VPN montada, no hay color: usa WireGuard. Es más seguro, más cómodo, y no tienes que abrir ni un solo puerto en el router. Si no la tienes todavía, es el momento perfecto para montarla —te sirve para aMule y para todo lo demás.

10. Gestión de los servicios

Una vez que tienes aMule funcionando como servicios de systemd, conviene tener a mano los comandos básicos para controlarlos. La buena noticia es que ahora tienes dos servicios independientes (amuled y amuleapi), pero están vinculados por una dependencia que hace que todo sea muy cómodo de gestionar.

🔗 Cómo se relacionan los dos servicios

En el archivo amuleapi.service incluimos estas líneas:

After=network.target amuled.service
Requires=amuled.service

Esa dependencia Requires significa que:

Si amuled se detiene, amuleapi también se detiene automáticamente. El sistema considera que amuleapi no tiene sentido sin el daemon.
Si arrancas amuleapi, systemd arranca amuled antes automáticamente. No tienes que preocuparte por el orden.

Es decir, en la práctica puedes gestionar casi todo desde un solo comando.

🛑 Parar aMule

Para detener todo, basta con parar amuled:

sudo systemctl stop amuled.service

amuleapi se detendrá solo como consecuencia de la dependencia. Puedes verificarlo con:

sudo systemctl status amuleapi.service

Debería aparecer como inactive (dead).

Si por algún motivo quieres parar solo la interfaz web sin cortar las descargas, puedes hacerlo sin afectar a amuled:

sudo systemctl stop amuleapi.service

Esto es útil, por ejemplo, si vas a tocar la configuración de amuleapi.conf y no quieres interrumpir las descargas en curso.

▶️ Iniciar aMule

Para arrancar todo de una vez:

sudo systemctl start amuleapi.service

Gracias al Requires, systemd arrancará primero amuled y luego amuleapi. Si prefieres ser explícito con el orden:

sudo systemctl start amuled.service
sudo systemctl start amuleapi.service

🔄 Reiniciar aMule

Útil cuando has cambiado algo en la configuración de amule.conf o amuleapi.conf y quieres aplicar los cambios sin parar y arrancar por separado:

sudo systemctl restart amuled.service amuleapi.service

O, si solo has tocado la parte web:

sudo systemctl restart amuleapi.service

Recuerda: amuleapi guarda la configuración en amuleapi.conf y la lee al arrancar. Si cambias algo ahí, es necesario reiniciar el servicio para que surta efecto.

📊 Ver el estado

Para comprobar que ambos servicios están corriendo correctamente:

sudo systemctl status amuled.service amuleapi.service

Verás algo como esto para cada uno:

● amuled.service - aMule Daemon
     Loaded: loaded (/etc/systemd/system/amuled.service; enabled; preset: enabled)
     Active: active (running) since ...

Si algo va mal, esta es la primera parada obligatoria. La salida suele dar pistas muy claras sobre el problema.

📜 Ver los logs en tiempo real

Cuando algo no funciona o quieres seguir la actividad del daemon, los logs son tu mejor amigo:

# Logs de amuled en vivo
sudo journalctl -u amuled -f

# Logs de amuleapi en vivo
sudo journalctl -u amuleapi -f

El parámetro -f mantiene el comando abierto y va mostrando las nuevas líneas a medida que se generan. Para salir, pulsa Ctrl+C.

Si quieres ver solo las últimas líneas sin quedarte enganchado:

sudo journalctl -u amuled -n 50
sudo journalctl -u amuleapi -n 50

🚦 Arranque automático al iniciar la Raspberry Pi

Ambos servicios están configurados con WantedBy=multi-user.target, lo que significa que arrancarán automáticamente cada vez que enciendas la Raspberry Pi. Si alguna vez quieres desactivar ese comportamiento (por ejemplo, para hacer pruebas):

sudo systemctl disable amuled.service amuleapi.service

Y para volver a activarlo:

sudo systemctl enable amuled.service amuleapi.service

Ten en cuenta que disable no para el servicio si está corriendo; solo impide que arranque automáticamente al inicio. Si quieres desactivarlo y pararlo en un solo paso:

sudo systemctl disable --now amuled.service

🧘 Resumen práctico

Acción	Comando
Parar todo	`sudo systemctl stop amuled.service`
Parar solo la web	`sudo systemctl stop amuleapi.service`
Arrancar todo	`sudo systemctl start amuleapi.service`
Reiniciar todo	`sudo systemctl restart amuled.service amuleapi.service`
Ver estado	`sudo systemctl status amuled.service amuleapi.service`
Ver logs en vivo	`sudo journalctl -u amuled -f`
Desactivar arranque automático	`sudo systemctl disable --now amuled.service`

Con estos comandos tienes control total sobre aMule. La dependencia entre los dos servicios hace que, en el 90% de los casos, te baste con gestionar amuled, y amuleapi seguirá el ritmo automáticamente.

Con esto tienes aMule 3.1.0 funcionando a pleno rendimiento en tu Raspberry Pi 5, con la mejor interfaz de control remoto que ha tenido nunca aMule y todas las ventajas de la nueva versión. Como siempre, si os surge cualquier duda, dejadme un comentario y os echo una mano.

¡A disfrutar de las descargas!