El problema: ¿en quién confiar?

Pi-hole incluye su propio servidor DNS (FTLDNS) que, después de aplicar las listas de bloqueo, reenvía las consultas de los clientes a los servidores DNS upstream configurados.

Sin embargo, esto plantea un problema de privacidad: cuando confías tus consultas DNS a un proveedor externo, estás delegando información sobre qué sitios visitas. Y aunque muchos proveedores prometen ser «privados y gratuitos», ¿cómo puedes saber realmente que cumplen su palabra?.

Además, los servidores DNS de grandes proveedores son objetivos muy atractivos para los atacantes. Si logran envenenar la caché de uno de ellos, millones de usuarios podrían ser redirigidos a sitios de phishing sin saberlo.

Cuando ejecutas tu propio servidor DNS recursivo (pequeño y local), la probabilidad de verse afectado por este tipo de ataques se reduce drásticamente.

¿Qué es un servidor DNS recursivo?

La primera distinción importante es entre un servidor autoritativo y uno recursivo:

• Un servidor autoritativo conoce la respuesta correcta para un dominio porque es el que lo gestiona (por ejemplo, el servidor autoritativo de pi-hole.net sabe cuál es su IP real).
• Un servidor recursivo, en cambio, resuelve cualquier consulta que recibe recorriendo la jerarquía del sistema DNS: pregunta a los servidores raíz, luego a los de nivel superior (TLD), y finalmente a los autoritativos, hasta obtener la respuesta.

¿Qué ofrece esta guía?

En pocos pasos, configuraremos tu propio servidor DNS recursivo en el mismo dispositivo donde ya tienes Pi-hole. No necesitas hardware adicional. La guía asume un sistema basado en Debian/Ubuntu relativamente reciente y utiliza los paquetes oficiales para simplificar el proceso.

Antes de empezar: prueba de acceso a los servidores raíz

Es fundamental verificar que tu ISP o router no esté interceptando o redirigiendo el tráfico DNS en el puerto 53. Si lo hace, Unbound no podrá comunicarse directamente con los servidores raíz y fallará de formas difíciles de diagnosticar.

Ejecuta estas pruebas en el sistema donde instalarás Unbound:

1. Prueba de reachabilidad UDP

Consulta directamente el servidor raíz a.root-servers.net (198.41.0.4) sin solicitar recursión:

dig @198.41.0.4 . NS +norec +time=3

Revisa la línea flags: en la respuesta. Si estás hablando directamente con un servidor raíz, verás aa (Authoritative Answer) y no verás ra (Recursion Available), ya que los servidores raíz no ofrecen recursión.

Ejemplo de respuesta correcta:

;; flags: qr aa; QUERY: 1, ANSWER: 13, AUTHORITY: 0, ADDITIONAL: 27

Si tu tráfico está siendo interceptado, aparecerá ra y probablemente faltará aa.

2. Prueba de reachabilidad TCP

Unbound también depende de TCP/53 para respuestas DNSSEC grandes y para reintentos:

dig @198.41.0.4 . NS +norec +tcp +time=3

Si esta prueba falla (timeout) pero la anterior funcionó, puede que tu red esté bloqueando tráfico DNS sobre TCP, lo que causará fallos crípticos en Unbound.

3. Confirmación de identidad vía CHAOS

Los servidores raíz responden a consultas de clase CHAOS con identificadores únicos. La mayoría de los proxies de ISP no manejan este tipo de consultas:

dig @198.41.0.4 version.bind CH TXT +time=3

Si te conectas directamente al servidor raíz, la respuesta será un registro TXT con «ATLAS»:

version.bind. 0 CH TXT "ATLAS"

Si el tráfico está siendo interceptado, obtendrás otra cadena, timeout o SERVFAIL.

Si alguna de estas pruebas falla, no es recomendable continuar con la instalación hasta investigar y resolver la causa (redirección del ISP, bloqueo de TCP DNS, filtros de seguridad en el router, etc.).

Configurando Pi-hole como servidor DNS recursivo

Vamos a utilizar Unbound, un servidor DNS recursivo seguro y de código abierto desarrollado por NLnet Labs, VeriSign, Nominet y Kirei.

1. Instalación de Unbound

sudo apt install unbound

Si instalas desde el gestor de paquetes, el archivo root.hints se instalará automáticamente con la dependencia dns-root-data y se actualizará con el gestor de paquetes.

Opcional: Si no instalas desde un gestor de paquetes, puedes descargar manualmente la lista de servidores raíz (actualízala cada seis meses aproximadamente):

wget https://www.internic.net/domain/named.root -qO- | sudo tee /var/lib/unbound/root.hints

Si haces esto, tendrás que descomentar la línea root-hints: en el archivo de configuración.

2. Configuración de Unbound

Crea o edita el archivo /etc/unbound/unbound.conf.d/pi-hole.conf con el siguiente contenido:

server:
    # Si no se especifica logfile, se usa syslog
    # logfile: "/var/log/unbound/unbound.log"
    verbosity: 0
    interface: 127.0.0.1
    port: 5335
    do-ip4: yes
    do-udp: yes
    do-tcp: yes
    # Puedes cambiarlo a no si no tienes conectividad IPv6
    do-ip6: yes
    # Déjalo en no a menos que tengas IPv6 nativo
    prefer-ip6: no
    # Usa esto solo si descargaste manualmente la lista de servidores raíz
    # root-hints: "/var/lib/unbound/root.hints"
    # Confía en la información de glue solo si está dentro de la autoridad del servidor
    harden-glue: yes
    # Requiere datos DNSSEC para zonas con trust-anchors; si faltan, la zona se marca como BOGUS
    harden-dnssec-stripped: yes
    # No uses randomización de mayúsculas (puede causar problemas con DNSSEC)
    use-caps-for-id: no
    # Reduce el tamaño del buffer de reensamblaje EDNS (recomendado por DNS Flag Day 2020)
    edns-buffer-size: 1232
    # Precarga entradas de caché próximas a expirar (solo para dominios consultados frecuentemente)
    prefetch: yes
    # Un hilo suele ser suficiente; aumenta solo en máquinas potentes
    num-threads: 1
    # Asegura que el buffer del kernel sea lo suficientemente grande para no perder mensajes
    so-rcvbuf: 1m
    # Protege la privacidad de rangos IP privados
    private-address: 192.168.0.0/16
    private-address: 169.254.0.0/16
    private-address: 172.16.0.0/12
    private-address: 10.0.0.0/8
    private-address: fd00::/8
    private-address: fe80::/10
    # Evita consultas inversas a rangos IP no públicos (RFC6303)
    private-address: 192.0.2.0/24
    private-address: 198.51.100.0/24
    private-address: 203.0.113.0/24
    private-address: 255.255.255.255/32
    private-address: 2001:db8::/32

Nota: En algunas distribuciones basadas en Red Hat (incluyendo CentOS hasta v10), la ruta del archivo puede ser /etc/unbound/conf.d/pi-hole.conf.

3. Iniciar y probar Unbound

Reinicia el servidor:

sudo service unbound restart

Comprueba que funciona:

~ $ dig pi-hole.net @127.0.0.1 -p 5335

; <<>> DiG 9.20.23-1~deb13u1-Debian <<>> pi-hole.net @127.0.0.1 -p 5335
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 20038
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
;; QUESTION SECTION:
;pi-hole.net.			IN	A

;; ANSWER SECTION:
pi-hole.net.		300	IN	A	162.244.93.14

;; Query time: 36 msec
;; SERVER: 127.0.0.1#5335(127.0.0.1) (UDP)
;; WHEN: Fri Jun 26 22:02:55 CEST 2026
;; MSG SIZE  rcvd: 56

La primera consulta puede ser algo lenta, pero las siguientes (incluso para otros dominios bajo el mismo TLD) deberían ser bastante rápidas.

4. Prueba de validación DNSSEC

Para verificar que DNSSEC funciona correctamente pasa este comando:

~ $ dig fail01.dnssec.works @127.0.0.1 -p 5335 #copia este comando

; <<>> DiG 9.20.23-1~deb13u1-Debian <<>> fail01.dnssec.works @127.0.0.1 -p 5335
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 28659
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
;; QUESTION SECTION:
;fail01.dnssec.works.		IN	A

;; Query time: 1008 msec
;; SERVER: 127.0.0.1#5335(127.0.0.1) (UDP)
;; WHEN: Fri Jun 26 21:58:14 CEST 2026
;; MSG SIZE  rcvd: 48

Debería devolver SERVFAIL y sin dirección IP.

y luego verifica con este otro:

~ $ dig +ad dnssec.works @127.0.0.1 -p 5335 #Copia este comando

; <<>> DiG 9.20.23-1~deb13u1-Debian <<>> +ad dnssec.works @127.0.0.1 -p 5335
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 62528
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
;; QUESTION SECTION:
;dnssec.works.			IN	A

;; ANSWER SECTION:
dnssec.works.		3600	IN	A	46.23.92.212

;; Query time: 152 msec
;; SERVER: 127.0.0.1#5335(127.0.0.1) (UDP)
;; WHEN: Fri Jun 26 21:59:03 CEST 2026
;; MSG SIZE  rcvd: 57

Debería devolver NOERROR, una dirección IP y la bandera ad (Authentic Data) en la sección flags:, indicando que la respuesta ha sido autenticada y validada mediante DNSSEC.

5. Configurar Pi-hole

Ve a la interfaz web de Pi-hole: Settings > DNS.

En la sección Custom DNS servers, especifica:

127.0.0.1#5335

Asegúrate de desmarcar todos los demás servidores upstream.

No olvides hacer clic en Save & Apply.

6. Deshabilitar entrada de resolvconf (requerido para Debian Bullseye+)

En Debian Bullseye y versiones posteriores, se instala automáticamente el paquete openresolv con una configuración que puede causar comportamientos inesperados en Pi-hole y Unbound.

El servicio unbound-resolvconf.service escribe nameserver 127.0.0.1 (sin el puerto 5335) en /etc/resolv.conf, lo que afecta a los servicios locales.

Paso 1: Deshabilitar el servicio

Comprueba si está activo:

systemctl is-active unbound-resolvconf.service

Si responde que inactivo, ve al punto 7, de lo contrario deshabilítalo.

Deshabilítalo así:

sudo systemctl disable --now unbound-resolvconf.service

Paso 2: Deshabilitar el archivo de configuración

sudo sed -Ei 's/^unbound_conf=/#unbound_conf=/' /etc/resolvconf.conf
sudo rm /etc/unbound/unbound.conf.d/resolvconf_resolvers.conf

Reinicia Unbound:

sudo service unbound restart

7. (Opcional) Añadir logs a Unbound

Advertencia: No se recomienda aumentar la verbosidad para uso diario, ya que Unbound genera muchos logs. Puede ser útil para depuración.

Niveles de verbosidad:

• 0: Solo errores
• 1: Información operativa
• 2: Información operativa detallada
• 3: Información a nivel de consulta
• 4: Información a nivel de algoritmo
• 5: Registro de identificación de cliente para fallos de caché

Edita el archivo con:

sudo nanno /etc/unbound/unbound.conf.d/pi-hole.conf 

y añade en la sección server:

server:
    logfile: "/var/log/unbound/unbound.log"
    log-time-ascii: yes
    verbosity: 1

Crea el directorio y archivo de log, y establece permisos:

sudo mkdir -p /var/log/unbound
sudo touch /var/log/unbound/unbound.log
sudo chown unbound /var/log/unbound/unbound.log

Una nota importante sobre AppArmor en Raspberry Pi OS

Es muy probable que AppArmor no esté activo en tu Raspberry Pi. (ni falta que hace)

Raspberry Pi OS no lo habilita por defecto, y muchos usuarios tienen que activarlo manualmente.

sudo aa-status 

Si al ejecutar el comando anterior, ves un error como comando no encontrado, No such file or directory, apparmor module is loaded, apparmor filesystem is not mounted, significa que AppArmor no está instalado o no está activo.

En ese caso, el paso de la guía para añadir una excepción en AppArmor no es necesario y puedes ignorarlo con tranquilidad.

Solo en el caso de que estuviese activo, sigue estos pasos:

Añadir una excepción en AppArmor

En sistemas modernos Debian/Ubuntu, añade una excepción en AppArmor:

Crea o edita /etc/apparmor.d/local/usr.sbin.unbound y añade:

/var/log/unbound/unbound.log rw,

Recarga AppArmor:

sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.unbound
sudo service apparmor restart

Reinicia Unbound:

sudo service unbound restart

8. Verificar que Pi-hole está usando Unbound

Realiza una consulta DNS:

dig en.wikipedia.org @127.0.0.1

Luego revisa el log de Pi-hole:

sudo tail /var/log/pihole/pihole.log

Deberías ver líneas como:

Nov 24 11:57:47 dnsmasq[973]: query[A] en.wikipedia.org from 127.0.0.1
Nov 24 11:57:47 dnsmasq[973]: forwarded en.wikipedia.org to 127.0.0.1#5335
Nov 24 11:57:47 dnsmasq[973]: reply en.wikipedia.org is <IP>

Si ves que las respuestas vienen de 127.0.0.1#5335, ¡enhorabuena! Pi-hole está usando Unbound como upstream.

Para otros clientes de la red

La configuración de la Raspberry solo afecta a la propia Raspberry. Para que el resto de dispositivos (móviles, portátiles, etc.) usen tu Pi-hole, configura tu router DHCP para que entregue 192.168.1.18 como único servidor DNS (y no entregue ningún secundario). Así, toda la red estará protegida.

Desinstalar Unbound

Si en algún momento quieres revertir los cambios:

sudo apt remove unbound

Recuerda volver a configurar otro servidor DNS upstream en Pi-hole.

Conclusión

Has configurado exitosamente tu propio servidor DNS recursivo con Pi-hole y Unbound. Ahora:

• Tu privacidad mejora: ninguna entidad externa registra todas tus consultas DNS.
• Tu seguridad aumenta: al ser un servidor pequeño y local, es un objetivo mucho menos atractivo para ataques de envenenamiento de caché.
• Tienes control total: decides cómo se resuelven tus consultas DNS, sin depender de terceros.

Comprobaciones, errores y soluciones

Advertencia so-rcvbuf en Unbound

La configuración establece so-rcvbuf: 1m para manejar altas tasas de consultas. Puedes ver esta advertencia:

so-rcvbuf 1048576 was not granted. Got 425984.

¿Dónde se puede ver esta advertencia? En dos sitios principales:

1. En los logs de Unbound

Esta es la forma más común de encontrar la advertencia. Unbound la escribe en sus propios registros cuando no puede establecer el tamaño de búfer que ha solicitado en su configuración (so-rcvbuf: 1m).

Puedes comprobar los logs de Unbound con el siguiente comando:

sudo journalctl -u unbound | grep "so-rcvbuf"

Si la advertencia está presente, verás un mensaje similar a este:

unbound[110586:0] warning: so-rcvbuf 1048576 was not granted. Got 425984.[reference:0]

Este mensaje indica que Unbound pidió un búfer de recepción de 1048576 bytes (1 MB), pero el sistema solo le concedió 425984 bytes.

2. Al iniciar Unbound manualmente (en primer plano)

Si ejecutas Unbound en primer plano (por ejemplo, para depuración), la advertencia aparecerá directamente en la terminal:

sudo unbound -d

¿Qué significa esta advertencia?

• No es un error crítico: Unbound seguirá funcionando, pero podría tener un rendimiento ligeramente inferior en momentos de mucho tráfico.
• Es un problema de límites del sistema: Unbound está pidiendo un búfer de red más grande para manejar mejor picos de tráfico, pero el límite del kernel (net.core.rmem_max) es más bajo.

Para solucionarlo, tendrías que aumentar el límite del kernel de forma permanente, por ejemplo, creando un archivo en /etc/sysctl.d/ (especialmente importante en sistemas más nuevos como Debian 13, donde /etc/sysctl.conf ya no se usa por defecto).

¿Como se soluciona?

1. Comprueba el límite actual:

   sudo sysctl net.core.rmem_max

2. Aumenta temporalmente:

   sudo sysctl -w net.core.rmem_max=1048576

3. Hazlo permanente. Edita
   sudo nano /etc/sysctl.d/99-unbound.conf
   y añade:

   net.core.rmem_max=1048576

4. Aplica los cambios:

• En sistemas actualizados (ej. Debian 13): sudo systemctl restart systemd-sysctl

4. Reinicia Unbound:

   sudo service unbound restart

Error en la prueba de DNSSEC

Durante la configuración de Pi-hole + Unbound como servidor DNS recursivo con validación DNSSEC, nos encontramos con un problema aparente, al realizar consultas con la bandera +dnssec, el sistema mostraba timeouts y terminaba resolviendo a través del router (fallback) en lugar de nuestro propio Pi-hole.

Síntoma

Desde el cliente, al ejecutar:

dig +dnssec sigfail.verteiltesysteme.net

obteníamos:

;; communications error to 192.168.1.18#53: timed out
...
;; SERVER: 192.168.1.1#53  (el router)

La consulta funcionaba sin +dnssec (respuesta inmediata desde Pi-hole), pero al pedir validación DNSSEC, el cliente se quedaba sin respuesta de Pi-hole y recurría al router, que sí devolvía SERVFAIL (porque también valida DNSSEC). Esto enmascaraba el problema real: Pi-hole no estaba respondiendo a tiempo.

Causa raíz

El motivo eran tres timeouts encadenados:

1. Timeout de reenvío de dnsmasq (Pi-hole):
   Por defecto, el servidor DNS interno de Pi-hole (dnsmasq) espera 2 segundos para que el upstream (Unbound) responda. Si Unbound tarda más (por ejemplo, en la primera resolución recursiva con DNSSEC, que puede llevar 400‑700 ms), dnsmasq aborta la conexión y no devuelve nada al cliente.
2. Timeout por defecto de dig:
   El comando dig tiene un tiempo de espera de 3 segundos. Si en el primer intento no recibe respuesta (por el aborto de dnsmasq), da el mensaje de communications error y reintenta. En el segundo intento, dnsmasq ya ha recibido la respuesta de Unbound (porque la caché ya está caliente) y la devuelve, pero el daño del mensaje de error ya está hecho.
3. Presencia del router como DNS secundario en /etc/resolv.conf:
   Al tener nameserver 192.168.1.1 como fallback, el sistema operativo, al no obtener respuesta de Pi-hole en el primer intento, acude al router, que responde rápidamente. Esto hacía que pareciera que «funcionaba» (porque se veía el SERVFAIL correcto), pero en realidad no estábamos usando nuestro propio Unbound para validar DNSSEC, sino el router.

Solución, eliminar el router como DNS secundario

Para asegurar que todas las consultas pasen por nuestro Pi-hole, es buena práctica dejar únicamente la IP de Pi-hole en /etc/resolv.conf (o configurar el DHCP del router para que entregue solo esa IP). Así, si Pi-hole falla, el sistema no tendrá un fallback y el error será evidente, pero en condiciones normales todas las consultas usarán nuestro propio resolver.

A continuación expongo 3 formas de hacer esto:

1. De forma gráfica.

Solo tienes que hacer clic derecho sobre el icono de red en la esquina superior derecha de la pantalla (el que parece dos monitores o unas barras de WiFi) y seleccionar «Wireless & Wired Network Settings» o una opción similar. Allí se abrirá una ventana para configurar tu conexión de red.

Para asegurarte de que los cambios son permanentes y no se sobrescriben, lo más fiable es usar el editor gráfico de conexiones de NetworkManager. Para ello, en lugar de la opción anterior, haz clic en «Advanced Options» y luego en «Edit Connections…». Se abrirá la ventana «Network Connections».

Aquí verás una lista de tus conexiones (por ejemplo, «Wired connection 1» para Ethernet o tu red WiFi). Selecciona la que estés usando y haz clic en el botón «Edit» (o «Configurar»). En la nueva ventana, ve a la pestaña «IPv4 Settings» (o «Ajustes IPv4»).

En esta pestaña, cambia el «Method» (Método) de Automatic (DHCP) a «Manual». Ahora se habilitarán los campos para que introduzcas tu configuración:

• Address (Dirección): La IP fija de tu Raspberry Pi (ej. 192.168.1.18).
• Netmask (Máscara de red): Normalmente 255.255.255.0.
• Gateway (Puerta de enlace): La IP de tu router (ej. 192.168.1.1).
• DNS servers (Servidores DNS): Aquí es donde pones 127.0.0.1.

Finalmente, haz clic en «Save» (Guardar) y luego cierra las ventanas. Para que los cambios surtan efecto, puedes reiniciar la interfaz de red o, simplemente, reiniciar la Raspberry Pi.

Luego reiniciamos Pi-hole:

sudo systemctl restart pihole-FTL

2. Desde la terminal.(usando nmcli)

1. Identifica tu conexión de red

sudo nmcli connection show

Anota el nombre de tu conexión activa (ej. eth0, Wired connection 1).

2. Ignora los DNS entregados por DHCP

sudo nmcli connection modify "eth0" ipv4.ignore-auto-dns yes

3. Asigna 127.0.0.1 como único DNS

sudo nmcli connection modify "eth0" ipv4.dns "127.0.0.1"

4. Aplica los cambios

sudo nmcli connection up "eth0"

5. Verifica que se ha aplicado

cat /etc/resolv.conf

Debe mostrar únicamente:

nameserver 127.0.0.1

3. Alternativa: nmtui (Interfaz gráfica en terminal)

Si no tienes el escritorio completo pero sí una interfaz de texto, puedes usar nmtui:

1. Ejecuta sudo nmtui edit "Wired connection 1" (cambia el nombre de la conexión si es necesario).
2. Navega con las flechas del teclado hasta «IPv4 CONFIGURATION» y cámbialo de <Automatic> a <Manual>.
3. Selecciona <Show> para ver los campos y rellénalos con tu IP, puerta de enlace y el DNS 127.0.0.1.
4. Guarda los cambios y reinicia NetworkManager con sudo systemctl restart NetworkManager.

Es un método igual de válido, pero a través de la línea de comandos y con una interfaz más amigable que nmcli puro.

Verificación final

Tras aplicar los cambios:

~ $ dig +dnssec sigfail.verteiltesysteme.net

; <<>> DiG 9.20.23-1~deb13u1-Debian <<>> +dnssec sigfail.verteiltesysteme.net
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 42460
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags: do; udp: 1232
;; QUESTION SECTION:
;sigfail.verteiltesysteme.net.	IN	A

;; Query time: 772 msec
;; SERVER: 127.0.0.1#53(127.0.0.1) (UDP)
;; WHEN: Fri Jun 26 20:10:10 CEST 2026
;; MSG SIZE  rcvd: 57

Resultado correcto:

• Sin mensajes de timeout.
• SERVER: 192.168.1.18#53 (nuestro Pi-hole).
• status: SERVFAIL con EDE: 6 (DNSSEC Bogus).

Y para un dominio válido:

dig +dnssec +time=10 dnssec.works

• status: NOERROR
• flags: qr rd ra ad (bandera ad = Authentic Data, validación DNSSEC correcta).

Conclusión

Conclusión sobre el fichero resolv.conf:

• Nunca pongas un DNS externo (ni el router) como secundario en la máquina que ejecuta Pi-hole.
• La mejor práctica es fijar 127.0.0.1 como único nameserver.
• Usa nmcli (o systemd-resolved si lo prefieres) para que los cambios sean permanentes.
• Verifica que ningún otro servicio sobrescriba el fichero.

Esta simple corrección cierra la puerta a fugas de privacidad y garantiza que todas las consultas de tu servidor pasen por tu propio filtro y resolver DNSSEC.

¡Disfruta de una navegación más privada y segura!

En este tutorial te cuento mi experiencia real instalando Pi-hole usando el método oficial de clonado del repositorio (no el típico curl | bash).

Requisitos previos

• Una Raspberry Pi (cualquier modelo, incluso una Zero)
• Conexión a Internet (por cable Ethernet o Wi-Fi).
• Acceso al panel de administración de tu router en mi caso un Asus RT-AC86U (para el paso final).

Paso 1: Actualizar el sistema y preparar el terreno

Primero nos asegurarnos de tener todo actualizado:

sudo apt update && sudo apt upgrade -y

Instala git, la herramienta que usaremos para clonar el repositorio:

sudo apt install git -y

Paso 2: Configurar una IP estática (¡obligatorio!)

Tu Raspberry Pi debe tener siempre la misma dirección IP para que los dispositivos de tu red sepan dónde está Pi-hole. Tienes dos opciones:

Opción A (recomendada): Reserva DHCP en el router

Dispongo de un router Asus, a continuación te detallo los pasos que debes seguir para asignar una IP fija.

Accede a la interfaz web de tu router, busca la sección «LAN» – «Servidor DHCP» y asigna una IP fija a tu Raspberry Pi usando su dirección MAC.

Opción B (desde la terminal): Configurar IP estática en la Raspberry

Si prefieres hacerlo por comandos, usa nmcli (sustituye "Wired connection 1" por el nombre de tu conexión, que verás con nmcli con show):

sudo nmcli con mod "Wired connection 1" ipv4.method manual ipv4.addr 192.168.1.100/24 ipv4.gateway 192.168.1.1 ipv4.dns 8.8.8.8
sudo nmcli device reapply eth0

Reinicia para aplicar los cambios:

sudo reboot

Luego reconéctate con la nueva IP.

Paso 3: Clonar el repositorio de Pi-hole

Usaremos el método 2 de la documentación oficial, que descarga el código completo para poder revisarlo antes de instalarlo:

git clone --depth 1 https://github.com/pi-hole/pi-hole.git Pi-hole

El parámetro --depth 1 acelera la descarga al solo obtener la última versión.

Paso 4: Ejecutar el instalador

Entramos en la carpeta del instalador y lo lanzamos con permisos de superusuario:

cd Pi-hole/automated\ install/
sudo bash basic-install.sh

El asistente te hará unas preguntas. Estas fueron mis respuestas:

Comenzamos por la primera pantalla donde nos dice que ¡Este instalador transformará tu dispositivo en un bloqueador de anuncios para toda la red!

Pi-hole es gratuito pero funciona gracias a tus donaciones. Te dan una dirección web para acceder a la zona de ofrendas a los dioses.

En esta ventana nos dice que Pi-hole es un servidor y necesita de una Dirección IP estática para funcionar correctamente. Como esto ya lo hicimos en un punto anterior, damos a Continue.

Dependiendo de si usas la interfaz de wifi (wlan0) o de cable (eth0) elige la que estes usando para conectar tu raspberry a internet. En mi caso usaré eth0 ya que estoy conectado por cable de red a mi router.

Aquí selecciona un proveedor de DNS, si tienes uno propio selecciona Custom. En mi caso como no tengo ninguno propio usaré Cloudflare.

Pi-hole se basa en listas de terceros para bloquear anuncios. Puedes usar la sugerencia a continuación o agregar la tuya propia después de la instalación.

Aquí seleccionamos yes, ya que la lista que trae por defecto es suficiente para empezar a bloquear anuncios.

Las listas de Steven Black (disponibles en GitHub – StevenBlack/hosts) son archivos que consolidan y extienden listados de fuentes confiables para bloquear anuncios, rastreadores y sitios maliciosos. Funcionan a nivel de sistema evitando que tu equipo resuelva las direcciones de dominios no deseados.

Pregunta si quieres activar el registro de consultas (log), ¡pues claro que sí, no seas ridiculo!.

Esa pantalla te pregunta qué nivel de detalle quieres ver en las estadísticas de Pi-hole y, sobre todo, qué información quieres que se almacene en los registros (logs).

Yo elegiré la opcion 0 Show everything, ya que muestra y guarda todos los detalles. Verás todas las consultas, los dominios, las IPs de los clientes, etc.. Es la opción perfecta para empezar, ya que te permite entender cómo funciona Pi-hole y ver qué dispositivos están haciendo más consultas. Si estás en un entorno doméstico y quieres máximo control y visibilidad, esta es tu opción.

Pantalla de resumen de la instalación, donde te dice cual es la dirección IP de tu servidor Pi-hole, distintos modos de como acceder a través del navegador y tu da una contraseña temporal para el acceso.

Paso 5: Acceder al panel de administración

Abre tu navegador y ve a:

http://localhost/admin

Inicia sesión con la contraseña temporal.

Si lo deseas puedes cambiar la contraseña por una más segura de tu elección:

pihole -a -p

Paso 6: Configurar el router para usar Pi-hole

Como dije anteriormente, sigo sobre los pasos de un router Asus, las instrucciones del tuyo pueden ser algo diferentes. Investiga como hacerlo.

Ahora, el paso clave para que toda tu red se beneficie:

1. Entra en la configuración de tu router.
2. Busca la sección de LAN y dentro busca Servidor DHCP.
3. Pon como servidor DNS primario la IP estática de tu Raspberry Pi. Así todos los dispositivos que se conecten automáticamente usarán Pi-hole.
4. Guarda los cambios y reinicia el router si es necesario.

Paso 7: forzar la actualización de listas.

En la instalación, las listas de Steven Black fueron añadidas pero no descargadas ni instaladas.

Desde la terminal, podemos hacerlo de forma rápida con un comando de este modo:

sudo pihole -g

Este comando descarga e instala las listas de bloqueo.

Paso 8: Verificar que el bloqueo funciona.

Para probar, ejecuta desde la terminal de tu Raspberry:

nslookup ad.doubleclick.net 127.0.0.1

Resultado esperado:

raspberry@terrapi:~ $ nslookup ad.doubleclick.net 127.0.0.1
Server:		127.0.0.1
Address:	127.0.0.1#53

Name:	ad.doubleclick.net
Address: 0.0.0.0
Name:	ad.doubleclick.net
Address: ::

Si ves 0.0.0.0 o ( ::), ¡enhorabuena! Pi-hole está bloqueando.

Otra forma gráfica de saber si tu Pi-hole está funcionando correctamente, es pinchando en el siguiente enlace.

https://blockads.fivefilters.org/?pihole

Si todo va bien deberás obtener una pantalla como esta en tu dispositivo.

Otros ajustes.

## Cambia el puerto del servidor.

A partir de la versión 6, Pi-hole dejó de usar lighttpd y ahora incluye su propio servidor web integrado. Para cambiar el puerto del panel de administración en las versiones modernas de Pi-hole, tienes que hacerlo así:

El método correcto para Pi-hole v6 o superior

La configuración del puerto se encuentra en el archivo /etc/pihole/pihole.toml. Para cambiarlo:

1. Abre el archivo de configuración con el siguiente comando:
   sudo nano /etc/pihole/pihole.toml
2. Dentro del archivo, busca la sección [webserver].
   Verás una línea que define el puerto, similar a esta: port = "80o,443os,[::]:80o,[::]:443os" Esta línea configura los puertos para IPv4 e IPv6, tanto HTTP como HTTPS.
3. Modifica el número de puerto que deseas cambiar. Por ejemplo, para que el panel web use el puerto 8080, la línea quedaría así: port = "8080o,443os,[::]:8080o,[::]:443os"
4. Guarda los cambios (Ctrl+O, Enter) y cierra el editor (Ctrl+X).
5. Para que los cambios surtan efecto, reinicia el servicio de Pi-hole:
   sudo systemctl restart pihole-FTL
   o usa el comando:
   sudo pihole restartdns

A partir de ahora, accederás al panel de administración a través de http://<IP_de_tu_Raspberry>:8080/admin.

## Actualiza tu Pi-hole

A continuación veremos el comando necesario para actualizar todos los componentes de Pi-hole a su última versión.

¿Qué hace exactamente?

Al ejecutarlo, el script revisa los repositorios oficiales de los tres componentes principales de Pi-hole:

• Pi-hole Core: El núcleo del software.
• Web Interface: El panel de administración.
• FTL (FTL Engine): El motor DNS que procesa las consultas.

Si detecta una nueva versión disponible, la descarga y la instala automáticamente.

¿Cómo se usa?

Puedes usar cualquiera de estos dos comandos en la terminal:

sudo pihole updatePihole

o su forma abreviada:

sudo pihole -up

Ambos comandos hacen exactamente lo mismo.

Puntos importantes

• Permisos de root: Dependiendo de tu configuración, es posible que necesites ejecutarlo con sudo.
• No actualiza las listas de bloqueo: Este comando solo actualiza el software de Pi-hole. Para actualizar las listas de dominios bloqueados, debes usar pihole -g (o pihole updateGravity).

## Añadir nuevas listas

Las listas de OISD (que significan «Oh, I See, Domains!») son unas listas de bloqueo de dominios muy populares y reconocidas en la comunidad de Pi-hole.

Su filosofía principal es priorizar la funcionalidad para que todo siga funcionando correctamente, evitando los molestos «falsos positivos» que rompen páginas web. De hecho, su lema es que la lista «pasa la prueba de la novia» , lo que significa que es tan fiable que una persona no técnica ni siquiera notará que está activa, más allá de que los anuncios desaparecen.

Añadir las listas de OISD a Pi-hole es muy sencillo. Solo tienes que añadirlas como cualquier otra lista de bloqueo. Te explico cómo hacerlo en tu versión 6.

Existen cuatro listas diferentes, pero lo normal es usar solo una de cada categoría, ya que son acumulativas:

• https://big.oisd.nl: Es la lista completa. Bloquea anuncios, rastreadores, malware, phishing y telemetría. (No incluye contenido NSFW).
• https://small.oisd.nl: Es una versión más ligera que se centra principalmente en anuncios. Está incluida en la lista big.
• https://nsfw.oisd.nl: Bloquea sitios para adultos (pornografía, shock, etc.).
• https://nsfw-small.oisd.nl: Versión más ligera de la lista NSFW. Está incluida en la lista nsfw.

Método 1: Añadir las listas desde la interfaz web (Recomendado)

