====== Service mumble.chapril.org =======

===== Déploiement du serveur Mumble =====

==== Installation ====
<code>
apt-get install mumble-server
dpkg-reconfigure mumble-server
</code>

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'' :
<code>
welcometext="<br/>Bienvenue sur le serveur Mumble du Chapril – https://www.chapril.org/.<br/>                                                                                                                                                                      
users=200                                                                                                                                                                                                                                                          
registerName=Chapril

</code>

==== Configuration routage flux ====

Sur ''maine'' et ''coon'' :

  * créer le fichier ''/etc/firehol/services/mumble.conf'' :
<code>
#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"
</code>

  * dans ''/etc/firehol/firehol.conf'' :

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

Redémarrer Firehol sur ''maine'' et ''coon'' :
<code>
systemctl restart firehol.service 
</code>

==== Configuration pare-feu local ====
Sur la vm ''allo'' :
  * créer le fichier ''/etc/firehol/services/mumble.conf'' :
<code>
#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"
</code>

  * dans le fichier ''/etc/firehol/firehol-ext2me.conf'', ajouter :
<code>
    server mumble accept
</code>

  * dans le fichier ''/etc/firehol/firehol.conf'', compléter avec :
<code>
[…]
# 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"
[…]
</code>

Redémarrer Firehol :
<code>
systemctl restart firehol.service 
</code>

==== 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.

<code>apt install dehydrated dnsutils ntp</code>

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

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

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

<file bash /etc/dehydrated/conf.d/auth-dns.sh>
CHALLENGETYPE="dns-01"
HOOK=/etc/dehydrated/hook-custom-chapril.sh
</file>

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//.

<file bash /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
</file>

Il faut rendre ce script exécutable :

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

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

<note>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//.</note>

<file /etc/dehydrated/domains.txt>
chapril.org *.chapril.org
</file>

La première fois :

<code>dehydrated --register --accept-terms</code>

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

<code>dehydrated -c</code>

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.

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

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

<file bash /etc/cron.weekly/acme-renew>
#! /bin/bash
/usr/bin/dehydrated -c
</file>

Puis on le rend exécutable :

<code>chmod +x /etc/cron.weekly/acme-renew</code>

==== Configuration web sur Bastion ====

Créer le dossier des logs Nginx :
<code>
mkdir /var/log/nginx/mumble.chapril.org/
</code>

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.

<code>
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;
    }
}
</code>
==== Installation code et build ====

Installation de ''npm'' :
<code>
apt-get install npm

Oui, ça installe 251 paquets node-*…
</code>

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

==== Déploiement ====

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

Créer la branche officielle :
<code>
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"
</code>

Créer la branche Chapril :
<code>
cd /var/www/mumble.chapril.org/
git branch chapril-9945bc5f7
git checkout chapril-9945bc5f7
</code>

Paramétrer le fichier ''/var/www/mumble.chapril.org/config.local.js'' :
<code>
echo "config.settings.address     = 'mumble.chapril.org/ws';" >> config.local.js
git add -p
git commit -m "First settings."
</code>

==== Installation de websockify ====

Installation de websockify :
<code>
apt install websockify
</code>

Configuration systemd :
<code>
[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
</code>

Activation :
<code>
systemctl daemon-reload
systemctl start mumble-web
systemctl enable mumble-web
</code>
==== Configuration du Nginx allo ====

Créer les fichiers Nginx :
<code>
touch /etc/nginx/sites-available/mumble.chapril.org
ln -s /etc/nginx/sites-available/mumble.chapril.org etc/nginx/sites-enabled/
</code>

Remplir le fichier :
<code>
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;
}
</code>

==== Personnalisation : la boite de dialogue ====
Éditer le fichier ''/var/www/mumble.chapril.org/config.local.js'' :
<code>
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;
</code>



==== 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'' :
<code>
TODO
</code>
==== Procédure de mise à jour ====

Les fichiers de Mumble-web sont statiques.

Builder les fichiers :
<code>
cd /srv/mumble.chapril.org/mumble-web
git fetch --all 
npm install
npm run build
</code>

Désactiver mumble-web :
<code>
rm /etc/nginx/sites-enabled/mumble.chapril.org
systemctrl restart nginx
</code>

Intégrer la nouvelle version :
<code>
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
</code>

Ré-activer mumble-web :
<code>
ln -s /etc/nginx/sites-available/mumble.chapril.org /etc/nginx/sites-enabled/
systemctrl restart nginx
</code>