Service mumble.chapril.org

Déploiement du serveur Mumble

Installation

apt-get install mumble-server
dpkg-reconfigure mumble-server

Options choisies :

Oui, la priorité du processus pour une meilleur latence ;
Un mot de passe pour SuperUser.

Mettre le mot de passe dans le password-store à SuperUser.

Le fichier de configuration est /etc/mumble.ini.

Personnalisation

Modification du fichier /etc/mumble.ini :

welcometext="<br/>Bienvenue sur le serveur Mumble du Chapril – https://www.chapril.org/.<br/>"
users=200
registerName=Chapril

Configuration routage flux

Sur korat et persan :

Créer le fichier /etc/firehol/services/mumble.conf :

#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"

Dans /etc/firehol/firehol.conf :

  ["mumble"]='("64738" "tcp udp" "192.168.1.64" "2a01:4f8:10b:c41::64" "2a01:4f8:10b:c42::64")'

Redémarrer FireHOL sur korat et persan :

systemctl restart firehol.service

Configuration pare-feu local

Sur la VM allo :

Créer le fichier /etc/firehol/services/mumble.conf :

#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"

Dans le fichier /etc/firehol/firehol-ext2me.conf, ajouter :

    server mumble accept

Dans le fichier /etc/firehol/firehol.conf, compléter avec :

[…]
# Trafic interne au cluster                                                                                                                                                                                                                                           
# The purpose of this interface is to control the traffic                                                                                                                                                                                                             
# on the ens3 interface with IP 192.168.1.30 (net: "192.168.1.0/24 ").                                                                                                                                                                                                
# on cible les interfaces ens3+ens8 pour mutualiser les regles ipv4 et ipv6                                                                                                                                                                                           
interface "ens3 ens8" internal_trafic src4 "192.168.1.0/24 " dst4 192.168.1.64 src6 "2a01:4f8:10b:c41::/64 2a01:4f8:10b:c42::/64" dst6 "2a01:4f8:10b:c41::64 2a01:4f8:10b:c42::64"
[…]
# Trafic externe au cluster                                                                                                                                                                                                                                           
# The purpose of this interface is to control the traffic                                                                                                                                                                                                             
# from/to unknown networks behind the default gateway 192.168.1.5 .                                                                                                                                                                                                   
# on cible les interfaces ens3+ens8 pour mutualiser les regles ipv4 et ipv6                                                                                                                                                                                           
interface "ens3 ens8" external_trafic src4 not "${UNROUTABLE_IPV4} 192.168.1.0/24 " dst4 192.168.1.64 src6 not "${UNROUTABLE_IPV6} 2a01:4f8:10b:c41::/64 2a01:4f8:10b:c42::/64" dst6 "2a01:4f8:10b:c41::64 2a01:4f8:10b:c42::64"
[…]

Redémarrer FireHOL :

systemctl restart firehol.service

Test de connexion

À cette étape, le serveur Mumble est joignable à condition d'accepter le certificat.

Informations de connexion :

Adresse : mumble.chapril.org ;
Port : 64738 (celui par défaut) ;
Nom d'utilisateur : monpseudo ;
Nom : Chapril.

Permettre la création de salons temporaires

Marche à suivre :

Se connecter en tant que Superuser ;
Bouton droit sur la racine puis modifier ;
Onglet CLA ;
Sélectionner @all non italique ;
Cocher la colonne Autoriser pour la ligne Créer des temporaires ;
Cliquer sur OK.

Configuration certificat

Par défaut, il est possible d'utiliser un certificat auto-signé. Mais alors une boite de dialogue technique apparaît et demande une confirmation. Cela représente une barrière aux utilisateurs. Donc l'utilisation d'un certificat validé par une autorité reconnue est la bienvenue.

apt install dehydrated dnsutils ntp

Temporairement, le temps de tester la configuration on va utiliser le serveur ACME de staging.

echo 'CA="https://acme-staging-v02.api.letsencrypt.org/directory"' > /etc/dehydrated/conf.d/staging.sh