1. Abre el panel de administración de Pi-hole: http://<IP_de_tu_Raspberry>/admin
2. En el menú lateral, ve a «Group Management» y luego haz clic en «Adlists».
3. En el campo «Address», pega la URL de la lista que quieras usar (por ejemplo, https://big.oisd.nl).
4. Haz clic en el botón «Add».
5. Actualiza la lista de bloqueo: Ve a «Tools» y haz clic en «Update Gravity», o ejecuta el comando pihole -g en la terminal.

Método 2: Añadir las listas desde la terminal (CLI)

Si prefieres usar la terminal, puedes añadir las listas con el siguiente comando (reemplaza "https://big.oisd.nl" por la URL que prefieras):

pihole -a adlist add "https://big.oisd.nl"

Después, actualiza Gravity para que los cambios surtan efecto:

pihole -g

Un par de detalles importantes

• Versión de Pi-hole: Asegúrate de que tu Pi-hole está actualizado. Estas listas requieren FTL v5.22, Web v5.19 y Core v5.16.1 o superior. Como tienes la versión 6, estás sobradamente cubierto.
• Número de dominios: Justo después de añadir la lista, es posible que Pi-hole muestre 0 dominios en el contador. Es un problema visual conocido. No te preocupes, la lista se ha añadido correctamente y los dominios se cargarán al actualizar Gravity.

Con estos pasos, ya tendrás una de las listas de bloqueo más completas y con menos falsos positivos de toda la comunidad Pi-hole.

## Lista de permitidos (allowlist)

En Pi-hole v6, el concepto de «lista blanca» (whitelist) ha pasado a llamarse oficialmente «lista de permitidos» (allowlist).

Dominios habituales en la lista blanca. Pincha aquí

Tienes varias formas de añadir dominios a esta lista, tanto desde la interfaz web como desde la terminal.

Te explico cada una:

Método 1: Desde la terminal (CLI) – El más rápido

La forma más directa es usar el nuevo comando pihole allow.

Añadir un solo dominio:

pihole allow dominio.com

Añadir varios dominios a la vez:

pihole allow dominio1.com dominio2.com dominio3.com

Eliminar un dominio de la lista de permitidos:

pihole allow remove dominio.com

Ejemplo práctico con algunos de los dominios que menciona el hilo de Discourse:

pihole allow clients4.google.com clients2.google.com s.youtube.com video-stats.l.google.com

Nota: El comando pihole allow es el equivalente moderno al antiguo pihole -w de versiones anteriores.

Método 2: Desde la interfaz web (GUI) – El más visual

1. Abre el panel de administración de Pi-hole: http://<IP_de_tu_Raspberry>/admin
2. En el menú lateral, haz clic en «Lists» (Listas).
3. Verás dos secciones: «Allowlist» (Lista de permitidos) y «Denylist» (Lista de denegados).
4. En la sección Allowlist, escribe el dominio que quieras permitir en el campo de texto.
5. Haz clic en «Add Allowlist» (Añadir a la lista de permitidos).

Puedes añadir varios dominios separados por espacios o cada uno en una línea nueva.

Método 3: Importar una lista completa (recomendado para muchos dominios)

Pi-hole v6 permite suscribirte a listas de permitidos públicas, igual que ya se hacía con las listas de bloqueo.

1. Ve a «Lists» en el panel web.
2. En la sección «Allowlist», encontrarás un campo para añadir una URL de lista de permitidos.
3. Introduce la URL de la lista (por ejemplo, la del repositorio comunitario).
4. Haz clic en «Add Allowlist».
5. Ejecuta pihole -g (o pihole gravity) para que Pi-hole procese la nueva lista.

Importante: Los dominios se asignan al grupo «Default»

Por defecto, cuando añades un dominio a la lista de permitidos, este se asocia al grupo «Default» (por defecto). Si quieres que se aplique a otros grupos, tendrás que ir a Group Management > Domains dentro de la interfaz web y asignarlos manualmente.

Resumen rápido

Ahora ya sabes dónde y cómo añadir esos dominios comunes a tu lista de permitidos en Pi-hole v6. ¡A disfrutar de una navegación sin bloqueos falsos!

Conclusión

Instalar Pi-hole en una Raspberry Pi ha sido una experiencia mucho más gratificante de lo que esperaba. No solo he conseguido eliminar anuncios y rastreadores en toda mi red doméstica, sino que también he aprendido conceptos fundamentales de redes como el DNS, las IP estáticas y la gestión de servidores.

Lo que empezó como un simple proyecto técnico se convirtió en una oportunidad para entender cómo funciona Internet a nivel local y, de paso, mejorar la privacidad y velocidad de navegación de todos los dispositivos de mi casa.

¿Dudas? Déjalas en los comentarios y te ayudaré encantado. ¡Feliz bloqueo!

Vamos a usar un script «inteligente» que recoge todo lo que aMule escupe, calcula los Megabytes y lo envía a Telegram usando un formato que nunca falla.

Paso 1: Configurar aMule

¡OJO! Antes de editar, detén aMule

sudo systemctl stop amuled.service

Vamos a decirle a aMule que ejecute nuestro script. Para ello, debemos editar el archivo amule.conf.

Recuerda que estamos usando un usuario dedicado, por lo que lo haremos a su ruta

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

Busca la sección [UserEvents/DownloadCompleted] y déjala exactamente así:

CoreEnabled=1
CoreCommand=/home/tu_usuario/notificar_amule.sh %NAME %SIZE

Sustituye tu_usuario por el tuyo propio.

Paso 2: Crear el Script

Crea el archivo de tu script, sustituyendo tu_usuario por el tuyo propio:

sudo nano /home/amule/notificar_amule.sh 

y pega este código (sustituye tu Token y tu ID de Chat):

#!/bin/bash

# --- CONFIGURACION DEL BOT ---
TOKEN="TU_TOKEN_AQUI"
ID_CHAT="TU_ID_AQUI"

# 1. Recogemos todo lo que mande aMule de golpe
TODO="$*"

# 2. Extraemos el tamaño (el último número de la frase)
BYTES=$(echo "$TODO" | grep -oP '\d+$')

# 3. Limpiamos el nombre (quitamos el número del final)
NOMBRE=$(echo "$TODO" | sed 's/[0-9]*$//')

# 4. Calculamos los MB y sacamos la fecha de la Raspberry
TAMANO_MB=$((BYTES / 1048576))
FECHA=$(date +"%d/%m/%Y a las %H:%M")

# 5. El Mensaje (con emoticonos para darle estilo)
MENSAJE="✅ DESCARGA COMPLETADA
----------------------------------
🎵 Archivo: $NOMBRE
⚖ Tamaño: $TAMANO_MB MB
🕒 Finalizado: $FECHA
🥧 Servidor: Raspberry Pi
----------------------------------"

# 6. Envío blindado con urlencode (evita que el mensaje se corte)
/usr/bin/curl -s -X POST "https://api.telegram.org/bot$TOKEN/sendMessage" \
     --data-urlencode "chat_id=$ID_CHAT" \
     --data-urlencode "text=$MENSAJE" > /dev/null

Como este archivo fue creado con sudo, el propietario será root, pero nosotros lo vamos a cambiar al usuario dedicado que es amule

sudo chown amule:amule /home/amule/notificar_amule.sh

Paso 3: Permisos y Arranque

Para que esto funcione, dale permiso de ejecución al script:

sudo chmod +x /home/amule/notificar_amule.sh

Ahora, arranca aMule de nuevo:

sudo systemctl restart amule

¡Y listo! A partir de ahora, cada vez que la Mula termine su trabajo, recibirás un «ping» en tu Telegram con toda la información. ¡A disfrutar de la descarga!

Estas instrucciones no te funcionarán si instalaste aMule desde repositorios.

La plantilla web por defecto es bastante espartana, con un diseño que recuerda a principios de los 2000. Por suerte, aMule permite cambiarla fácilmente, y existen creaciones de la comunidad mucho más atractivas y modernas.

En este artículo te mostraré cómo instalar AmuleWebUI-Reloaded, una plantilla que utiliza Bootstrap, jQuery e iconos para ofrecer una interfaz responsive, limpia y agradable a la vista, tanto en ordenador como en móvil.

¿Qué mejora esta plantilla?

• Diseño actualizado con Bootstrap y animaciones CSS.
• Interfaz responsive que se adapta a pantallas pequeñas (perfecta para usar desde el móvil).
• Iconos y botones más claros que facilitan la navegación.
• Transiciones suaves y logo animado en el inicio de sesión.
• Mismas funcionalidades que la plantilla original, solo mejora la apariencia.

Requisitos previos

Antes de empezar, asegúrate de que tienes:

• aMule funcionando en tu Raspberry Pi (siguiendo mi guía de compilación).
• Acceso por SSH a la Raspberry Pi.
• El servicio amule.service activo.

Instalación paso a paso

1. Detener el servicio aMule

Siempre es recomendable detener el demonio antes de modificar sus archivos:

sudo systemctl stop amuled.service

2. Clonar la plantilla en el directorio correcto

Como compilamos aMule desde código fuente y lo instalamos en /usr/local, el directorio de plantillas web está en:

cd /usr/local/share/amule/webserver

Ahora clonamos el repositorio de la plantilla:

sudo git clone https://github.com/MatteoRagni/AmuleWebUI-Reloaded.git

Nota: Usamos sudo porque el directorio pertenece al sistema.

3. Configurar aMule para usar la nueva plantilla

Editamos el archivo de configuración del demonio, que se encuentra en tu carpeta personal:

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

Buscamos la sección [Webserver] y añadimos o modificamos la línea Template:

[Webserver]
Enabled=1
Password=tu_hash_md5
Port=4711
Template=AmuleWebUI-Reloaded

Importante: El nombre Template debe coincidir exactamente con el nombre de la carpeta que clonaste. Respeta mayúsculas y minúsculas.

Guarda los cambios con Ctrl+O, presiona Enter y sal con Ctrl+X.

4. Reiniciar el servicio

sudo systemctl restart amuled.service

5. ¡Disfrutar de la nueva interfaz!

Abre tu navegador y accede a http://la-ip-de-tu-raspberry:4711 (o http://localhost:4711 si estás en la propia Raspberry).

Verás que la pantalla de login tiene un logo animado y un aspecto mucho más cuidado. Introduce tu contraseña y ¡listo!

Verificación de que todo funciona

Si algo no va bien, puedes comprobar los logs del servicio:

journalctl -u amuled.service -f

Abre la interfaz web mientras observas los logs. Si la plantilla no se carga, puede que el nombre no coincida o que la carpeta no esté en la ruta correcta.

También puedes listar las plantillas disponibles para confirmar que está instalada:

ls -la /usr/local/share/amule/webserver/

Deberías ver la carpeta AmuleWebUI-Reloaded junto con otras (como default o php-default).

Comparativa visual

Para que te hagas una idea, así se ve la interfaz antes (plantilla clásica):

Y así se ve después con AmuleWebUI-Reloaded:

La diferencia es notable, sobre todo si accedes desde el móvil.

Posibles problemas y soluciones

Conclusión

Cambiar la plantilla web de aMule es un proceso sencillo que mejora enormemente la experiencia de uso. En pocos minutos, tu interfaz web pasará de ser funcional pero austera a algo mucho más agradable y moderno.

Ahora ya puedes gestionar tus descargas desde cualquier dispositivo con un diseño responsive y cuidado. Si te ha gustado este artículo, compártelo o déjame un comentario con tus impresiones.

¡Felices descargas!

Enlaces de interés

• Repositorio de la plantilla AmuleWebUI-Reloaded
• Guía de compilación de aMule en Raspberry Pi 5
• Web oficial de aMule

El proyecto, que llevaba más de cinco años sin un lanzamiento importante desde la versión 2.3.3 de 2021, ha vuelto a la carga con una versión que han bautizado acertadamente como «The ‘alive again’ version» (la versión «viva de nuevo»). Y no es para menos.

¿Qué trae de nuevo aMule 3.0.0?

El cambio más impactante, sin duda, está en el rendimiento. Los desarrolladores han realizado una profunda reescritura del sistema de E/S de disco y de la capa de red. El resultado son unas cifras que quitan el hipo: mejoras de velocidad de entre 100 y 380 veces más rápidas en descargas entre pares en comparación con la versión anterior, sin necesidad de cambiar de hardware. Las pruebas sobre el terreno hablan por sí solas: en un Mac Studio con chip Apple Silicon se ha pasado de 0,35 MB/s a 135 MB/s. ¡Una auténtica bestia!

Pero no todo es velocidad. aMule 3.0.0 también ha modernizado por completo sus entrañas:

• Sistema de compilación moderno: Se ha eliminado el anticuado Autotools y se ha unificado todo con CMake, lo que facilita enormemente la compilación en los sistemas actuales.
• Paquetes nativos para todos: Por fin tenemos binarios nativos y actualizados para las principales plataformas. Instalador y versión portable para Windows (x64 y ARM64), .dmg universal para macOS (Apple Silicon e Intel) y AppImage o Flatpak para Linux (x64 y ARM64). Ya no hay excusas para no tenerlo todo a punto.
• Límites de ancho de banda corregidos: Los limitadores de subida y bajada se han reescrito por completo para que funcionen como es debido, con un sistema de «token bucket» real que promete una gestión del tráfico mucho más precisa.
• HTTPS y más: La descarga de listas de servidores y otras funciones vía HTTPS vuelven a funcionar correctamente, y el cliente de geolocalización se ha actualizado a MaxMindDB.

La espera ha sido larga, pero la comunidad alrededor de aMule puede respirar tranquila. El proyecto no solo está vivo, sino que ha vuelto con una fuerza inusitada, modernizándose por completo sin perder esa esencia que nos hizo enamorarnos del P2P.

Este tutorial se compone de los siguientes pasos.

• A. Preparación.
• B. Compilación e instalación
• C. Creación de un Usuario Dedicado
• D. Automatización avanzada del servicio con Systemd
• E. Configuración de aMule

A. Preparación.

Para compilar la versión 3.0 estable de aMule tal como indica la documentación oficial, usaremos CMake. La ventaja de hacerlo en Debian 13 (Trixie) es que todos los paquetes y dependencias requeridos, incluyendo wxWidgets 3.2, están disponibles de forma nativa en los repositorios oficiales sin tener que buscar versiones alternativas.

Instalar las dependencias

El documento de instalación de GitHub menciona las dependencias obligatorias (como Crypto++, zlib y Boost) y las opcionales para la interfaz, los iconos en la bandeja del sistema y las estadísticas.

Actualizamos la lista de paquetes.

sudo apt update

Ejecuta este comando en tu terminal para instalar todas las librerías de desarrollo necesarias:

sudo apt install build-essential cmake git gettext libwxgtk3.2-dev \
    libcrypto++-dev libboost-dev libboost-system-dev zlib1g-dev libupnp-dev \
    libgd-dev libmaxminddb-dev libayatana-appindicator3-dev libglib2.0-dev

B. Compilación e instalación.

Descarga el código fuente

Sitúate en tu directorio de usuario para descargar el ćodigo fuente con este comando:

cd ~

Un vez ahí, descargamos el código fuente de aMule 3.0

wget https://github.com/amule-org/amule/archive/refs/tags/3.0.0.tar.gz

Como resultado obtendremos un archivo comprimido en Gzip

3.0.0.tar.gz

Descomprime el archivo así.

tar -xzf 3.0.0.tar.gz

Al descomprimirse creará un directorio con los archivos necesarios para la compilación.

Entramos al nuevo directorio con:

cd amule-3.0.0

Configuración avanzada con CMake (Exprimiendo la Pi 5)

En lugar de hacer una compilación genérica, vamos a pasarle a CMake una serie de directivas de optimización brutales para exprimir la arquitectura de los núcleos Cortex-A76 de la Raspberry Pi 5 y mejorar el rendimiento del almacenamiento.

Creamos un directorio limpio para la compilación y configuramos el entorno:

mkdir build && cd build

Ahora, lanza el comando de configuración con las banderas optimizadas:

cmake .. \
    -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_DAEMON=ON \
    -DBUILD_REMOTEGUI=ON \
    -DBUILD_AMULECMD=ON \
    -DBUILD_WEBSERVER=ON \
    -DBUILD_MONOLITHIC=OFF \
    -DENABLE_MMAP=OFF \
    -DENABLE_UPNP=ON \
    -DCMAKE_INSTALL_PREFIX=/usr/local

¿Por qué esta configuración?

• -DCMAKE_BUILD_TYPE=RelWithDebInfo: Aplica las optimizaciones de velocidad de una versión Release, pero conserva los símbolos de depuración. Si la rama master sufriera un cierre inesperado, el core dump nos dirá la línea exacta del fallo sin ralentizar el demonio en el día a día.
• -DBUILD_MONOLITHIC=OFF: Desactivamos la interfaz gráfica «todo en uno». Al compilar sólo el demonio y las herramientas remotas, el binario es muchísimo más ligero.
• +crypto y cortex-a76: Obliga a GCC a generar instrucciones específicas para el procesador de la Pi 5, aprovechando su aceleración criptográfica por hardware para el cálculo de hashes P2P.
• -DENABLE_MMAP=OFF: Desactiva el mapeo de memoria. Usa E/S tradicional (más compatible con kernels de 16KB y sistemas remotos, evita corrupción). En lugar de proyectar los archivos directamente en la memoria virtual, el demonio usará las operaciones clásicas de lectura/escritura (read / write).

Importante sobre DENABLE_MMAP=OFF en Debian 13
Desactiva el mapeo de memoria nativo de Linux.

Efectos principales:

• Mayor compatibilidad: Evita problemas de corrupción en kernels con tamaños de página no estándar (como las páginas de 16 KB en Raspberry Pi 5 con Debian 13), en sistemas de archivos remotos (NFS, SMB) o con implementaciones problemáticas de mmap.
• Soluciona bucles de rehasheo en aMule, ya que elimina el desalineamiento de páginas que ocurría al superar ciertos tamaños de archivo.
• Rendimiento algo menor: Incrementa ligeramente el uso de CPU y reduce la velocidad de transferencia en almacenamiento rápido (NVMe, SSD), porque se copian datos entre usuario y kernel en cada operación.

Cuándo usarlo:
Solo si experimentas fallos con la opción activada (archivos corruptos, rehasheos infinitos, descargas que nunca completan). En caso contrario, mantener ON ofrece mejor rendimiento.

4. Compilación.

Para no perder tiempo, le indicamos al sistema que compile aprovechando todos los núcleos del procesador en paralelo. Gracias al flag -pipe, el proceso se hará intercambiando datos en la RAM en lugar de escribir temporales intermedios en el disco:

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

5. Instalación.

Una vez que el proceso finalice con éxito, instalamos los binarios optimizados en el sistema:

sudo cmake --install .

Refresca la caché de enlaces dinámicos del sistema

El comando ldconfig lo que hace es asegurar y actualizar la caché de las librerías compartidas (los archivos .so) en los directorios del sistema (como /usr/local/lib).

sudo ldconfig

Aunque en este caso, los ejecutables que se generan no instalan librerías compartidas del sistema y no sería necesario ejecutarlo , pero siempre es un buen hábito su ejecución.

Actualizar la caché de iconos

# 1. Copiar el icono de la 3.0.0 a pixmaps con el nombre exacto que busca el lanzador
sudo cp /home/raspberry/amule-3.0.0/org.amule.aMule.png /usr/share/pixmaps/org.amule.aMule.png

# 2. Forzar la actualización de la caché de iconos del sistema
sudo gtk-update-icon-cache -f /usr/share/icons/hicolor

# 3. Reiniciar el panel de XFCE4 para que aplique el cambio de inmediato
xfce4-panel --restart

En cuanto parpadee la barra de tareas tras el último comando, abre el menú de aplicaciones. El dibujo clásico de aMule ya aparecerá impecable en el lanzador. ¡Solucionado!

B. Creación de un Usuario Dedicado

Por seguridad (aplicando el Principio de Menor Privilegio), nunca debemos ejecutar un demonio expuesto a la red con el usuario root o con nuestra cuenta personal. Al aislar aMule en su propio usuario de sistema, si el proceso se ve comprometido por algún exploit de red, el atacante se quedará atrapado en una «jaula» sin acceso al resto del sistema ni a tus datos personales.

b.1. Crear el usuario de sistema amule

Ejecutamos el siguiente comando para generar el entorno aislado:

sudo useradd -r -m -s /usr/sbin/nologin amule

• -r: Define que es un usuario de sistema (no caduca).
• -m: Crea automáticamente su directorio de trabajo en /home/amule para alojar sus configuraciones.
• -s /usr/sbin/nologin: Bloquea por completo cualquier intento de inicio de sesión (local o por SSH) con esta cuenta.

b.2. Preparar la carpeta en el almacenamiento.

Las carpetas de almacenamiento las puedes dejar tal vienen por defecto y tan solo deberás darles permisos como haremos mas adelate.

Como dispongo de un viejo disco mecánico conectado via usb a mi raspberry y para no desgastar el disco SSD/NVMe con la escritura intensiva del P2P, voy a crear una carpeta dedicada en mi disco de almacenamiento montado en /media

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

Nota al lector: para montar un disco en Debian, sigue los pasos de Guía completa: Montar particiones al inicio en Debian

b.3. El truco maestro de los permisos (SGID)

Si le damos la propiedad de la carpeta exclusivamente al usuario amule, mi usuario habitual (raspberry) podrá leer las descargas pero no podrá borrarlas, renombrarlas ni moverlas a otra parte de la red sin usar sudo.

Para solucionar esto de forma elegante como un administrador profesional, aplicamos la siguiente configuración de permisos compartidos:

# 1. Metemos a tu usuario habitual en el grupo de amule
sudo usermod -aG amule raspberry

# 2. Hacemos que 'amule' sea el dueño y el grupo 'amule' sea el propietario de todo de forma recursiva
sudo chown -R amule:amule /media/Disco_1TB/amule_downloads

# 3. Damos permisos 775 (lectura, escritura y ejecución) recursivamente a todo lo actual
sudo chmod -R 775 /media/Disco_1TB/amule_downloads

# 4. Activamos el bit SGID en la carpeta raíz y en las subcarpetas de descarga
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

¿Qué hace el bit SGID (chmod g+s)? Es la clave de todo. Al activarlo en la carpeta madre, cualquier archivo o subcarpeta que aMule descargue e inserte ahí dentro heredará automáticamente el grupo amule con permisos de escritura. Gracias a esto, tu usuario raspberry siempre tendrá el control total para gestionar las descargas completadas. (Nota: Recuerda reiniciar sesión con tu usuario o ejecutar newgrp amule para que el sistema reconozca tu nuevo grupo).

C. Automatización avanzada del servicio con Systemd

Para garantizar que el demonio arranque de forma impecable en cada inicio del sistema, creamos un archivo de servicio altamente optimizado para entornos de red:

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

Pega el siguiente contenido:

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

[Service]
Type=simple
User=amule
Group=amule
Environment="HOME=/home/amule"
ExecStart=/usr/local/bin/amuled
Restart=on-failure
RestartSec=10
LimitNOFILE=65536
# Para detener el demonio y sus subprocesos (amuleweb) limpiamente
KillMode=control-group
KillSignal=SIGTERM

[Install]
WantedBy=multi-user.target

¿Por qué este servicio?

• network-online.target: Espera a que la Raspberry Pi tenga una IP real asignada por la red antes de intentar lanzar el demonio, evitando fallos de conexión en el arranque.
• LimitNOFILE=65536: Eleva el límite de conexiones y archivos abiertos simultáneamente por Linux, algo vital para mantener la estabilidad cuando el P2P gestiona cientos de fuentes a la vez.
• KillMode=control-group: Garantiza que cuando el servicio se detenga, systemd mate a todos los procesos dentro de ese grupo, incluido amuleweb.

Habilitamos el servicio para que sea automático y lo arrancamos:

Comenzamos con un daemon-reload: Le dice a Systemd que vuelva a escanear los directorios de configuración de los servicios. Como acabamos de crear el archivo amuled.service desde cero, el sistema operativo necesita este «refresco» para enterarse de que hay un nuevo servicio disponible y poder gestionarlo.

sudo systemctl daemon-reload

Después seguimos con un enable amuled.service: Configura el demonio para que se active automáticamente cada vez que arranques la Raspberry Pi. Lo que hace internamente es crear un enlace simbólico (symlink) en los directorios de inicio del sistema operativo (bajo el objetivo multi-user.target).

sudo systemctl enable amuled.service

Una vez activo haz un start amuled.service: Enciende y pone a funcionar el proceso de amuled inmediatamente en este preciso momento. No necesitas reiniciar la máquina para que el programa empiece a correr en segundo plano.

sudo systemctl start amuled.service

A modo de información status amuled.service: Muestra el estado actual del servicio en tiempo real. Te permite comprobar de un vistazo si el demonio está corriendo correctamente (active (running)), si está detenido o si ha fallado por algún error (failed). Además, tiene la enorme ventaja de mostrarte las últimas líneas del registro de log, lo que resulta vital para diagnosticar qué ha pasado si algo no va bien.

sudo systemctl status amuled.service

Casi con total seguridad, la primera vez que hagas esto, te lo encontraras inactivo, no te preocupes, es normal, la primera vez que amule arranca lo hace para crear sus directorios así como sus archivo de configuración.

raspberry@terrapi:~ $ sudo systemctl status amuled.service 
● amuled.service - aMule Master Daemon
     Loaded: loaded (/etc/systemd/system/amuled.service; enabled; preset: enabled)
     Active: inactive (running) since Sun 2026-06-14 10:10:12 CEST; 2 days ago
 Invocation: 029397ab533f4ea591acdaaec815610f
   Main PID: 23651 (amuled)
      Tasks: 15 (limit: 9492)
        CPU: 1h 14min 333ms
     CGroup: /system.slice/amuled.service
             ├─23651 /usr/local/bin/amuled
             └─23680 amuleweb --amule-config-file=/home/amule/.aMule/amule.conf

jun 14 10:10:12 terrapi systemd[1]: amuled.service: Scheduled restart job, restart counter is at 1.
jun 14 10:10:12 terrapi systemd[1]: Started amuled.service - aMule Master Daemon.

D. Configuración de aMule

Ahora que ya arrancaste aMule por primera con la orden start.amuled.service y status.amuled.service no arrojó ningún error, es hora de comenzar

d.1. Generar contraseña encriptada (hash MD5)

echo -n "TuContraseñaSegura" | md5sum

Crea un par de contraseñas, una para aMuleGUI y la otra para aMuleweb.

Nota, cuando crees tu contraseña, desprecia el guión final (no lo uses)

usuario@pi5:~ $ echo -n "TuContraseñaSegura" | md5sum
1c1b95a7f1aa172dd1cddafd371d4d12  -
usuario@pi5:~ $ 

d.2. Configuración final de las rutas

Al arrancar por primera vez, recuerda que lo hicimos con sudo systemctl start amuled.service se habrá generado el archivo de configuración base. Es aquí donde utilizaremos las dos contraseñas creadas, mas la activación de las conexiones externas.

Como el archivo de configuración no puede ser escrito mientras aMule se ejecuta debes pararlo ejecutando

sudo systemctl stop amuled.service

Ábrelo para modificar su contenido con:

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

+ Conexiones externas.

Modifica estas líneas:

AcceptExternalConnections=1
ECPassword=pega_uno_de los_hash_que_copiaste

En la sección [WebServer]:

[WebServer]
Enabled=1
Password=pega_el_otro_hash_que_creaste
Port=4711

+ Puertos

Los puertos predeterminados y NO recomendados de usar son TCP 4662 y UDP 4672. El programa genera un tercer puerto oculto llamado TCP + 3 (por defecto 4665). Para obtener ID Alta, debes abrir los tres en tu router.

Port=34662
UDPPort=34672
UDPEnable=1

Nota: Cambia los puertos, por ejemplo TCP 34662 y UDP 34672 que generan el puerto UDP 34665, lo cuales deberás abrir en tu router.

+ Directorios

Para aplicar la redirección hacia tu disco rápido de almacenamiento, busca y modifica las siguientes líneas apuntando a la estructura que creamos:

TempDir=/media/Disco_1TB/aMule/Temp
IncomingDir=/media/Disco_1TB/aMule/Incoming

Guarda con Ctrl+O, Enter, y sal con Ctrl+X.

+ Seguridad

El archivo IPFilterURL en aMule es una lista negra que bloquea direcciones IP maliciosas, fakes y rastreadores de Internet, mejorando tu seguridad y privacidad al descargar. Buscala y déjala como la siguiente.

IPFilterURL=http://upd.emule-security.org/ipfilter.zip

Una vez guardados los cambios reinicia el servicio para que empiece a descargar con total seguridad y el máximo rendimiento de hardware:

sudo systemctl restart amuled.service

¿Qué te parece esta versión? ¿Ya la has probado? ¡Te leo en los comentarios!

Soluciones a errores y trucos.

En esta sección expongo algunos errores y trucos que me han ayudado con aMule

* Desinstalación de aMule

Si no te convence como va tu aMule compilado, siempre lo podrás eliminar de la forma siguiente:

Dirigente a la carpeta «builld»

cd ~/amule/build

Una vez dentro, haz comprueba que existe un archivo llamado install_manifest.txt

ls -l ./install_manifest.txt && cat install_manifest.txt

Si ese archivo existe, puedes usarlo para desinstalar automáticamente:

sudo xargs rm -f < install_manifest.txt

Un vez ejecutado el comando anterior, la desinstalación será instantánea, así que para comprobar que todo a salido bien, busca posibles restos con:

find /usr/local -name "*amule*" -type f 2>/dev/null

Sabrás que aMule se eliminó correctamente ya que no deberá de salir nada a la orden del comando anterior.

* Forzar la ejecución manual en la terminal como usuario amule

Si por cualquier motivo quieres ver el output (la salida de texto) que escupe aMule en la terminal en su primer arranque para comprobar que no falta ninguna librería, no puedes usar el usuario raspberry.

Como el usuario amule tiene el login bloqueado (nologin), debes usar sudo con el flag -u (user) para suplantarlo solo durante la ejecución de ese comando:

sudo -u amule /usr/local/bin/amuled

Al hacerlo así, el sistema operativo ejecutará el programa en nombre de amule, creará los archivos en /home/amule/.aMule/ con los permisos correctos de propietario y verás los mensajes en tu pantalla. Una vez que veas que ha arrancado bien, lo cierras con Ctrl + C y procedes a editar el archivo.

* aMuleweb. Sin acceso desde el navegador.

Es posible que no necesites hacer esto, ya que en versiones anteriores a la 3.0, como en aMuleWeb 2.3.3 se cerraba en frecuentemente.

Dado que amuleweb en ocasiones, puede comportarse de forma inestable llegando a cerrarse, la solución más robusta para un sistema 24/7 es, un script «vigilante» (watchdog) que lo reactive automáticamente cuando muera.

Aquí tienes la forma más sencilla de hacerlo.

Paso 1: Crear el script vigilante

Ve a tu terminal, si estas en el equipo, si no, conéctate por SSH y crea el script:

sudo nano /usr/local/bin/amuleweb-watchdog.sh

Paso 2: Copiar el contenido (más simple y efectivo)

Este script es más simple: solo comprueba si el proceso amuleweb existe y, si no, lo arranca.

#!/bin/bash
# Script para vigilar y reiniciar amuleweb si se cierra

if pgrep -x "amuleweb" > /dev/null
then
    :
else
    logger "amuleweb-watchdog: amuleweb no encontrado, reiniciando..."
    # Se ejecuta como el usuario dedicado 'amule' apuntando a su home real
    sudo -u amule /usr/local/bin/amuleweb --amule-config-file=/home/amule/.aMule/amule.conf &
fi

Paso 3: Dar permisos y probar

sudo chmod +x /usr/local/bin/amuleweb-watchdog.sh

Paso 4: Programarlo cada minuto

Edita el crontab del usuario root para que vigile todo el tiempo:

sudo crontab -e

Añade esta línea al final del archivo:

* * * * * /usr/local/bin/amuleweb-watchdog.sh

Con esto, el sistema comprobará cada minuto si amuleweb está vivo y lo levantará automáticamente si se ha cerrado.

* Instala la rama master

Si quieres tener los últimos cambios y novedades, ve a por la rama Master y compila desde ahí.

Clonamos el repositorio oficial de aMule directamente desde GitHub para asegurarnos de compilar la última versión de la rama master:

git clone https://github.com/amule-org/amule.git

Una vez descargado el clon de github sigue los pasos que se describen en el apartado 2. Descarga el código fuente.

• Bajas una ISO de Linux desde el navegador, haces el sha256sum y… falla. La vuelves a descargar, el hash es diferente otra vez. Corrupta siempre.
• Usas aMule para compartir archivos, la descarga llega feliz al 100% y de repente retrocede al 80%. Vuelve a subir, otra vez 100%, otra vez 80%… un bucle infinito de rehasheo. A veces después de horas logra completar, pero la desesperación ya te ha consumido.

Esto me pasó a mí. Y lo peor es que en Debian 12 funcionaba todo perfectamente. Probé de todo: memtest, cambiar la fuente de alimentación, revisar el NVMe, hacer fsck… nada. Hasta que por fin alguien me dio la solución mágica: dos cambios aparentemente absurdos que lo arreglaron todo.

Hoy te cuento por qué ocurría, por qué la solución funciona, y sobre todo cómo aplicarla para que nunca más sufras con descargas rotas en tu Raspberry Pi 5.

Lo que NO era (descartando lo obvio)

Antes de tirarme por la ventana, descarté lo típico:

• Memoria RAM defectuosa – Pasó las pruebas.
• Problemas de red – Otras máquinas descargaban el mismo archivo sin fallos.
• Alimentación insuficiente – Usaba el cargador oficial de la Pi 5.
• Disco duro o microSD corruptos – Ni fsck ni smartctl mostraban errores.

Era algo más raro, más profundo. Algo que había cambiado entre Debian 12 y Debian 13.

El hallazgo inesperado: el kernel de 16KB

Resulta que, para optimizar el rendimiento en procesadores modernos, algunas distribuciones de Linux para ARM64 (como las últimas versiones de Raspberry Pi OS y Debian 13) han empezado a compilar el kernel con páginas de memoria de 16KB, en lugar de las clásicas de 4KB que hemos usado toda la vida.

¿Qué significa esto? El sistema operativo divide la memoria RAM en «páginas» (como las hojas de un libro). Durante décadas el estándar fue 4KB. Pero si aumentas el tamaño a 16KB, el sistema puede manejar más datos con menos operaciones internas, lo que teórico mejora el rendimiento.

El problema es que el software del mundo real está compilado asumiendo páginas de 4KB. Navegadores, aMule, emuladores, clientes de descarga… todos ellos hacen cálculos basándose en ese tamaño. En concreto, utilizan una función del sistema llamada mmap (memory-mapped files) que es muy rápida pero muy sensible al alineamiento de las páginas.

¿Qué hace mmap y por qué se rompe?

mmap le dice al kernel: «Oye, toma este archivo del disco y proyéctalo directamente en la memoria RAM, para que pueda escribir en él a toda pastilla». Para hacerlo, el programa calcula las posiciones (offsets) en múltiplos del tamaño de página.

Si el programa usa 4KB y el kernel piensa en 16KB, los cálculos se desalinean. Los datos se escriben en posiciones incorrectas, unos encima de otros. Esto es especialmente crítico con archivos grandes (varios GB). Las ISO se descargan completas pero internamente tienen los bytes cambiados de sitio. Por eso el sha256sum nunca coincide, y por eso aMule entra en un bucle de rehasheo: detecta que los bloques no son los que deberían ser y vuelve a descargarlos una y otra vez.

Ese era el monstruo oculto bajo la cama.

La solución: dos caminos, uno definitivo

Opción 1: Cambiar el kernel al de 4KB (recomendada)

La forma más limpia y que arregla todos los programas de golpe es obligar a la Raspberry Pi a usar el kernel clásico de 64 bits con páginas de 4KB. Es muy sencillo:

1. Abre el archivo de configuración del firmware:

   sudo nano /boot/firmware/config.txt

2. Al final del archivo, añade esta línea:

   kernel=kernel8.img

3. Guarda, reinicia y ya está.

¿Qué hace esa línea? El firmware de la Raspberry Pi, al arrancar, busca un kernel. kernel8.img es el kernel de 64 bits «estándar», que usa páginas de 4KB como toda la vida. Las versiones más modernas a veces usan otros nombres (como kernel8-16k.img), pero kernel8.img sigue siendo el clásico. Así que con esa instrucción le dices: «carga ese, no el que te dé la gana».

Después de reiniciar, puedes comprobar el tamaño de página activo con:

getconf PAGE_SIZE

Si ves 4096 (que son 4KB), enhorabuena. El problema ha desaparecido para siempre.

Opción 2: El parche solo para aMule (no recomendado, pero existe)

Si por alguna razón no quieres tocar el kernel, puedes recompilar aMule desactivando el uso de mmap. Así el programa usará el sistema de entrada/salida clásico, que no se ve afectado por el tamaño de página.

./configure --disable-mmap
make && sudo make install

Ojo: Esto solo arregla aMule. El navegador web y cualquier otra aplicación que use mmap seguirá descargando archivos corruptos. Por eso la opción 1 es infinitamente mejor.

Comprobación de que todo funciona

Después de aplicar la solución (la opción 1, claro), haz estas pruebas:

• Descarga dos veces la misma ISO grande (por ejemplo, Ubuntu 24.04). Calcula el sha256sum de ambas. Deben ser idénticos y coincidir con el oficial.
• Prueba una descarga pesada con aMule. Llegará al 100% y se quedará ahí, sin rehasheos.
• Opcional: getconf PAGE_SIZE debe decir 4096.

¿Pierdo rendimiento usando páginas de 4KB?

En teoría, los kernels con páginas de 16KB pueden ser ligeramente más rápidos en ciertos benchmarks de memoria masiva. En la práctica, con un uso normal de escritorio, servidor casero o centro multimedia, no notarás la diferencia. Lo que sí notarás es que tus archivos se descargan correctamente. Para mí, la fiabilidad gana por goleada.

Además, hay quien dice que muchos juegos y emuladores funcionan incluso mejor con 4KB precisamente por la compatibilidad. Así que no le des más vueltas.

Preguntas frecuentes

¿Esto es seguro? ¿Puedo romper mi Raspberry Pi?
Absolutamente seguro. kernel=kernel8.img es un kernel oficial, firmado, estable. No es overclock ni modificación extraña.

¿Qué pasa si en el futuro el kernel kernel8.img también se vuelve de 16KB?
Muy improbable, porque ese nombre está reservado tradicionalmente para el kernel de 4KB. En todo caso, si ocurriera, existiría otra forma de forzar 4KB. Pero de momento no hay indicios.

Me pasa en Ubuntu Server o Arch Linux ARM, ¿vale lo mismo?
El problema puede aparecer en cualquier distribución que haya adoptado el kernel de 16KB para la Pi 5. La solución es similar: busca cómo cargar un kernel con páginas de 4KB. En algunos casos puedes instalar el kernel raspberrypi-kernel o compilar el tuyo. Pero para no complicarte, te recomiendo probar primero con la línea kernel=kernel8.img en el config.txt. Suerte.

¿Por qué no me pasaba en Debian 12?
Porque Debian 12 usaba el kernel clásico de 4KB. El cambio a 16KB ha llegado con las versiones más recientes (Debian 13, Trixie, y algunas actualizaciones de Raspberry Pi OS). Es un cambio silencioso que nos ha pillado a muchos por sorpresa.

La Bitácora de Pruebas: Descartando pieza a pieza

Estas son las pruebas que realicé para descartar problemas de hardware, en la que fui aislando cada componente del sistema, empezando por lo mas básico:

1. El test de estrés a la Memoria RAM (memtester)

En los casos de corrupción aleatoria de datos, el primer sospechoso siempre es un módulo de memoria defectuoso. Instalamos la herramienta memtester para exprimir la RAM de las Pi 5 y obligarlas a leer y escribir patrones de datos buscando bits defectuosos.

sudo apt install memtester
sudo memtester 4000M 3

Le asignamos 4GB de RAM y le pedimos 3 pasadas completas.

Resultado: No debe de dar errores.

2. Auditoría y estrés del NVMe local (Descarte de almacenamiento)

Descartada la RAM, el siguiente sospechoso era el almacenamiento. ¿Estaba el bus PCIe, el adaptador HAT oficial o el propio firmware del NVMe corrompiendo los datos al escribir? Para salir de dudas, sometimos el disco a una auditoría en tres fases: pasiva, de superficie y de hash lógico.

Fase A: Lectura de salud S.M.A.R.T.

Instalamos las herramientas de diagnóstico para interrogar directamente al firmware del disco y comprobar si arrastraba fallos físicos o sectores reasignados:

sudo apt install smartmontools
sudo smartctl -a /dev/nvme0n1

(Nota: Cambia /dev/nvme0n1 por la ruta específica de tu dispositivo si varía).

Resultado: Todo limpio. Parámetros críticos como Media and Data Integrity Errors o sectores reasignados estaban a cero. El disco reportaba salud de fábrica.

Fase B: Test de superficie a bajo nivel (badblocks)

Para asegurar que ninguna celda de silicio flaqueaba bajo estrés, ejecutamos la prueba de fuego más exhaustiva que existe en Linux:

sudo badblocks -vsw -b 4096 /dev/nvme0n1

¡Ojo! El parámetro -w realiza un test de escritura destructivo (escribe patrones encima de lo que haya). Hazlo siempre sobre un disco vacío o antes de montar datos definitivos.

Este comando realiza 4 pasadas completas a todo el disco, escribiendo, leyendo y verificando secuencialmente patrones de bits totalmente diferentes (0xaa, 0x55, 0xff y 0x00). Si un bit se queda pegado o falla al retener la información, badblocks lo caza al vuelo.

Resultado: Cero errores en las 4 comprobaciones. Las celdas físicas del NVMe respondieron de forma impecable.

Fase C: Integridad lógica y velocidad en ráfaga (dd + sha256sum)

Por último, queríamos estresar el bus PCIe de la Raspberry Pi 5 a su máxima tasa de transferencia y comprobar si los archivos se «deformaban» al copiarse localmente. Ejecutamos esta secuencia en bloque:

# 1. Creamos un archivo masivo de 1 GB de ceros puros a máxima velocidad
dd if=/dev/zero of=test_gordo.img bs=1M count=1024

# 2. Calculamos su huella digital o hash único original
sha256sum test_gordo.img

# 3. Lo duplicamos a otra zona física del NVMe
cp test_gordo.img test_gordo_copia.img

# 4. Calculamos el hash de la copia para comprobar si ha mutado
sha256sum test_gordo_copia.img

Resultado: Los hashes de ambos archivos coincidieron al milímetro, firmando un resultado idéntico. Además, la transferencia local se mantuvo a una velocidad brutal de 1,8 GB/s.

Conclusión del descarte de hardware

Si el bus PCIe, las pistas del HAT o el controlador del disco sufrieran la más mínima degradación por temperatura o carga, los hashes habrían salido distintos y el test de bloques habría cantado fallos.

Con la RAM en perfecto estado y el almacenamiento local rindiendo como una roca a casi 2 GB/s, el hardware quedaba totalmente absuelto. El poltergeist de la corrupción de datos tenía que ser, por fuerza, un problema de software entre el Kernel y la pila de red.

3. La prueba cruzada de red

Si las tripas de la máquina estaban sanas, miramos hacia afuera. Repetimos las descargas en mi segunda Raspberry Pi 5. Mismo resultado: hashes aleatorios. En cambio, al realizar la misma descarga en un PC Intel conectado por Ethernet en el mismo switch, los hashes salían perfectos a la primera. El problema se concentraba exclusivamente en las Pi 5.

4. El misterio de la EEPROM

Para asegurar que no arrastrábamos configuraciones antiguas grabadas a fuego en las placas, entramos en sudo raspi-config y restablecimos el Bootloader (EEPROM) a los valores por defecto de fábrica. El problema persistió.

5. La prueba del Wi-Fi

Para confirmar si el fallo venía exclusivamente por el cable eléctrico, desconectamos el cable Ethernet y activamos el Wi-Fi. Al ir por un chip inalámbrico independiente, la corrupción desapareció, confirmando que la interfaz por cable eth0 era el embudo donde se deformaban los paquetes.

Conclusión:

Me costó semanas de pruebas, foros y cabezazos contra el techo. Al final, el culpable no era ni el hardware ni la red: era un cambio interno en el kernel que nadie me había advertido.

Si esta entrada te ha salvado de un dolor de cabeza, por favor, compártela en los foros, en los grupos de Telegram, en Reddit o con ese amigo que tiene una Raspberry Pi 5 y se queja de que «las descargas le van mal». Entre todos podemos hacer que Linux sea más predecible y amigable.

Y recuerda: cuando todo falle, prueba a poner kernel=kernel8.img en el config.txt. A veces la solución más pequeña es la que desatasca el mayor de los problemas.

En mi caso, he rescatado dos discos duros olvidados para montarlos en mi TerraPi Xtreme DUO con una Raspberry Pi 5, dándoles una segunda vida útil antes de que ganen su merecido descanso en el Valhalla de la informática.

En este artículo te explico, paso a paso, cómo configurar tus discos para que se monten automáticamente al arrancar el sistema. Veremos cómo hacerlo de forma correcta, segura y profesional, evitando los errores típicos de configuración que pueden comprometer la estabilidad de tu sistema.

1. Identificador de disco «UUID»

El UUID son las siglas de Universally Unique Identifier (Identificador Único Universal). En el contexto de Linux y los discos, es un número de 128 bits que se asigna a cada partición de forma que sea prácticamente único en todo el mundo.
Sirve para identificar de forma inequívoca una partición, independientemente de dónde esté conectada o en qué orden la detecte el sistema.

Con el comando lsblk -f puedes ver todos los discos y particiones.

lsblk -f

raspberry@terrapi:/mnt/Datos $ lsblk -f
NAME        FSTYPE FSVER LABEL  UUID                                          FSAVAIL   FSUSE%   MOUNTPOINTS
loop0       swap   1                                                                
sda                                                                                 
└─sda1      ext4   1.0   Disco_4TB c1ejfioe36-3f56-4ffb-8ee1-3e5lfojrdbb3       3,4T       0%     /mnt/Zombie
sdb                                                                                 
└─sdb1      ext4   1.0   Disco_1TB 4ddd15-57f5-4b75-8cc7-9143332b1062           429,4G    48%     /mnt/Datos
zram0       swap   1     zram0  a3r3bf9-7ee7-47b0-bf32-a3fgasda099b7                                [SWAP]
nvme0n1                                                                             
├─nvme0n1p1 vfat   FAT32 bootfs 7D34-B6BD                                       428,8M    16%     /boot/firmware
└─nvme0n1p2 ext4   1.0   rootfs 61r3raf9-9db4-4dec-8a3b-437abc3df332d           439,5G     2%    /
raspberry@terrapi:/mnt/Datos $ 

Nota: Nunca uses la ruta al dispositivo como por ejemplo`/dev/sda1` porque puede cambiar al reiniciar, usa **UUID** (identificador universal único).

Antes de editar ningún archivo, debes identificar **de forma única** tu partición.

1.1 Obtener el UUID de una partición concreta

Lo podemos obtener de varias formas, siendo estos comandos los mas usados:

a – Ver todos los UUID de las particiones

sudo blkid

b – Ver solo los UUID (más limpio)

lsblk -f

c – Obtener UUID de un disco concreto

sudo blkid /dev/sda1

Anota el `UUID` y el `TYPE` que corresponda a tu disco.(por ejemplo `ext4`, `ntfs`, `exfat`).

2. Crear el punto de montaje /media vs /mnt

La elección no afecta al funcionamiento (Linux monta en cualquier directorio vacío), pero hay una buena práctica basada en el estándar FHS (Filesystem Hierarchy Standard):

• /media → Para discos extraíbles o de datos (USB, discos externos, tarjetas SD).
  Úsalo si son discos que conectas/desconectas o que almacenan solo datos personales (películas, copias de seguridad, música).
• /mnt → Para montajes temporales y manuales realizados por el administrador (reparar el sistema, probar una partición).
  Úsalo solo si vas a montar un disco de forma puntual, no permanente.

En mi caso (Raspberry Pi con 2 HDD USB fijos de datos)

Crearé los dos puntos de montaje bajo /media:

sudo mkdir -p /media/Disco_4TB /media/Disco_1TB

Así se integra mejor con el sistema (detectados automáticamente por aplicaciones como Plex, Samba, o el gestor de archivos) y sigues la convención actual.

Recuerda: Lo importante es que el directorio exista y esté vacío antes de montar. El resto es organización.

3. Montaje manual de prueba (antes de hacerlo permanente)

Hagamos un montaje manual para verificar que el disco se monta sin errores:

sudo mount /dev/sda1 /media/Disco_4TB /dev/sdb1 /media/Disco_1TB

Lista los archivos del disco con:

ls /media/Disco_4TB /media/Disco_1TB

¿se ven los archivos? si es así, desmonta el disco manualmente con:

sudo umount /media/Disco_4TB /media/Disco_1TB

4. Montaje automático con `/etc/fstab`

El archivo `/etc/fstab` controla los montajes al inicio. **Haz una copia de seguridad** antes de editarlo:

sudo cp /etc/fstab /etc/fstab.bak

Ahora edítalo:

sudo nano /etc/fstab

Añade una línea por cada partición con el siguiente formato:

UUID=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX /punto/de/montaje tipo_fs opciones 0 2

Ejemplo real para un disco ext4 de datos:

UUID=c1ejfioe36-3f56-4ffb-8ee1-3e5lfojrdbb3 /media/Disco_4TB ext4 defaults,nofail,x-systemd.automount 0 2
UUID=4ddd15-57f5-4be75-8cc7-9143332b1062ese /media/Disco_1TB ext4 defaults,nofail,x-systemd.automount 0 2

¿Qué significan estas opciones?

• defaults: Incluye: `rw, suid, dev, exec, auto, nouser, async`
• nofail: Si el disco no está conectado, el sistema arranca igual (imprescindible para discos externos)
• x-systemd.automount: El disco se monta bajo demanda, al primer acceso. Acelera el arranque.

Nota: ¿Qué pasa si el disco no está conectado al arrancar? Sin `nofail`, el sistema se quedará esperando o entrará en modo de emergencia.

**Siempre añade `nofail` en discos extraíbles**.

Otras opciones que puedes añadir si las necesitas:

• users: Permite que cualquier usuario monte/desmonte la unidad (cuidado con `noexec`)
• errors=remount-ro: Si hay errores, remonta como solo lectura para proteger los datos

Atención con users y noexec:
Cuando usas la opción users, el sistema añade automáticamente noexec (no se pueden ejecutar programas desde esa unidad) por razones de seguridad. Si necesitas ejecutar binarios en esa partición, añade explícitamente exec después de users. Ejemplo: users,exec,defaults.

Ejemplo para un disco NTFS (Windows)

Si tu disco proviene de un sistema tipo Windows, instalaremos la gestión de particiones NTFS

sudo apt install ntfs-3g

Línea en fstab:

UUID=1234567890ABCDEF /media/WinData ntfs-3g defaults,uid=1000,gid=1000,dmask=022,fmask=133,noexec,nofail 0 0

• uid=1000/gid=1000` → tu usuario normal es el dueño
• dmask=022,fmask=133` → permisos: directorios 755, archivos 644

5. Probar y recargar sin reiniciar

Después de editar `fstab`monta todo lo que esté en fstab (solo lo nuevo)

sudo mount -a

Si usas systemd.automount como tenemos en nuestro ejemplo

sudo systemctl daemon-reload 

Si no hay errores, todo está correcto. Puedes reiniciar para confirmar.

Resumiendo.

Monta tus HDD USB en /media.

Aquí te detallo varias razones de peso:

1. Son discos de datos, no del sistema
   El NVMe ya tiene el sistema operativo (/dev/nvme0n1p2 montado en / y p1 en /boot/firmware). Los HDD USB son puramente almacenamiento secundario.
2. Son fijos pero externos
   Aunque no los desconectes, al estar por USB el sistema los trata como extraíbles. La convención moderna es que /media es para medios extraíbles o de datos, incluso si están siempre conectados.
3. Mejor integración con el entorno
   Muchas aplicaciones (Plex, Samba, MiniDLNA, gestores de archivos) detectan automáticamente lo montado bajo /media.
   Si usas escritorio, aparecerán automáticamente en el administrador de archivos.
   Por el contrario, /mnt es ignorado por muchas herramientas gráficas.
4. Evitas confusiones de sistema
   Los scripts del sistema y udisks (que gestiona montajes automáticos de USB) respetan /media. Si montas en /mnt, pierdes esa integración.

Excepción: ¿Cuándo usar /mnt?

Prácticamente nunca para estos discos fijos. Solo lo usarías si:

• Temporalmente necesitas desmontar y montar un disco para reparación o pruebas.
• Quieres montar manualmente una partición sin dejarla fija en fstab.

Tabla resumen

Si tu disco es…	Monta en…
Sistema operativo (NVMe, SSD interno)	/ o /boot (lo decide el instalador)
Disco de datos interno adicional (sata, nvme secundario)	/media (o /mnt si prefieres, pero menos práctico)
Disco USB fijo (tu caso)	/media
Disco USB que conectas/desconectas	/media (montaje automático)
Montaje temporal para reparar el sistema	/mnt

Comandos útiles para el día a día

Ver todos los montajes activos

mount | grep "/media"

Ver uso de espacio en discos montados

df -h

Desmontar de forma segura

sudo umount /media/Disco_4TB

# Forzar desmontaje (si está ocupado)

sudo umount -l /media/Disco_4TB

Configuración recomendada.

Resumen para cada HDD:

# Crear puntos de montaje descriptivos
sudo mkdir -p /media/Disco1
sudo mkdir -p /media/Disco2

# Obtener UUID de cada uno
sudo blkid | grep -E "sda|sdb"   # según tu fdisk, /dev/sda y /dev/sdb

# Editar /etc/fstab añadiendo líneas como:
UUID=AAAA...   /media/Disco1   ext4   defaults,nofail,x-systemd.automount   0   2
UUID=BBBB...   /media/Disco2   ext4   defaults,nofail,x-systemd.automount   0   2

Pero como en mi caso utilizo la placa como un híbrido entre PC y servidor, y aprovechando que la Raspberry Pi 5 va sobrada de potencia, he decidido instalar Xfce4 desde cero para llevar la experiencia de uso a otro nivel.

En este artículo te guiaré paso a paso para instalar Xfce, configurar el sistema completamente en español, instalar un navegador web y personalizar el entorno para conseguir un aspecto moderno y atractivo.

Requisitos previos

• Raspberry Pi 5 (también vale para Pi 3/4/400/500)
• Disco SSD o Nvme (evita las MicroSD) de 120 GB en adelante.
• Raspberry Pi OS Lite instalado en el disco (versión 64-bit)
• Conexión a internet (por cable o WiFi configurada desde raspi-config)
• Paciencia y ganas de aprender

¿Por qué empezar con Raspberry Pi OS Lite?

Si ya tienes la versión completa de Raspberry Pi OS (con el escritorio Pixel), instalar otro entorno encima puede provocar conflictos visuales y duplicación de aplicaciones. Por eso es mejor empezar desde Raspberry Pi OS Lite (sin escritorio) e instalar solo lo que necesitas.

• Descarga Raspberry Pi OS Lite 64 bits, desde la web oficial.
• Grábalo en un un disco SSD o Nvme con Raspberry Pi Imager.
• Usa el asistente para elegir nombre de la máquina, usuario, configurar idioma etc etc etc .

1. Instalación base de Xfce

Una vez instalado, entra a tu sistema de terminal pura, e inicia sesión con tu usuario y ejecuta estos comandos en orden:

1.1 Actualizar el sistema por completo

sudo apt update
sudo apt full-upgrade -y

Nota: full-upgrade es importante porque actualiza el kernel y paquetes con cambios de dependencias, algo que el simple upgrade no hace siempre.

1.2 Instalar Xfce + drivers + gestor de red

sudo apt install xfce4 xfce4-goodies network-manager-gnome gldriver-test -y

¿Qué es cada cosa?

• xfce4: el escritorio base.
• xfce4-goodies: un montón de utilidades extra (visor de imágenes, archivador, editor de texto, etc.).
• network-manager-gnome: interfaz gráfica para conectarte a Internet desde el escritorio.
• gldriver-test: Específico de Raspberry Pi y detecta automáticamente el hardware (Pi 5 con VideoCore VII) para configurar el driver gráfico adecuado.

1.3 Configurar el arranque en modo gráfico

Ve a las opciones de configuración la eeprom con el siguiente comando.

sudo raspi-config

Dentro de la herramienta:

Ve a 1. System Options Configure system settings

Raspberry Pi 5 Model B Rev 1.0, 8GB


┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│       1 System Options       Configure system settings                       │
│       2 Display Options      Configure display settings                      │
│       3 Interface Options    Configure connections to peripherals            │
│       4 Performance Options  Configure performance settings                  │
│       5 Localisation Options Configure language and regional settings        │
│       6 Advanced Options     Configure advanced settings                     │
│       8 Update               Update this tool to the latest version          │
│       9 About raspi-config   Information about this configuration tool       │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Select>                     <Finish>  

Busca la opcion S5 Boot Select boot into desktop or to command line y pulsa Enter

┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│      S1 Wireless LAN    Enter SSID and passphrase                            │
│      S2 Audio           Select audio out through HDMI or 3.5mm jack          │
│      S3 Password        Change password for the 'raspberry' user             │
│      S4 Hostname        Set name for this computer on a network              │
│      S5 Boot            Select boot into desktop or to command line          │
│      S6 Auto Login      Enable auto login to desktop or to command line      │
│      S7 Splash Screen   Choose graphical splash screen or text boot          │
│      S8 Power LED       Set behaviour of power LED                           │
│      S9 Browser         Choose default web browser                           │
│      S10 Admin Password Enable or disable sudo password                      │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Select>                     <Back>         

Baja con las flechas del teclado hasta B2 Desktop Desktop GUI

┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│                           B1 Console Text console                            │
│                           B2 Desktop Desktop GUI                             │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Aceptar>                    <Cancelar>                  │
│                                                               

Pulsa Tab, para Aceptar, luego Enter, y al salir te preguntará si quieres reiniciar. Di que Sí.

1.4 Al reiniciar, ¡magia!

Aparecerá la pantalla de inicio de sesión de Xfce (LightDM por defecto). Inicia sesión con tu usuario y contraseña.

¡Felicidades! Ya tienes Xfce funcionando, con el driver gráfico correcto y el gestor de red listo para conectar por ETHERNET o WiFi.

2. Poniendo a punto el sistema.

2.2 Instala los paquetes de idioma de Xfce4.

Xfce recién instalado está en inglés. Vamos a arreglarlo.

sudo apt install task-spanish-desktop -y

2.3 Configura el idioma del sistema.

sudo dpkg-reconfigure locales

• Usa las flechas y la barra espaciadora para seleccionar es_ES.UTF-8
• También marca en_US.UTF-8 UTF-8 (por si acaso, no está de más).
• En la pantalla siguiente, elige es_ES.UTF-8 como idioma por defecto.

2.4 Hacer visibles equipos en red.

Por algún motivo que desconozco, xfce viene de fábrica mas ciego que un topo, no ve ningún equipo en la red.

Y para arreglare esto, instala los paquete sugeridos:

sudo apt install thunar-archive-plugin thunar-media-tags-plugin gvfs-backends

2.5 Reinicia para que todo se aplique.

sudo reboot

Al volver, todos los menús de Xfce, la configuración y las aplicaciones estarán en español de España (incluido Firefox cuando lo abras).

3. Personaliza Xfce para que se vea BONITO

Xfce por defecto es funcional pero feo. Con estos pasos lo convertirás en un escritorio moderno, similar a macOS o Windows 11.

3.1 Instala temas, iconos y un dock

sudo apt install arc-theme papirus-icon-theme

• Arc-theme: tema limpio y moderno (versión oscura y clara).
• Papirus-icon-theme: los mejores iconos para Linux, actualizados y vistosos.

3.1.a Aplicar el tema y los iconos (desde el escritorio)

Ve al menú de aplicaciones > Settings > Appearance:

• En la pestaña Style, selecciona Arc-Darker (o Arc-Dark si te gusta muy oscuro).
• En la pestaña Icons, selecciona Papirus-Dark (o Papirus para la versión clara).

Luego ve a Settings > Window Manager y en la pestaña Style, elige también Arc-Darker para que las ventanas combinen.

3.1.b Cambiar el fondo de pantalla (opcional)

Haz clic derecho en el escritorio > Desktop Settings > Background. Elige una imagen bonita. Puedes descargar fondos con:

sudo apt install variety  # gestor de fondos de pantalla (luego lo encuentras en el menú)

3.1.c Extra: instalar un tema para LightDM (pantalla de inicio de sesión)

sudo apt install lightdm-settings

Luego ve a Settings > LightDM GTK+ Greeter Settings para elegir un tema que combine con tu escritorio.

4 Trucos adicionales para un escritorio perfecto

4.2 Hacer que el sistema sea más rápido

En una Raspberry Pi 5 va muy fluido, así que no deshabilitaré ningún efecto, pero si tu placa es mas limitada puedes hacerlo así.

# Deshabilitar efectos visuales pesados
xfconf-query -c xfwm4 -p /general/use_compositing -s false

5 Instalar Software.

5.1 Instalar un navegador web (Firefox en español)

Lo primero que haremos será instalar un navegador, ya que lo vas a necesitar para seguir este tutorial.

En una terminal reglamentaria y homologada, escribe:

sudo apt install firefox-esr firefox-esr-l10n-es-es -y

Ahora lo encontrarás en el menú de aplicaciones > Internet > Firefox ESR.

5.2 Instalar Flatpak

Con Flatpak tendremos acceso a una gran cantidad de software y lo instalaremos mediante el siguiente proceso.

# 1. Instalar Flatpak
sudo apt install flatpak -y

# 2. Añadir el repositorio Flathub
sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

5.3 Instalar Telegram desde Flatpak

Telegram no puede faltar en mis equipos, así, que una vez instalado Flatpak, nada nos impide empezar a instalar cualquier software que necesitemos, en este caso empezamos por Telegram.

# 3. Instalar Telegram
sudo flatpak install flathub org.telegram.desktop -y

# 4. Ejecutar Telegram
flatpak run org.telegram.desktop

5.4 Instalar Flatseal (dando permisos a aplicaciones)

Flatseal. Es una herramienta gráfica fantástica que te permite gestionar los permisos de tus apps de Flatpak con solo mover unos interruptores.

Por seguridad, las aplicaciones Flatpak corren en una especie de caja de arena (sandbox) y no tienen acceso a tus carpetas personales por defecto, por eso no te deja arrastrar y soltar archivos.

Una vez que tienes instalado Flatpak , puedes instalar Flatseal abriendo tu terminal y ejecutando el siguiente comando:

flatpak install flathub com.github.tchx84.Flatseal

Una vez instalada, ábrela desde el menú de aplicaciones de tu Raspberry Pi (suele aparecer en la sección de «Accesorios»).

Dando permisos a Telegram.

Por seguridad, cuando intentas arrastrar y soltar archivos a Telegram ocurre un error de permisos ya que las aplicaciones corren en una especie de caja de arena (sandbox) y no tienen acceso a tus carpetas personales por defecto.

Para solucionar esto:

1. En la barra lateral izquierda de Flatseal, busca y selecciona Telegram.
2. En el panel de la derecha, baja hasta la sección llamada Filesystem (Sistema de archivos).
3. Activa la opción All user files (Todos los archivos de usuario) o Home folder (Carpeta personal).
   • Tip: Si prefieres no darle acceso a todo, puedes ir a la opción Other files (Otros archivos), añadir una ruta manualmente y poner, por ejemplo, ~/Downloads (tu carpeta de Descargas).

Una alternativa rápida por comandos (sin instalar nada)

Si no te apetece instalar otra app y prefieres arreglarlo en un segundo desde la terminal, puedes darle acceso a tu carpeta personal (home) a Telegram ejecutando este comando:

flatpak override org.telegram.desktop --filesystem=home

Nota importante: Después de aplicar los cambios (ya sea con Flatseal o por comando), asegúrate de cerrar Telegram por completo y volverlo a abrir para que los permisos se activen. ¡Con eso ya deberías poder arrastrar tus archivos sin problemas!

5.5 Instalar software básico

# Reproductor de música
sudo apt install quodlibet

# Reproductor de vídeo
sudo apt install vlc

# Editor de imágenes
sudo apt install gimp

# Oficina (opcional, algo pesado para Pi 5 pero funciona)
sudo apt install libreoffice

¡Claro que sí! He reestructurado el texto para que quede impecable, con una jerarquía clara, bloques de código limpios y un formato muy cómodo de leer para los visitantes de tu blog.

Aquí tienes la propuesta maquetada en Markdown, lista para copiar y pegar:

5.6 Recuperar el bloqueo de pantalla clásico (LightDM) en MX 25 / Debian 13

El equipo de desarrollo de Xfce ha ido independizando y delegando por completo el bloqueo de sesión en xfce4-screensaver. Ahora, el gestor de energía no bloquea por sí mismo, sino que le dice al salvapantallas: «Oye, apágate y bloquea».

¿La consecuencia? Ya no ves la pantalla de login nativa de LightDM. En su lugar, aparece la interfaz propia de xfce4-screensaver (con su fondo gris, reloj flotante o el logo del tema actual). Aunque cumple su función, estéticamente no es lo mismo a lo que estábamos acostumbrados en Debian 12 o MX 23.

Si prefieres el comportamiento clásico —un bloqueo directo con la pantalla de login de LightDM y sin un demonio de salvapantallas consumiendo recursos en segundo plano—, sigue estos pasos:

Paso 1: Desinstalar el salvapantallas de Xfce

Para evitar conflictos entre gestores, lo ideal es eliminar por completo el paquete nativo y limpiar sus residuos. Abre una terminal y ejecuta:

sudo apt remove --purge xfce4-screensaver

sudo apt autoremove

Nota: El parámetro --purge asegura que también se eliminen los archivos de configuración obsoletos, mientras que autoremove limpia las dependencias pequeñas que hayan quedado huérfanas.

Paso 2: Instalar y configurar Light-Locker

Como en las versiones más recientes de Debian (como Trixie) el paquete gráfico light-locker-settings ya no está disponible en los repositorios, instalaremos solo el motor principal desde la terminal:

sudo apt update && sudo apt install light-locker

Cierra sesión o reinicia tu Raspberry.

A continuación, debemos asegurarnos de que light-locker arranque automáticamente con el sistema:

• Ve al menú de aplicaciones ➔ Configuración ➔ Sesión e inicio.
• Entra en la pestaña Inicio automático de aplicaciones.
• Comprueba que se añadió Bloqueador de pantalla.

Si light-locker no aparece y no está cargado, podemos añadirlo manualmente con:

1. Ve al menú de aplicaciones ➔ Configuración ➔ Sesión e inicio.
2. Entra en la pestaña Autoarranque de aplicaciones.
3. Haz clic en el botón «+» (Añadir) y rellena los campos de la siguiente manera:
   • Nombre: Light Locker Classic
   • Descripción: Bloqueo con pantalla de login nativa
   • Comando: light-locker --lock-on-suspend --lock-after-screensaver=0
4. Guarda los cambios.

¿Cómo probar si funciona?

Para que los cambios surtan efecto, cierra tu sesión actual y vuelve a entrar (o reinicia el sistema).

Si quieres comprobar que el bloqueo funciona correctamente de inmediato, sin necesidad de esperar el tiempo de inactividad, abre una terminal y lanza este comando:

light-locker-command -l

Verás cómo el monitor salta instantáneamente a la mítica pantalla de login tradicional, idéntica a la gestión de sesiones que disfrutábamos en Debian 12.

6. Resumen de comandos útiles (chuleta)

7. Conclusión

Con este tutorial hemos conseguido:

Instalar Xfce en Raspberry Pi 5 sin pantalla negra (usando gldriver-test y raspi-config).
Tener el sistema completo en español de España (interfaz, teclado y Firefox).
Un escritorio bonito y moderno con temas Arc, iconos Papirus.
Un navegador web, gestor de red WiFi y aplicaciones básicas listas para usar.

Ahora tu Raspberry Pi 5 tiene un escritorio ligero, atractivo y totalmente funcional, perfecto para trabajar, navegar o incluso como pequeño PC de escritorio.

¿Te ha funcionado? ¿Tienes alguna duda? Déjame un comentario en el blog y te ayudaré.

Este tutorial está basado en mi experiencia real y en el vídeo «How to Install XFCE Desktop on Raspberry Pi OS Lite (Trixie)» de Amine Tech. Todos los comandos han sido probados en Raspberry Pi 5 con Debian 13 Trixie,

WireGuard es una VPN moderna, ultrarrápida y muy segura. A diferencia de OpenVPN, es nativa del kernel de Linux (va como parte del sistema, no como un programa aparte), consume muy pocos recursos y se configura en minutos.

¿Para qué querrás una VPN en tu Raspberry Pi?

• Acceder a tu red local desde cualquier lugar (archivos, impresoras, otros equipos)
• Navegar con la IP de tu casa cuando estés fuera (evitar bloqueos geográficos)
• Sincronizar contraseñas de forma segura con KeePass + Syncthing (el siguiente tutorial)
• Usar WiFi públicas sin miedo a que espíen tu tráfico

Ventajas de montarla en una Raspberry Pi:

• Consumo eléctrico ridículo (puede estar 24/7 encendida)
• Control total de tus datos (no dependes de servicios de terceros)
• Aprendizaje enorme

Requisitos

• Una Raspberry Pi (cualquier modelo desde la 3B funciona, pero mejor una Pi 4 o 5)
• Raspberry Pi OS instalado y actualizado (puede ser la versión Lite sin escritorio)
• DuckDNS (gratuito) o cualquier servicio de DNS dinámico ( no lo configuramos aquí)
• Un puerto abierto en tu router (el 51820 UDP)
• Un teléfono Android (para probar el cliente)

1. Instalación de WireGuard

Conéctate a tu Raspberry Pi por SSH o directamente con teclado y pantalla.

sudo apt update && sudo apt upgrade -y
sudo apt install wireguard wireguard-tools qrencode iptables nftables -y

Verifica que el módulo del kernel se ha cargado correctamente:

sudo modprobe wireguard
lsmod | grep wireguard

Si ves algo como wireguard 131072 0, está todo bien.

2. Generar las claves del servidor

Cada VPN necesita un par de claves (pública y privada) para el servidor y otro par para cada cliente. Empezamos con las del servidor.

sudo mkdir -p /etc/wireguard
cd /etc/wireguard
sudo umask 077
sudo wg genkey | sudo tee private.key
sudo cat private.key | sudo wg pubkey | sudo tee public.key

Comprueba que se han creado los archivos:

sudo ls -la /etc/wireguard/

Debes ver private.key y public.key, ambos con permisos -rw------- (600).

3. Crear la configuración del servidor

Ahora creamos el archivo de configuración que arrancará la VPN.

sudo nano /etc/wireguard/wg0.conf

Pega este contenido (cambiando la PrivateKey por la tuya):

[Interface]
PrivateKey = PEGA_AQUÍ_TU_CLAVE_PRIVADA
Address = 10.0.0.1/24
ListenPort = 51820
SaveConfig = false

PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

¿Cómo obtener tu clave privada?

sudo cat /etc/wireguard/private.key

Copia el resultado y pégalo donde pone PrivateKey = ...

Importante sobre la interfaz de red:

• Si tu Raspberry Pi usa cable Ethernet, deja eth0
• Si usa WiFi, cambia eth0 por wlan0
• Si no estás seguro, ejecuta ip route | grep default y mira qué interfaz aparece

Las líneas PostUp y PostDown son las que permiten que tu móvil tenga acceso a internet a través de la VPN (enmascaramiento NAT). Sin ellas, la VPN conectará pero no habrá internet.

Guarda el archivo (Ctrl+O, Enter, Ctrl+X).

4. Configurar el sistema para enrutar tráfico

La VPN necesita que el sistema operativo permita reenviar paquetes de una interfaz a otra.

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Debes ver net.ipv4.ip_forward = 1 en la salida.

5. Arrancar WireGuard

sudo chmod 600 /etc/wireguard/*
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

Verifica que funciona:

sudo wg show

Deberías ver algo como:

interface: wg0
  public key: TU_CLAVE_PUBLICA
  private key: (hidden)
  listening port: 51820

Y comprueba que el puerto está escuchando:

sudo ss -tuln | grep 51820

Debe aparecer 0.0.0.0:51820.

6. Crear la configuración para el móvil (cliente)

Cada dispositivo que se conecte a la VPN necesita su propio par de claves. Vamos a generar las del móvil.

sudo mkdir -p /etc/wireguard/clients
cd /etc/wireguard/clients
sudo umask 077
sudo wg genkey | sudo tee mobile_private.key
sudo cat mobile_private.key | sudo wg pubkey | sudo tee mobile_public.key

Ahora creamos el archivo de configuración que importaremos en el móvil.

sudo nano mobile.conf

Pega este contenido (cambia solo los campos entre [ ... ]):

[Interface]
PrivateKey = [CLAVE_PRIVADA_DEL_MOVIL]
Address = 10.0.0.2/32
DNS = 8.8.8.8

[Peer]
PublicKey = [CLAVE_PUBLICA_DEL_SERVIDOR]
Endpoint = [TU_DOMINIO_O_IP_PUBLICA]:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

Rellena cada campo:

• [CLAVE_PRIVADA_DEL_MOVIL] → El contenido de sudo cat /etc/wireguard/clients/mobile_private.key
• [CLAVE_PUBLICA_DEL_SERVIDOR] → El contenido de sudo cat /etc/wireguard/public.key
• [TU_DOMINIO_O_IP_PUBLICA] → Tu dominio DuckDNS (ej: tublog.duckdns.org) o tu IP pública si no tienes DNS dinámico

Guarda el archivo.

7. Añadir el móvil como cliente permitido en el servidor

MOBILE_PUBKEY=$(sudo cat /etc/wireguard/clients/mobile_public.key)
sudo wg set wg0 peer $MOBILE_PUBKEY allowed-ips 10.0.0.2/32
sudo wg-quick save wg0

Verifica que aparece el peer:

sudo wg show

Ahora deberías ver una sección peer: adicional con la clave pública del móvil.

8. Preparar el código QR para el móvil

sudo cat /etc/wireguard/clients/mobile.conf | qrencode -t ansiutf8

Esto mostrará un código QR en la terminal.

En tu Android:

1. Instala la app WireGuard desde Play Store
2. Abre la app → Botón + → Escanear desde código QR
3. Escanea el código QR de la terminal

La app importará automáticamente la configuración. Solo tendrás que pulsar el interruptor para conectarte.

9. Abrir el puerto en el router (imprescindible para acceso remoto)

Este es el único paso que depende de tu router, pero es sencillo.

Primero, averigua la IP local de tu Raspberry Pi:

hostname -I

Anota la primera IP (ej: 192.168.1.150).

Accede a la web de tu router (normalmente 192.168.1.1 o 192.168.0.1).

Busca la sección «Reenvío de puertos» o «Port Forwarding» y añade una regla:

Guarda los cambios. Si tu router tiene la opción, reinícialo para aplicar la regla.

Si usas DuckDNS: Asegúrate de que el cliente de actualización está corriendo en tu Raspberry Pi o en el router, para que tu dominio siempre apunte a tu IP pública.

10. Comprobación final

Prueba dentro de casa (WiFi local)

1. En el móvil, activa WireGuard
2. Abre el navegador y busca «cuál es mi IP»
3. Debe mostrar la IP pública de tu casa (la de tu router)

Prueba desde fuera (con datos móviles)

1. Desactiva el WiFi del móvil
2. Activa WireGuard
3. Repite la búsqueda de IP
4. Sigue debiendo mostrar la IP de tu casa

Si ves la IP de tu casa, la VPN funciona perfectamente.

11. Posibles errores y soluciones (basados en errores reales)

12. Mantenimiento y buenas prácticas

• Actualiza regularmente: sudo apt update && sudo apt upgrade -y
• Monitorea el servicio: sudo systemctl status wg-quick@wg0
• Revoca el acceso a un dispositivo: Elimina su peer del servidor con sudo wg set wg0 peer [su_clave_publica] remove
• Copia de seguridad de las claves: Guarda en un lugar seguro (/etc/wireguard/ entero)
• Puerto seguro: El 51820 UDP es el estándar, pero puedes cambiarlo por cualquier otro si quieres algo menos predecible

13. ¿Qué viene después?

Con la VPN funcionando, ya puedes:

• Sincronizar contraseñas entre tu PC con Linux y tu Android usando KeePassXC + Syncthing (próximo tutorial)
• Acceder a tu red doméstica desde cualquier lugar (NAS, servidor multimedia, impresora)
• Usar Pi-hole para bloquear anuncios también en tu móvil cuando estás fuera de casa

Conclusión

Has montado tu propia VPN en una Raspberry Pi sin depender de servicios externos, sin Docker y con software libre. WireGuard es ligero, seguro y una vez configurado, olvidas que está ahí.

¿Te ha servido? ¿Tienes dudas? Puedes dejar un comentario y te ayudaré (porque yo ya pasé por todos los errores posibles mientras escribía este tutorial).

Este tutorial está basado en una instalación real en Raspberry Pi 5 con Raspberry Pi OS, sin Docker, y probado con Android 13.

De repente, cada vez que reiniciaba el sistema, la Pi arrancaba pero con la pantalla más negra que el porvenir de un zombi. Al principio, el pánico: pensé que el sistema se colgaba y no arrancaba. Cambié el HAT, probé otro disco NVMe, compré cables HDMI nuevos e incluso reinstalé el sistema operativo varias veces. ¿El resultado? El mismo vacío oscuro.

Sin embargo, al entrar por SSH desde mi teléfono, descubrí la verdad: la Pi estaba vivita y coleando, con el sistema totalmente cargado y funcionando de fondo. El problema no era que la Pi no arrancara, ¡era que no quería hablar con mi monitor!

Nota: Para que el sistema arranque de forma normal quita el cable de alimentación y tras 5 segundos vuelve a conectar.

¿Por qué el NVMe «rompe» el vídeo al reiniciar?

Si te está pasando lo mismo, no te vuelvas loco cambiando hardware. La explicación de por qué con una tarjeta SD o un SSD lento todo iba bien y con el NVMe oficial falla, se resume en estos tres factores:

• Tu Raspberry Pi ahora es «demasiado rápida»: Imagina que el arranque es una conversación. Con la SD, la Pi tardaba 30 segundos; al monitor le daba tiempo a despertarse y tomarse un café. Con el NVMe, el sistema carga en 5 segundos. La Pi lanza la señal de vídeo tan rápido que el monitor aún está «desperezándose» del reinicio. Cuando el monitor quiere mirar, la Pi ya ha dejado de llamar a la puerta y ambos se quedan esperando en silencio.
• Interferencias y «ruido» eléctrico: El bus PCIe donde va tu NVMe funciona a frecuencias altísimas que generan ondas electromagnéticas. Como los puertos micro-HDMI están pegados al conector PCIe en la Pi 5, ese «ruido» puede ensuciar la señal. Si el cable no es de excelente calidad, la Pi no recibe los datos del monitor (EDID) y, por seguridad, apaga la salida.
• El reinicio «suave» vs «fuerte»: Al reiniciar desde el escritorio, el driver de vídeo a veces no se cierra correctamente antes de que el rapidísimo NVMe vuelva a cargar todo. Esto deja a la gráfica en un estado de confusión total.

En resumen: Es como si tu Raspberry Pi fuera ahora un coche de carreras. Arranca tan rápido que sale del garaje antes de que la puerta (tu monitor) termine de abrirse.

A continuación, te explico los pasos exactos para decirle a tu Pi: «Espera un segundo antes de salir y, aunque veas la puerta cerrada, empuja, que se abrirá».

El cambio imprescindible (De Wayland a X11)

Por defecto, la Raspberry Pi 5 utiliza Wayland. Sin embargo, Wayland todavía tiene problemas para gestionar el «Screen Blanking» (que la pantalla se apague sola tras un tiempo sin uso).

Si quieres que tu monitor descanse y que los comandos que vamos a usar funcionen, debemos volver al servidor gráfico X11.

¿Cómo cambiar a X11?

1. Abre una terminal y escribe: sudo raspi-config
2. Ve a 6 Advanced Options.
3. Busca A6 Wayland.
4. Selecciona W1 X11 (o el que indique que desactiva Wayland).
5. Dale a Finish y acepta el Reboot (reiniciar).

Ahora que estamos en X11, todos los comandos de ahorro de energía y gestión de pantalla funcionarán como un reloj.

Parte 1: El «Seguro de Vida» (Configurar SSH)

Antes de meterle mano a la configuración interna, necesitamos una forma de hablar con la Raspberry Pi cuando la pantalla está en negro. Para eso usamos el SSH (Secure Shell). Si puedes entrar por SSH desde tu móvil o tu PC mientras la pantalla está oscura, ¡felicidades!, tu Pi no está muerta, solo está «tímida» con el monitor.

1. ¿Cómo saber si el SSH está activo?

Si tienes la suerte de que la pantalla ha encendido o estás configurándola por primera vez, abre una terminal y comprueba el estado del servicio:

sudo systemctl status ssh

Caso A: El servicio funciona correctamente

Si ves un mensaje en verde que dice active (running), todo está perfecto. Ya puedes acceder remotamente.

Ojo: En mi caso veréis que uso el puerto 22299, pero por defecto en vuestra Pi será el 22.

● ssh.service - OpenBSD Secure Shell server
     Active: active (running) since Sat 2026-03-14 15:15:56 CET; 3h 28min ago
     ...
     mar 14 15:15:56 pi5-2 sshd[1006]: Server listening on 0.0.0.0 port 22299.

Caso B: El servicio está apagado o muerto

Si por el contrario ves que dice inactive (dead), significa que estás «ciego» si la pantalla falla. Tienes que activarlo obligatoriamente.

○ ssh.service - OpenBSD Secure Shell server
     Loaded: loaded (...; disabled; ...)
     Active: inactive (dead)

2. Cómo activar e iniciar el SSH

Para que el SSH se encienda solo cada vez que arranques la Pi (muy importante para nuestro problema), ejecuta estos dos comandos:

Primero: Habilitar el inicio automático

sudo systemctl enable ssh

Verás que el sistema crea unos «symlinks» (accesos directos internos), eso indica que ahora arrancará siempre con el sistema.

Segundo: Arrancar el servicio ahora mismo

sudo systemctl start ssh

Parte 2: El diagnóstico definitivo (¿Monitor o Sistema?)

Una vez que tengas SSH, la próxima vez que reinicies y la pantalla se quede «más negra que el porvenir de un zombi», no entres en pánico. Conéctate desde tu móvil y lanza este comando:

kmsprint

• Si ves HDMI-A-1 (connected) nos confirma que la Raspberry Pi sí detecta el monitor, pero la señal de vídeo no se está «dibujando»
• Si quieres forzar el encendido desde el móvil, pega esto en la terminal de tu móvil:

export DISPLAY=:0
xset dpms force on

Si esto no enciende tu monitor, ejecuta:

sudo systemctl restart lightdm

(Esto cerrará tus apps abiertas, pero debería forzar al monitor a recibir señal).

En mi caso, reiniciar lightdm encendió mi monitor.

El hecho de que al reiniciar lightdm la pantalla se encienda es la prueba definitiva: el sistema operativo arranca bien, el hardware funciona y el disco NVMe está perfecto.

Parte 3: La Solución Definitiva (La «D» Mágica)

Si has confirmado que por SSH todo funciona pero el HDMI se queda frito, vamos a aplicar la medicina. Editamos el archivo de configuración del arranque:

sudo nano /boot/firmware/cmdline.txt

Ve al final de la única línea que hay, añade un espacio y escribe:

video=HDMI-A-1:1920x1080@60D

¿Por qué la D? Porque le dice a la Pi: «Envía señal Digital sí o sí, no preguntes al monitor si está listo, ¡dispara!».

Un último ajuste en la EEPROM

Para que el disco NVMe y el vídeo se lleven bien eléctricamente en la Raspberry Pi 5, te recomiendo este cambio final:

sudo rpi-eeprom-config --edit

Dentro te encontrarás tres líneas como estas.

BOOT_UART=1
BOOT_ORDER=0xf146
NET_INSTALL_AT_POWER_ON=1

Añade estas líneas al final de las existentes:

• POWER_OFF_ON_HALT=1
• HDMI_DELAY=1

Cuando lo tengas, guarda los cambios con Ctrl + o y cierra para salir con Crtl + x

Entonces se generará la nueva configuración.

raspberry@pi5:~ $ sudo rpi-eeprom-config --edit
Updating bootloader EEPROM
 image: /usr/lib/firmware/raspberrypi/bootloader-2712/default/pieeprom-2026-05-26.bin
config_src: blconfig device
config: /tmp/tmp_3tpo_c8/boot.conf
################################################################################
[all]
BOOT_UART=1
BOOT_ORDER=0xf146
NET_INSTALL_AT_POWER_ON=1
POWER_OFF_ON_HALT=1
HDMI_DELAY=1

################################################################################
*** CREATED UPDATE /tmp/tmp_3tpo_c8/pieeprom.upd  ***

Checking flashrom probe
   CURRENT: vie 06 feb 2026 14:31:40 UTC (1770388300)
    UPDATE: mar 26 may 2026 15:01:25 UTC (1779807685)
    BOOTFS: /boot/firmware
'/tmp/tmp.1fcqwNnARo' -> '/boot/firmware/pieeprom.upd'

UPDATING bootloader. This could take up to a minute. Please wait

*** Do not disconnect the power until the update is complete ***

If a problem occurs then the Raspberry Pi Imager may be used to create
a bootloader rescue SD card image which restores the default bootloader image.

flashrom -p linux_spi:dev=/dev/spidev10.0,spispeed=16000 -w /boot/firmware/pieeprom.upd
Verifying update
VERIFY: SUCCESS
UPDATE SUCCESSFUL
raspberry@pi5:~ $ 

Ahora tan solo reinicia el sistema con

sudo reboot

Este paso es como ajustar el «reloj interno» y la gestión eléctrica de la placa base de tu Raspberry Pi 5. Es el ajuste que soluciona el conflicto físico entre el disco NVMe y el puerto HDMI.

• POWER_OFF_ON_HALT=1: Fuerza un reinicio eléctrico completo. Evita que el disco «atonté» a la salida de vídeo.
• HDMI_DELAY=1: Le da un segundo de ventaja al monitor para que esté listo antes de que la Pi empiece a enviar imágenes.

¡Y listo! Con esto habrás pasado de tener un pisapapeles caro a una Raspberry Pi 5 con NVMe que vuela y que no se achica ante ningún reinicio.