--- title: "Cómo instalar un servidor Mumble en Ubuntu 24.04" description: "Instala el servidor de voz Mumble en Ubuntu 24.04, fija la contraseña de SuperUser, abre el firewall, añade un certificado TLS y organiza canales y permisos." category: "VoIP y Comunicación" language: es source: https://cubepath.com/es/docs/voip-y-comunicación/instalacion-de-mumble-servidor-de-voz updated: 2026-09-25 --- # Cómo instalar un servidor Mumble en Ubuntu 24.04 Mumble es un sistema de chat de voz libre, cifrado y de muy baja latencia, muy usado por comunidades de juego y equipos que quieren un servidor de voz propio. El componente servidor (antes llamado Murmur y ahora `mumble-server`) es ligero y funciona con pocos recursos. En este tutorial instalarás `mumble-server` en Ubuntu 24.04, le darás una contraseña de administrador, lo publicarás a través del firewall, le pondrás un certificado de Let's Encrypt y crearás tus primeros canales y grupos. ## Requisitos previos - Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Con 1 GB de RAM hay de sobra para decenas de usuarios. - Un usuario no root con privilegios `sudo`. - UFW activo con el acceso SSH permitido. - Opcional, para el certificado TLS: un dominio (en este tutorial `your_domain`) con un registro A que apunte a la IP del servidor. - El cliente Mumble instalado en tu ordenador (disponible en [mumble.info](https://www.mumble.info/downloads/) para Windows, macOS y Linux). ## Paso 1: Instalar mumble-server El paquete `mumble-server` está en el repositorio `universe` de Ubuntu e incluye un servicio systemd ya configurado: ```bash sudo apt update sudo apt install mumble-server ``` Durante la instalación, debconf puede preguntarte si quieres que el servidor arranque al inicio y si quieres fijar la contraseña de SuperUser. Si no aparecen esas preguntas no pasa nada; las responderás en el paso 2. Comprueba que el servicio está activo: ```bash sudo systemctl status mumble-server ``` ```output ● mumble-server.service - Mumble server Loaded: loaded (/usr/lib/systemd/system/mumble-server.service; enabled; preset: enabled) Active: active (running) since ... ``` El servicio lee su configuración de `/etc/mumble/mumble-server.ini` y escribe el log en el journal de systemd. ## Paso 2: Definir la contraseña de SuperUser `SuperUser` es la cuenta especial del servidor que se salta todas las comprobaciones de permisos. La usarás para crear canales y nombrar administradores. La forma más limpia de fijar su contraseña es reconfigurar el paquete: ```bash sudo dpkg-reconfigure mumble-server ``` El asistente pregunta si el servidor debe arrancar al inicio (responde **Sí**), si debe tener prioridad de red alta (puedes responder **Sí**) y la contraseña de SuperUser. Escribe una contraseña larga y guárdala en tu gestor de contraseñas. Si el script de configuración no consigue aplicar la contraseña, lo indica en la terminal con el mensaje `Failed to set SuperUser password.`. Si no ves ese mensaje, la contraseña se ha guardado; lo comprobarás al conectarte como SuperUser en el paso 6. ## Paso 3: Ajustar la configuración del servidor Abre el archivo de configuración: ```bash sudo nano /etc/mumble/mumble-server.ini ``` Las opciones más útiles ya vienen en el archivo, algunas comentadas con `;`. Ajusta o descomenta estas líneas: ```ini ; Texto que ven los usuarios al conectarse (admite HTML sencillo) welcometext="
Bienvenido al servidor de voz de tu comunidad.
" ; Puerto TCP y UDP de escucha port=64738 ; Contraseña de acceso para todos los usuarios. Vacío = servidor público serverpassword= ; Número máximo de usuarios conectados a la vez users=50 ; Ancho de banda máximo por usuario en bits por segundo bandwidth=72000 ; Nombre del canal raíz que ven los clientes registerName=Mi servidor de voz ``` Un `bandwidth` de 72000 bps da muy buena calidad con Opus y reduce el consumo cuando hay muchos usuarios hablando a la vez. Si quieres un servidor privado, pon una contraseña en `serverpassword` y compártela solo con tu grupo. Reinicia el servicio para aplicar los cambios y comprueba que escucha en TCP y UDP: ```bash sudo systemctl restart mumble-server sudo ss -tulpn | grep 64738 ``` ```output udp UNCONN 0 0 *:64738 *:* users:(("mumble-server",pid=2412,fd=33)) tcp LISTEN 0 50 *:64738 *:* users:(("mumble-server",pid=2412,fd=31)) ``` Debes ver una línea `udp` y otra `tcp` para el puerto 64738. Si el servicio no arranca, revisa el journal con `sudo journalctl -u mumble-server -n 50`: suele indicar la línea del `.ini` que tiene un error de sintaxis. ## Paso 4: Abrir el puerto en el firewall Mumble usa TCP para el control y el chat, y UDP para la voz. Abre los dos protocolos: ```bash sudo ufw allow 64738/tcp sudo ufw allow 64738/udp sudo ufw status ``` ```output To Action From -- ------ ---- OpenSSH ALLOW Anywhere 64738/tcp ALLOW Anywhere 64738/udp ALLOW Anywhere ``` Si UDP está bloqueado el cliente se conecta igualmente, pero manda la voz por TCP y la latencia empeora de forma notable. ## Paso 5: Usar un certificado de Let's Encrypt (opcional) Si no configuras nada, el servidor genera un certificado autofirmado y los clientes muestran un aviso la primera vez que se conectan. Con un certificado válido para `your_domain` ese aviso desaparece. Instala certbot y abre temporalmente el puerto 80 para la validación HTTP: ```bash sudo apt install certbot sudo ufw allow 80/tcp sudo certbot certonly --standalone -d your_domain ``` El servicio de Mumble se ejecuta como el usuario `mumble-server`, que no puede leer `/etc/letsencrypt/live/`. La solución es copiar el certificado a `/etc/mumble/` con los permisos correctos en cada renovación, mediante un hook de certbot: ```bash sudo nano /etc/letsencrypt/renewal-hooks/deploy/mumble-server.sh ``` ```bash #!/usr/bin/env bash set -euo pipefail install -m 0640 -o root -g mumble-server "${RENEWED_LINEAGE}/fullchain.pem" /etc/mumble/cert.pem install -m 0640 -o root -g mumble-server "${RENEWED_LINEAGE}/privkey.pem" /etc/mumble/key.pem systemctl restart mumble-server ``` Hazlo ejecutable y lánzalo una vez a mano para copiar el certificado que acabas de obtener: ```bash sudo chmod 755 /etc/letsencrypt/renewal-hooks/deploy/mumble-server.sh sudo RENEWED_LINEAGE=/etc/letsencrypt/live/your_domain /etc/letsencrypt/renewal-hooks/deploy/mumble-server.sh ``` Indica a Mumble dónde están los archivos. En `/etc/mumble/mumble-server.ini`, descomenta y rellena: ```ini sslCert=/etc/mumble/cert.pem sslKey=/etc/mumble/key.pem ``` Reinicia el servicio y comprueba que ha cargado el certificado sin errores: ```bash sudo systemctl restart mumble-server sudo journalctl -u mumble-server -n 20 --no-pager ``` Si el log no muestra errores de SSL, el certificado está en uso. Certbot renueva automáticamente con su timer de systemd y el hook vuelve a copiar los archivos. Puedes probar la renovación con `sudo certbot renew --dry-run`. > Nota: el modo `--standalone` necesita el puerto 80 libre y abierto en cada renovación. Si prefieres no dejarlo abierto, usa la validación DNS de certbot con el plugin de tu proveedor de DNS. ## Paso 6: Conectarte como SuperUser y crear canales Abre el cliente Mumble en tu ordenador y ve a **Servidor > Conectar > Añadir nuevo**: - **Dirección**: `your_domain` o `your_server_ip` - **Puerto**: `64738` - **Usuario**: `SuperUser` Al conectar, introduce la contraseña del paso 2. Ya como SuperUser, haz clic derecho sobre el canal raíz y elige **Añadir** para crear un canal. Una estructura sencilla para una comunidad o empresa podría ser: - `Recepción`: canal de entrada para todos. - `General`: charla abierta. - `Equipos`, con subcanales `Backend`, `Frontend` y `Sistemas`. - `AFK`: para usuarios ausentes. Para crear subcanales, haz clic derecho sobre el canal padre y elige **Añadir**. Si marcas **Temporal**, el canal se borra cuando se queda vacío; déjalo sin marcar para canales permanentes. ## Paso 7: Registrar usuarios y nombrar administradores Mumble identifica a cada usuario por un certificado de cliente que el propio cliente genera la primera vez que se ejecuta (asistente de certificados). Cuando un usuario se conecta, puede registrarse haciendo clic derecho sobre su propio nombre y eligiendo **Registrar**. A partir de ese momento su nombre queda reservado y asociado a su certificado. No uses SuperUser para el día a día. En su lugar, añade tu usuario registrado al grupo `admin`, que en la configuración por defecto tiene todos los permisos en el canal raíz: 1. Conéctate como SuperUser. 2. Haz clic derecho en el canal raíz y elige **Editar**. 3. En la pestaña **Grupos**, selecciona el grupo `admin`. 4. En la lista de miembros, añade el nombre de tu usuario registrado y pulsa **Aceptar**. Desconéctate, vuelve a entrar con tu usuario normal y comprueba que puedes crear y editar canales. > Consejo: pide a cada usuario que exporte su certificado desde el asistente de certificados del cliente y lo guarde en un lugar seguro. Si lo pierde, pierde también su identidad registrada en el servidor. ## Paso 8: Controlar el acceso con ACL Las ACL de Mumble se definen por canal, se heredan hacia los subcanales y se aplican a usuarios o a grupos. Los grupos especiales más útiles son: | Grupo | Quién pertenece | |-------|-----------------| | `all` | Todos los usuarios, registrados o no | | `auth` | Usuarios registrados en el servidor | | `in` | Usuarios que están dentro del canal | | `admin` | Grupo de administradores definido en el canal raíz | Un caso habitual es dejar que cualquiera vea el servidor pero que solo los usuarios registrados puedan hablar. En el canal raíz, abre **Editar > ACL** y añade dos entradas: - Grupo `all`: denegar **Hablar**. - Grupo `auth`: permitir **Hablar** y **Mensaje de texto**. Para un canal privado, por ejemplo `Sistemas`, crea en su pestaña **Grupos** un grupo `sistemas` con sus miembros y en la pestaña **ACL**: - Grupo `all`: denegar **Entrar** y **Atravesar**. - Grupo `sistemas`: permitir **Entrar**, **Atravesar** y **Hablar**. Comprueba el resultado conectándote con un usuario sin registrar: no debe poder hablar en `General` ni ver el canal `Sistemas`. ## Solución de problemas **El cliente no conecta o se queda en "Conectando".** Comprueba que el servicio escucha (`sudo ss -tulpn | grep 64738`) y que UFW permite TCP y UDP. Si tu VPS tiene un firewall adicional en el panel del proveedor, abre allí también el puerto 64738 en ambos protocolos. **El cliente muestra "Servidor conectado mediante TCP" o la voz llega con retraso.** El tráfico UDP no llega al servidor. Revisa la regla `64738/udp` y cualquier firewall intermedio. **Error de certificado al arrancar tras configurar TLS.** Verifica que `/etc/mumble/cert.pem` y `/etc/mumble/key.pem` existen, pertenecen al grupo `mumble-server` y tienen permisos `640`: ```bash ls -l /etc/mumble/*.pem ``` **Has olvidado la contraseña de SuperUser.** Vuelve a ejecutar `sudo dpkg-reconfigure mumble-server` y escribe una nueva contraseña. ## Conclusión Tienes un servidor Mumble funcionando en Ubuntu 24.04 con la configuración básica ajustada, el firewall abierto, un certificado TLS válido y una estructura de canales y permisos controlada por grupos. Como siguientes pasos puedes limitar el acceso con `serverpassword`, definir ACL más finas por equipo o proteger el puerto con reglas de UFW limitadas a las IP de tu organización.