On configure Dehydrated pour faire de la validation DNS-01 dans le fichier /etc/dehydrated/conf.d/auth-dns.sh :

/etc/dehydrated/conf.d/auth-dns.sh

CHALLENGETYPE="dns-01"
HOOK=/etc/dehydrated/hook-custom-chapril.sh

On va maintenant créer le script hook /etc/dehydrated/hook-custom-chapril.sh. C'est lui qui est chargé de pousser des changements dans la zone DNS dynamique _acme-challenge.chapril.org à l'aide de la commande nsupdate. Attention les paramètres passés à la commande nsupdate sont ici spécifiques à Chapril.

Et la valeur de la variable KEY est ici évidemment fausse. La bonne valeur à utiliser se trouve sur le serveur DNS du Chapril dans le fichier /etc/bind/rndc-acme.key.

/etc/dehydrated/hook-custom-chapril.sh

#!/usr/bin/env bash
 
set -e
set -u
set -o pipefail
 
DNSSERVER="dns.cluster.chapril.org"
KEY="hmac-sha512:rndc-acme cmF0YXBvaWwgdWd1c3NlCg=="
NSUPDATE="nsupdate"
TTL=300
 
case "$1" in
    "deploy_challenge")
        printf "key %s\nserver %s\nupdate add _acme-challenge.%s. %d in TXT \"%s\"\nsend\n" "${KEY}" "${DNSSERVER}" "${2}" "${TTL}" "${4}" | $NSUPDATE
        ;;
    "clean_challenge")
        printf "key %s\nserver %s\nupdate delete _acme-challenge.%s. %d in TXT \"%s\"\nsend\n" "${KEY}" "${DNSSERVER}" "${2}" "${TTL}" "${4}" | $NSUPDATE
        ;;
 
    "deploy_cert")
        # Reloading mumble is not possible, so we restart it :(
        /bin/systemctl restart mumble-server
        ;;
 
    "unchanged_cert")
        # do nothing for now
        ;;
 
    "startup_hook")
        # do nothing for now
        ;;
 
    "exit_hook")
        # do nothing for now
        ;;
 
esac
 
exit 0

Il faut rendre ce script exécutable :

chmod +x /etc/dehydrated/hook-custom-chapril.sh

On indique le ou les domaines qu’on souhaite dans /etc/dehydrated/domains.txt :

On génère ici un certificat wildcard. C'est une solution de facilité. Si on avait voulu créer un certificat ciblé pour mumble.chapril.org on aurait été obligé de créer sur le serveur DNS du Chapril une nouvelle zone dynamique _acme-challenge.mumble.chapril.org.

/etc/dehydrated/domains.txt

chapril.org *.chapril.org

La première fois :

dehydrated --register --accept-terms

Puis on génère ou régénère les certificats :

dehydrated -c

Si tout s’est bien passé, alors on peut générer un vrai certificat cette fois. Il faut donc supprimer le fichier /etc/dehydrated/conf.d/staging.sh, forcer la création d’un nouveau compte ACME et forcer le renouvellement du certificat pour écraser le certificat de test qu’on vient de créer.

rm /etc/dehydrated/conf.d/staging.sh
dehydrated --register --accept-terms
dehydrated -c --force

Il faut maintenant automatiser le renouvellement des certificats avec une tâche Cron. On créé le fichier /etc/cron.weekly/acme-renew suivant :

/etc/cron.weekly/acme-renew

#! /bin/bash
/usr/bin/dehydrated -c

Puis on le rend exécutable :

chmod +x /etc/cron.weekly/acme-renew

Configuration Web sur Bastion

Créer le dossier des logs Nginx :

mkdir /var/log/nginx/mumble.chapril.org/

Actions :

Créer le fichier de configuration Web /etc/nginx/sites-available/mumble.chapril.org :
- S'appuyer sur un fichier déjà existant, par exemple drop.chapril.org,
- Remplacer drop par mumble,
- Neutraliser la partie TLS,
- Neutraliser la partie redirection TLS ;
Créer un lien vers ce fichier dans /etc/nginx/sites-enable/ ;
Ajouter mumble.chapril.org dans /etc/dehydrated/domains.txt ;
Lancer dehydrated -c pour générer les certificats ;
Réactiver la redirection TLS et la partie TLS dans le fichier Web.

