Outils pour utilisateurs

Outils du site


admin:services:mumble.chapril.org

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 maine et coon :

  • 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 maine et coon :

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 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 chapril une nouvelle zone dynamique _acme-challenge.mumble.chapril.org.
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 pour 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 SSL ;
    • neutraliser la partie redirection SSL ;
  • 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 certifcats ;
  • réactiver la redirection SSL et la partie SSL 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 web,
    • 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 :
    • lancé en tâche de fond via Systemd,
    • lit tout ce qui arrive sur le port 64737,
    • redirige tout vers le port 64738 (c'est celui de notre serveur Mumble),
    • s'occupe de rediriger correctement les réponses,
  • serveur Mumble :
    • traite toutes les connexions sur le port 64738.

Configuration du Nginx bastion

Gère le certificat SSL. 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 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 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 boite 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;

Personnalisation : ajouter un favicon

TODO

Personnalisation : remplacer l'icône GitHub

TODO

Personnalisation : remplacer le lien GitHub

TODO

Personnalisation : 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.

Builder 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
admin/services/mumble.chapril.org.txt · Dernière modification : 2020/03/31 23:51 de cpm