Organiser les salons

Par défaut, aucun salon n'est présent.

Pour créer des salons :

Se connecter avec :
- Adresse : mumble.chapril.org,
- Port : 64738 (celui par défaut),
- Nom d'utilisateur : Superuser,
- Nom : Chapril-SU ;
Dans l’arborescence des salons :
- Cliquer bouton droit sur root,
- Cliquer sur Ajouter…,
- Remplir le formulaire.

Mumble-web

Principe

Mumble-web peut être installé en mode standalone ou proxied. Pour le Chapril, le mode proxied a été retenu car il permet :

Une gestion du certificat Web sur notre VM Bastion ;
La génération de log HTTP pour suivre la fréquentation du service.

Voici le chemin romancé des requêtes :

Côté utilisateur

Mumble-web consiste en des fichiers statiques : HTML, Javascript et images.

Une fois ces fichiers chargés dans le navigateur depuis https://mumble.chapril.org/, le code Javascript ouvre un flux WebRTC.

Le fichier config.local.js de Mumble-web contient une adresse spéciale pour le flux Web :

config.defaults.address = 'mumble.chapril.org/ws';

Donc le navigateur de l'utilisateur ouvre deux flux : un flux Web statique et un flux WebRTC.

Nginx sur la VM Bastion

Tout le trafic Web du SI Chapril passe par un bastion Web. Les deux flux arrivent sur le même Nginx. C'est à ce niveau là qu'est géré le certificat TLS. Ensuite tout est envoyé au Nginx de la VM Allo sans chiffrement.

Nginx sur la VM Allo

Les deux flux arrivent sur le même Nginx. Si le chemin de requête est / alors on sert les pages Web demandées. Si le chemin demandé est /ws alors on redirige vers le port 64737 du processus websockify.

Websockify sur la VM Allo

Websockify :

Est lancé en tâche de fond via Systemd ;
Lit tout ce qui arrive sur le port 64737 ;
Redirige tout vers le port 64738 (celui de notre serveur Mumble) ;
S'occupe de rediriger correctement les réponses.

Le serveur Mumble traite toutes les connexions sur le port 64738.

Configuration du Nginx Bastion

Il gère le certificat TLS et redirige en proxy vers la VM Allo.

server {
    listen 80;
    listen [::]:80;
 
    server_name mumble.chapril.org; 
 
    access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.access_log;
    error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.error_log;
 
    include /etc/nginx/acme-challenge;
    include /etc/nginx/sexy-chapril;
    include /etc/nginx/force-ssl.conf;
}
 
server {
    listen 443 ssl;
    listen [::]:443 ssl;
 
    server_name mumble.chapril.org;
 
    access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.access_log;
    error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.error_log;
 
    ssl_certificate     /var/lib/dehydrated/certs/mumble.chapril.org/fullchain.pem;
    ssl_certificate_key /var/lib/dehydrated/certs/mumble.chapril.org/privkey.pem;
 
    include /etc/nginx/acme-challenge;
    include /etc/nginx/sexy-chapril;
    #include /etc/nginx/chapril-banner-location;
 
    location / {
        proxy_http_version      1.1;
        proxy_set_header        Upgrade $http_upgrade;
        include proxy_params;
        proxy_pass http://allo.cluster.chapril.org;
    }
}

Installation code et build

Installation de npm :

apt-get install npm

Oui, ça installe 251 paquets node-*…

Clonage :

cd /srv/mumble.chapril.org/
git clone https://github.com/johni0702/mumble-web
cd mumble-web/
npm install
npm run build

Déploiement

Note : pour le premier déploiement, on a utilisé le commit 9945bc5f767eafb0fb82040c4ab38ecf24d99cbc.

Créer la branche officielle :

mkdir /var/www/mumble.chapril.org/
cd /var/www/mumble.chapril.org/
git init .
cp -a /srv/mumble.chapril.org/mumble-web/dist/* .
chown -R www-data /var/www/mumble.chapril.org/
git add .
git commit -m "Build 9945bc5f7"

Créer la branche du Chapril :

cd /var/www/mumble.chapril.org/
git branch chapril-9945bc5f7
git checkout chapril-9945bc5f7

Paramétrer le fichier /var/www/mumble.chapril.org/config.local.js :

echo "config.settings.address     = 'mumble.chapril.org/ws';" >> config.local.js
git add -p
git commit -m "First settings."

Installation de Websockify

Installation de Websockify :

apt install websockify

Configuration de Systemd :

[Unit]
Description=Mumble web interface
Documentation=https://github.com/johni0702/mumble-web
Requires=network.target mumble-server.service
After=network.target mumble-server.service
 
[Service]
Type=simple
User=www-data
ExecStart=/usr/bin/websockify --ssl-target localhost:64737 localhost:64738
 
[Install]
WantedBy=multi-user.target

Activation :

systemctl daemon-reload
systemctl start mumble-web
systemctl enable mumble-web

Configuration du Nginx Allo

Créer les fichiers Nginx :

touch /etc/nginx/sites-available/mumble.chapril.org
ln -s /etc/nginx/sites-available/mumble.chapril.org etc/nginx/sites-enabled/

Remplir le fichier :

server {
        listen 80;
        server_name mumble.chapril.org;
 
        access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org-access.log;
        error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org-error.log;
 
        location / {
                root /var/www/mumble.chapril.org/;
        }
 
        location /ws {
                proxy_pass http://localhost:64737;
                proxy_http_version 1.1;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection $connection_upgrade;
        }
}
 
map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
}

Personnalisation

La boîte de dialogue

Éditer le fichier /var/www/mumble.chapril.org/config.local.js :

config.connectDialog.address  = false;
config.connectDialog.port     = false;
config.connectDialog.token    = false;
config.connectDialog.password = false;
config.connectDialog.channel  = false;
 
config.settings.voiceMode     = 'ptt';
config.settings.joinDialog    = true;

Ajouter un favicon

TODO

Remplacer l'icône GitHub

TODO

Remplacer le lien GitHub

TODO

Franciser un peu

Éditer le fichier /var/www/mumble.chapril.org/index.html :

<!-- TODO -->

Procédure de mise à jour

Les fichiers de Mumble-web sont statiques.

Construire les fichiers :

cd /srv/mumble.chapril.org/mumble-web/
git fetch --all 
npm install
npm run build

Désactiver Mumble-web :

rm /etc/nginx/sites-enabled/mumble.chapril.org
systemctrl restart nginx

Intégrer la nouvelle version :

cd /var/www/mumble.chapril.org/
git checkout master
git branch master-hashducommit
rm -f *
cp -a /srv/mumble-chapril.org/dist/* .
chown -R www-data .
git add .
git commit -m "Build hashducommit"
git checkout chapril-derniereversion
git merge master-hashducommit

Ré-activer Mumble-web :

ln -s /etc/nginx/sites-available/mumble.chapril.org /etc/nginx/sites-enabled/
systemctrl restart nginx

Table des matières

Service mumble.chapril.org

Déploiement du serveur Mumble

Installation

Personnalisation

Configuration routage flux

Configuration pare-feu local

Test de connexion

Permettre la création de salons temporaires

Configuration certificat

Configuration Web sur Bastion

Organiser les salons

Mumble-web

Principe

Côté utilisateur

Nginx sur la VM Bastion

Nginx sur la VM Allo

Websockify sur la VM Allo

Configuration du Nginx Bastion

Installation code et build

Déploiement

Installation de Websockify

Configuration du Nginx Allo

Personnalisation

La boîte de dialogue

Ajouter un favicon

Remplacer l'icône GitHub

Remplacer le lien GitHub

Franciser un peu

Procédure de mise à jour