Table of Contents

Self-hosting for teams - 1 - ZE tuto (docker)

Lexique

TODO :

New:

DOCUWIKI les groupes d'utilisateurs et la gestion des autorisations :

NEXTCLOUD :

MATTERMOST :

GOGS :

Côté système

Côté applications

Commandes de base

Sous-domaines

Avant l'installation, vous devez choisir à quel url (domaine ou sous-domaine) chaque service sera accessible. Tant que le serveur ne sera pas déployé, vous pouvez configurer un fichier hosts pour rediriger ces url (qui ne sont pas encore actives, et reliées à un éventuel nom de domaine) à l'ip du serveur sur le réseau local.

Choisissez donc maintenant vos adresses pour chaque service :-) (par exemple cloud.fuz.re - wiki.fuz.re - forum.fuz.re, etc.)

Matériel

  1. Vorke V1 : Celeron J3160, RAM 4GO, SSD 64GO, emplacement pour disque 2.5”
  2. Disque dur HGST 7k1000 2.5“ et 7200 tours/min, 1TO
  3. Si nécessaire, boîter externe Inateck USB 3.0 FE2006 pour un disque dur 2.5” de backup
  4. Si nécessaire, boîtier externe Icy Box IB-RD2253-U31 USB 3.1 et raid pour deux disques durs 2.5“

Liste des services

Pour commencer

- Pour le Vorke V1, mettre le HDD de 1TO à l'intérieur

- Brancher le mini PC, le raccorder au réseau

Avant l'installation du système d'exploitation

On veut installer le système d'exploitation que va faire tourner notre serveur de self hosting, Ubuntu Server, depuis une image mise sur une clef USB

- Télécharger l'iso Ubuntu Server (la version Long Term Support ou “LTS”). Toutes les versions ici

- Créer une clef USB bootable d'Ubuntu Server :

- Démarrer le serveur en y branchant écran, clavier et la clef USB

- Démarrer dans le “BIOS” : (en général : appuyer sur les touches F2, F7, F8, F9, F10, F11, F12 ou Suppr juste après avoir appuyé sur le bouton pour allumer l'ordinateur. Pour le Vorke V1, appuyer sur “Suppr” ou “F7” au démarrage)

- Dans l'onglet “Save and Exit”, choisir de booter en “override” depuis la clef USB ~~ ça marche en UEFI

- Le serveur redémarre sur la clef USB

- Sur l'écran d'accueil de la clef, choisir “Install Ubuntu Server”

Installation d'Ubuntu Server

- 1/11 - Choisir la langue “Français”

- 2/11 - Ecran “Configuration clavier”, suivre la procédure de détection automatique de l'agencement du clavier

- 3/11 - Choisir “Installer Ubuntu”

- 4/11 - L'installeur passe à l'écran “Configuration du réseau”, par défaut par DHCP, vous *devez* être connecté-e à internet.

- 5/11 - Pas de proxy

- 6/11 - Miroir de dépôts

- 7/11 - Partionnement

- 9/11 - L'installeur demande le nom de la machine, le nom d'utilisateur et le nom du compte utilisateur et son mot de passe

- 10/11 - L'installation de “snaps” facilite notre travail, sélectionnez docker puis selon vos besoin nextcloud et wekan

- 11/11 - L'installation est finie ! Sélectionnez “Rédémarrer”, le serveur va s'arrêter et vous demander de retirer la clé puis appuyer sur ENTRÉE.

Après l'installation

- Par sécurité “sudo apt update” puis “sudo apt upgrade”, pour partir sur une base entièrement à jour !

- Vérifier que la partition du disque de data a été créée et qu'elle peut être montée :

- Ensuite exécuter “ifconfig” pour avoir l'adresse ip du serveur, notez là quelque part pour l'avoir toujours sous la main

Préparation du fichier hosts pour la redirection

Comme précisé au départ, cette section vous permet de rediriger, sur votre machine perso, vers l'ip du serveur tant que les domaines et sous-domaines de chaque service ne sont pas encore actifs.

Sur Linux, allez éditer, sur votre machine : 

sudo nano /etc/hosts

Sur Windows, le fichier est à l'adresse C:\Windows\System32\drivers\etc\hosts

Et ajouter ces lignes à la fin (en fonction des services que vous installez) 

IP_DU_SERVEUR URL_DE_NEXTCLOUD
IP_DU_SERVEUR URL_DE_WEKAN
IP_DU_SERVEUR URL_DE_GOGS
IP_DU_SERVEUR URL_DE_DOKUWIKI
IP_DU_SERVEUR URL_DE_LIMESURVEY
IP_DU_SERVEUR URL_DE_FLARUM
IP_DU_SERVEUR URL_DE_MATTERMOST
IP_DU_SERVEUR URL_DE_ODOO

Concrètement ça pourra donner 

99.54.127.142 cloud.fuz.re

Installation du serveur web Nginx en SSH

- A partir de là, nous n'utiliserons plus d'écran et de clavier branché directement à notre serveur, nous allons tout faire en SSH depuis une autre machine

- Depuis un client SSH (putty ou terminal linux, port 22) sur une machine du réseau local, taper 

ssh NOM_UTILISATEUR@IP_DE_LA_MACHINE

- Taper le mot de passe

- Remettre à jour l'index des paquets puis installer nginx: 

sudo apt update
sudo apt install nginx

Configuration générale du serveur web Nginx (temporaire)

Cette partie en gras correspond à la création d'un certificat SSL temporaire, tant que l'on n'a pas atteint la section “Let's encrypt” du tuto, dans laquelle on générera les véritables certificats SSL. Il faut la refaire à chaque démarrage du serveur : 
openssl req -subj "/CN=*.domaine.org" -newkey rsa:2048 -nodes -keyout domain.key -x509 -days 365 -out domain.crt


En remplaçant ”.domaine.org“ par votre domaine principal
Une fois ces certificats obtenus, il faut éditer la configuration générale de Nginx, ouvrez le fichier /etc/nginx/nginx.conf

sudo nano /etc/nginx/nginx.conf


et ajoutez ces 3 lignes à la fin du bloc http, après la section Virtual Host Configs :

	# Custom
	ssl_certificate /tmp/domain.crt;
	ssl_certificate_key /tmp/domain.key;


et copier les fichiers générés dans /tmp/

   sudo cp domain* /tmp/


Pour prendre le changement en compte, rechargez la configuration de Nginx:

sudo systemctl reload nginx

Configurer le snap de Nextcloud et Nginx

Effectuez ces opérations avant d'avoir testé Nextcloud et créé l'administrateur !

Création des dossiers pour les apps et les data de Nextcloud sur le disque dur interne: 

sudo mkdir -p /media/DATA/nextcloud/data /media/DATA/nextcloud/apps

Configuration de Nextcloud, éditez le fichier autoconfig.php 

nano /var/snap/nextcloud/current/nextcloud/config/autoconfig.php

à la ligne “directory”, entrez par exemple '/media/DATA/nextcloud/data' : 

'directory' => '/media/DATA/nextcloud/data/' ,

et dans le fichier config.php 

nano /var/snap/nextcloud/current/nextcloud/config/config.php

à la ligne des apps installées par les utilisateurs, mettre par ex /media/DATA/nextcloud/apps/ 

'path'=> '/media/DATA/nextcloud/apps/' ,

Redémarrez le service : 

sudo snap restart nextcloud.php-fpm

Source: https://github.com/nextcloud/nextcloud-snap/wiki/Change-data-directory-to-use-another-disk-partition

Activez l'accès au stockage externe pour Nextcloud (pour pouvoir écrire dans /media/DATA) 

sudo snap connect nextcloud:removable-media

Configurer le port de nextcloud, par ex en 10080 : 

sudo snap set nextcloud ports.http=10080

Vous pouvez dès à présent vous connecter sur “http://URL_DE_NEXTCLOUD:10080” et créer l'utilisateur administrateur du Nextcloud.

Pour accepter d'autres noms de domaine (et utiliser notre url perso) et éviter que les redirections automatiques ne marchent pas. Attention : la première ligne ne prend que le nom de domaine complet (sans le protocole ni le port), la deuxième prend le nom de domaine avec le port : 

sudo nextcloud.occ config:system:set trusted_domains 2 --value=URL_DE_NEXTCLOUD
sudo nextcloud.occ config:system:set overwritehost --value="URL_DE_NEXTCLOUD"
sudo nextcloud.occ config:system:set overwriteprotocol --value="https"

Source : https://github.com/nextcloud/nextcloud-snap#configuration

Il faut créer un fichier de configuration spécifique pour Nextcloud, voici celui proposé par la doc du snap de nextcloud, dans lequel nous avons ajouté deux lignes pour faire du logging spécifique à Nextcloud (pour garder une trace de ce qui a été fait avec le container Nextcloud). Vous pouvez le créer avec “sudo vim /etc/nginx/sites-available/nextcloud” ou “sudo nano /etc/nginx/sites-available/nextcloud” par exemple : 

server {
        listen 1234 ssl;

        server_name URL_DE_NEXTCLOUD;

        access_log /var/log/nginx/nextcloud_access.log combined;
        error_log /var/log/nginx/nextcloud_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:10080;
        }
}

Pour activer le nouveau site (et le rendre accessible par le serveur web) il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/nextcloud /etc/nginx/sites-enabled/nextcloud
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/nextcloud” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Pour tester, accéder à https://URL_DE_NEXTCLOUD:1234

Attention, Nextcloud vous demandera peut être d'ajouter cette IP à la liste des “trusted domains”, c'est une fonction de sécurité qui permet à Nextcloud de contrôler l'accès depuis l'extérieur.

Une fois que vous voyez la page de login de Nextcloud, l'installation a réussi !

Configurer le snap de Wekan et Nginx

Pour la fiabilité de notre setup, nous allons modifier la configuration du snap de Wekan pour placer la base de donnée sur la partition de DATA. Dans les commandes ci-dessous, entrez dans la dernière l'url de Wekan et le port que vous avez choisi pour le serveur Nginx. 

sudo mkdir -p /media/DATA/wekan/db
docker pull mongo
docker run --name wekan-mongo -p 17017:27017 --restart always -v /media/DATA/wekan/db:/data/db -d mongo
sudo snap stop wekan
sudo snap set wekan disable-mongodb='true'
sudo snap set wekan mongodb-bind-ip='127.0.0.1'
sudo snap set wekan mongodb-port='17017'
sudo snap set wekan mongodb-bind-unix-socket='nill'
sudo snap set wekan root-url="https://URL_DE_WEKAN:PORT"
sudo snap start wekan

Le premier utilisateur que vous créerez sera l'administrateur !

Pour la configuration nginx, attention le port de la ligne proxy_pass est ici “8080”

- “sudo nano /etc/nginx/sites-available/wekan” 

server {
        listen 1234 ssl;

        server_name URL_DE_WEKAN;

        access_log /var/log/nginx/wekan_access.log combined;
        error_log /var/log/nginx/wekan_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:8080;
        }
}

Pour activer le nouveau site il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/wekan /etc/nginx/sites-enabled/wekan
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/wekan” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que la base de donnée de wekan tourne. Sinon faire “docker start wekan-mongo”

Pour tester, accéder à https://URL_DE_WEKAN:1234/

Créer un groupe utilisateur pour Docker

- D'après la page Post-installation steps for Linux 

sudo groupadd docker
sudo usermod -aG docker $USER

- Et redémarrer le serveur 

sudo reboot

Installer Gogs dans Docker

- Nous sommes partis du tutoriel d'installation de gogs dans un container Docker

- AVEC QUELQUES ADAPTATIONS par rapport à notre setup 

docker pull gogs/gogs
docker run --name=gogs -d -p 10022:22 -p 11080:3000 -v /media/DATA/gogs:/data gogs/gogs
docker start gogs

Configurer Gogs

- SQLite3

- Donner un nom à l'application

- Dans “Url de l'application”, mettre URL_DE_GOGS, précédé de https:// et avec le port.

- Dans “Domaine”, mettre URL_DE_GOGS, (uniquement le nom de domaine) à la place de localhost (changeable plus tard dans le volume /media/DATA/gogs/gogs/conf/app.ini)

- Dans “Paramètres du serveur et des autres services”, sélectionner “Désactiver le formulaire d'inscription” et “Exiger l'identification pour afficher les pages”

- Ajouter les login et mot de passe du compte administrateur

- Cliquer sur “installer gogs”

- “docker stop gogs”, “docker start gogs” pour qu'il prenne en compte la configuration

Configurer Nginx pour Gogs

Idem que pour Nextcloud

- “sudo nano /etc/nginx/sites-available/gogs” : 

server {
        listen 1234 ssl;
        server_name URL_DE_GOGS;

        access_log /var/log/nginx/gogs_access.log combined;
        error_log /var/log/nginx/gogs_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:11080;
        }
}

Pour activer le nouveau site (et le rendre accessible par le serveur web) il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/gogs /etc/nginx/sites-enabled/gogs
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/gogs” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que gogs tourne. Sinon faire “docker start gogs”

Pour tester, accéder à https://URL_DE_GOGS:1234/. A partir de cette page, on va pouvoir configurer gogs.

Installer Mattermost dans Docker

On va devoir construire l'image du container parce qu'il n'y a pas d'image prête à l'emploi

Il faut que docker-compose soit installé (mais il est installé par défaut avec docker. Il suffit de taper “docker-” dans le terminal et d'appuyer sur tab pour vérifier que docker-compose est proposé et donc installé)

Il y a un tutoriel d'installation de Mattermost dans un container Docker, mais nous reprenons les étapes avec les particularités de notre setup

- Créer un dossier spécifique pour mattermost : “mkdir mattermost”

- Aller dans ce dossier : “cd mattermost”

- Exécuter “git clone https://github.com/mattermost/mattermost-docker.git”

- Aller dans le dossier mattermost-docker : “cd mattermost-docker”

- Éditer le fichier de config pour docker-compose : “nano docker-compose.yml” 

- ./volumes/ET_LA_SUITE_DU_PATH

en 

- /media/DATA/mattermost/ET_LA_SUITE_DU_PATH
args:
         - edition=team
         - PUID=1000
         - PGID=1000
    - "12080:80"
    - "12443:443"
ARG edition=team
ARG PUID=1000
ARG PGID=1000

- Les commandes sont à modifier légèrement: 

  docker-compose build
  sudo mkdir -pv /media/DATA/mattermost/app/mattermost/{data,logs,config,plugins}
  sudo chown -R 1000:1000 /media/DATA/mattermost/app/mattermost/
  sudo mkdir -p /media/DATA/mattermost/db/var/lib/postgresql/data
  sudo mkdir -p /media/DATA/mattermost/web/cert
  docker-compose up -d

- Exécuter “docker ps” pour être sûr que mattermost tourne. Sinon faire “docker-compose start”

- On peut maintenant s'y connecter avec “http://URL_DE_MATTERMOST:12080/” qui redirigera vers la page d'inscription de votre utilisateur administrateur

- Après avoir créé votre compte administrateur, dans la section “System console > Settings > General > Configuration” mettre URL_DE_MATTERMOST (précédé de https://)

TODO: Configurer Mattermost

(vous pouvez sauter cette étape pour le moment)

- Exemple pour un nom de domaine chez Gandi:

Après avoir crée un compte, dans la “system console”, dans la section “notifications”

Activer les notifications par email

“Notifications from address” : adresse que l'on veut utiliser (ou pas! on peut mettre n'importe quoi, #vivelegameçonage)

“SMTP Server Username” : adresse mail complète truc@example.com (celle ci doit vraiment exister!)

“SMTP Server Password” : mot de passe de l'adresse mail, telle qu'utilisé pour se connecter à un webmail par exemple

“SMTP Server” : mail.gandi.net

“SMTP Server Port” : 465

“Connection security” : TLS

TODO: Configurer Nginx pour Mattermost

Idem que pour Nextcloud

- “sudo nano /etc/nginx/sites-available/mattermost” : 

upstream backend {
   server localhost:12080;
   keepalive 32;
}

proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=mattermost_cache:10m max_size=3g inactive=120m use_temp_path=off;

server {
   listen 1234 ssl;
   server_name    URL_DE_MATTERMOST;

   location ~ /api/v[0-9]+/(users/)?websocket$ {
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection "upgrade";
       client_max_body_size 50M;
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       client_body_timeout 60;
       send_timeout 300;
       lingering_timeout 5;
       proxy_connect_timeout 90;
       proxy_send_timeout 300;
       proxy_read_timeout 90s;
       proxy_pass http://backend;
   }

   location / {
       client_max_body_size 50M;
       proxy_set_header Connection "";
       proxy_set_header Host $http_host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header X-Frame-Options SAMEORIGIN;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       proxy_read_timeout 600s;
       proxy_cache mattermost_cache;
       proxy_cache_revalidate on;
       proxy_cache_min_uses 2;
       proxy_cache_use_stale timeout;
       proxy_cache_lock on;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }
}

Pour activer le nouveau site il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/mattermost /etc/nginx/sites-enabled/mattermost
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/mattermost” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que mattermost tourne. Sinon faire “docker start mattermost”

Pour tester, accéder à https://URL_DE_MATTERMOST:1234/

Installer Dokuwiki (avec Bootstrap) dans Docker

On veut installer Dokuwiki avec Bootstrap, parce que Dokuwiki tout seul, c'est monstrueusement moche (on avait du mal avec l'idée de n'afficher le contenu d'un wiki que sur un tiers des écrans full HD de nos laptops actuels, avec du blanc tout autour pour décorer… Beurk…)

N'oubliez pas de changer les username, password et nom de wiki par les valeurs que vous voulez (mais vous pouvez mettre un mot de passe temporaire, qui sera simple à modifier une foir logué dans dokuwiki) 

docker pull bitnami/dokuwiki
docker run -d -p 14080:80 -p 14043:443 -e DOKUWIKI_USERNAME=user -e DOKUWIKI_PASSWORD=password -e DOKUWIKI_WIKI_NAME="Wiki Name" --name dokuwiki --volume /media/DATA/dokuwiki:/bitnami bitnami/dokuwiki:latest

Les variables d'environnement servent à paramétrer l'utilisateur administrateur et son mot de passe ainsi que le nom du wiki.

Connecter vous au wiki pour la fin de la configuration : http://ADRESSE_IP_DU_SERVEUR:14080/

Maintenant vous pouvez aller dans la configuration, en cliquant sur l'icône de bonhomme en haut à droite, puis en cliquant sur “admin” puis “Configuration Settings”, pour remplir le champ baseurl avec https://URL_DE_DOKUWIKI:1234

Configurer Dokuwiki

Par défaut votre wiki n'accepte pas les enregistrements de nouveaux utilisateurs.

- Pour installer bootstrap :

- Pour activer Bootstrap :

- Pour choisir le thème de Bootswatch.com

- Exécuter les commandes suivantes dans le terminal :

Grâce à la commande commit, les changements ont été conservés, puis le container stoppé puis redémarré et vous verrez votre template, options conservées !

TODO : Configurer Nginx pour Dokuwiki

Idem que pour Nextcloud

- “sudo nano /etc/nginx/sites-available/dokuwiki” : 

server {
        listen 1234 ssl;

        server_name URL_DE_DOKUWIKI;

        access_log /var/log/nginx/nextcloud_access.log combined;
        error_log /var/log/nginx/nextcloud_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:14080;
        }
}

Pour activer le nouveau site il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/dokuwiki /etc/nginx/sites-enabled/dokuwiki
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/dokuwiki” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que dokuwiki tourne. Sinon faire “docker start dokuwiki”

Pour tester, accéder à https://URL_DE_DOKUWIKI:1234/

Installer Flarum dans Docker

FIXME (08/03/2019) Ce qui suit est temporaire et corrige un problème avec l'image de Flarum que nous utilisons, en attendant une éventuelle correction par les développeurs.

- Créer un dossier spécifique pour flarum : “mkdir flarum”

- Aller dans ce dossier : “cd flarum”

- Exécuter “git clone https://github.com/mondediefr/docker-flarum”

- Aller dans le dossier docker-flarum : “cd docker-flarum”

- Éditer le fichier Dockerfile qui se trouve dans ce dossier : “nano Dockerfile” et ajouter une ligne après la ligne “COPY rootfs /” (ligne 51) : 

COPY --chown=991:991 rootfs/flarum /flarum"

- Construire l'image : “docker build -t flarum .”

- Créer les dossiers pour les données de flarum : 

sudo mkdir -p /media/DATA/flarum/assets /media/DATA/flarum/extensions
sudo chmod -R 775 /media/DATA/flarum/assets /media/DATA/flarum/extensions
sudo chown -R 991:991 /media/DATA/flarum/assets

- Crée le fichier de config pour docker-compose : “nano docker-compose.yml”

Le fichier dont on s'inspire est ici mais on l'adapte et finalement voilà ce qu'on met dans le fichier : 

version: "3"

services:
    flarum:
      image: flarum
      container_name: flarum
      ports:
        - "15080:8888"
      environment:
        - FORUM_URL=URL_DE_FLARUM:15080
        - DB_PASS=password
        - FLARUM_ADMIN_USER=admin
        - FLARUM_ADMIN_PASS=password
        - FLARUM_ADMIN_MAIL=email@example.com
        - FLARUM_TITLE=Titre du forum
      volumes:
        - /media/DATA/flarum/assets:/flarum/app/public/assets
        - /media/DATA/flarum/extensions:/flarum/app/extensions
        - /media/DATA/flarum/nginx:/etc/nginx/conf.d
      depends_on:
        - mariadb

    mariadb:
      image: mariadb:10.2
      container_name: flarum-mariadb
      volumes:
        - /media/DATA/flarum_mariadb/mysql/db:/var/lib/mysql
      environment:
        - MYSQL_ROOT_PASSWORD=rootpassword
        - MYSQL_DATABASE=flarum
        - MYSQL_USER=flarum
        - MYSQL_PASSWORD=password

Flarum a tendance à faire sa connexion à la db avant que celle-ci ne soit entièrement prête, on sépare en deux commandes : “docker-compose up -d mariadb”, attendre une dizaine de secondes pour lui laisser le temps, laisser reposer la pâte, pendant ce temps dessiner des pentacles au plafond (au posca rouge et dans le sens anti-trigo de préférence). Finalement exécuter la commande : “docker-compose up -d”

TODO: Configurer Nginx pour Flarum

Idem que pour Nextcloud

- “sudo nano /etc/nginx/sites-available/flarum” : 

server {
        listen 1234 ssl;

        server_name URL_DE_FLARUM;

        access_log /var/log/nginx/flarum_access.log combined;
        error_log /var/log/nginx/flarum_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:15080;
        }
}

Pour activer le nouveau site il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/flarum /etc/nginx/sites-enabled/flarum
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/flarum” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que flarum tourne. Sinon faire “docker start docker-flarum”

Pour tester, accéder à https://URL_DE_FLARUM:1234/

Installer Odoo dans Docker

Il y a une image officielle de Odoo pour docker (“Run Odoo with a custom configuration”) : https://hub.docker.com/_/odoo

Il faut télécharger cette image sur le serveur : 

docker pull odoo:12.0

À la manière des services précédents, créez un dossier odoo dans votre home et déplacez vous dans celui-ci : “cd” puis “mkdir odoo” puis “cd odoo”

Créez le fichier docker-compose: 

nano docker-compose.yml

. 

version: '2'
services:
  web:
    image: odoo:12.0
    depends_on:
      - db
    ports:
      - "16080:8069"
    volumes:
      - /media/DATA/odoo/web-data:/var/lib/odoo
      - /media/DATA/odoo/addons:/mnt/extra-addons
      - /media/DATA/odoo/config:/etc/odoo
    environment:
      - PASSWORD=password
  db:
    image: postgres:10
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_PASSWORD=password
      - POSTGRES_USER=odoo
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - /media/DATA/odoo/db-data:/var/lib/postgresql/data/pgdata

Pensez à changer le mot de passe (c'est bien le même les deux fois) !

Il faut créer deux dossiers et appliquer des permissions particulières : 

sudo mkdir -p /media/DATA/odoo/web-data /media/DATA/odoo/config/
sudo chmod -R 777 /media/DATA/odoo/web-data

Au cas où la configuration devrait être changée dans le futur, nous créons un volume dédié, il faut par conséquent créer le fichier de conf, et le remplir avec la configuration par défaut que vous trouverez ici: 

sudo nano /media/DATA/odoo/config/odoo.conf

Lancez le service avec 

docker-compose up -d

et testez en allant à l'adresse http://URL_DE_ODOO:16080

Sur la page qui s'affiche, entrez un nom de base de donnée de votre choix (sans rapport avec la configuration précédente), les champs suivants concernent le compte d'administrateur de votre instance d'Odoo. Une fois validé, la configuration est terminée, vous voilà devant le tableau de bord de Odoo.

Pour nous, l'idée c'est de faire de la gestion de BOM, de compta et de mailing (pour les kanbans et les todos on utilisera surtout Wekan si nécessaire, qui est quand même beaucoup plus light)

On installe : CRM, Site Web, Inventaire, Facturation, Comptabilité, Fabrication, Email Marketing, Événements

TODO: Configurer Nginx pour Odoo

Idem que pour Nextcloud

- “sudo nano /etc/nginx/sites-available/odoo” : 

server {
        listen 1234 ssl;

        server_name URL_DE_ODOO;

        access_log /var/log/nginx/odoo_access.log combined;
        error_log /var/log/nginx/odoo_error.log warn;

        location / {
                proxy_pass_header   Server;
                proxy_set_header    Host $host;
                proxy_set_header    X-Real-IP $remote_addr;
                proxy_set_header    X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header    X-Forwarded-Proto $scheme;
                proxy_pass          http://localhost:16080;
        }
}

Pour activer le nouveau site il faut créer un lieu symbolique et recharger la configuration de nginx: 

sudo ln -s /etc/nginx/sites-available/odoo /etc/nginx/sites-enabled/odoo
sudo systemctl reload nginx

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/odoo” et vérifier que ça ouvre bien le fichier qu'on a édité précédemment

Exécuter “docker ps” pour être sûr que odoo tourne. Sinon taper “docker-compose up -d” (depuis le dossier d'installation d'odoo)

Pour tester, accéder à https://URL_DE_ODOO:1234/

Si vous n'arrivez pas à vous connecter, il y a un bug étrange, ajoutez /web/login à la fin de l'URL, soit https://URL_DE_ODOO:1234/web/login

Démarrage automatique des services quand le serveur démarre

Parmi les containers qu'on a déployé, Mattermost est la seule à être par défaut en démarrage automatique (ça vient de sa config avec docker-compose). Les snaps démarrent aussi automatiquement (docker, nextcloud et wekan).

Pour le reste des applications, il faut leur spécifier de démarrer automatiquement quand le serveur démarre

On commence par créer et ouvrir le fichier de config du service (ici on fait l'exemple avec le service Gogs) 

sudo nano /etc/systemd/system/docker-gogs.service

On y copie le code suivant : 

[Unit]
Description=Gogs container
Requires=snap.docker.dockerd.service
After=snap.docker.dockerd.service

[Service]
Restart=always
ExecStart=/snap/bin/docker start -a gogs
ExecStop=/snap/bin/docker stop gogs

[Install]
WantedBy=default.target

(comme d'habitude, dans l'éditeur de texte Nano, on copie-colle avec le bouton droit de la souris, on enregistre avec ctrl+O, on valide, et ferme avec ctrl+X)

Dans ce fichier on a dit :

De même pour les autres services 

sudo nano /etc/systemd/system/docker-dokuwiki.service
[Unit]
Description=Dokuwiki container
Requires=snap.docker.dockerd.service
After=snap.docker.dockerd.service

[Service]
Restart=always
ExecStart=/snap/bin/docker start -a dokuwiki
ExecStop=/snap/bin/docker stop dokuwiki

[Install]
WantedBy=default.target
sudo nano /etc/systemd/system/docker-limesurvey.service
[Unit]
Description=Limesurvey container
Requires=snap.docker.dockerd.service
After=snap.docker.dockerd.service

[Service]
Restart=always
ExecStart=/snap/bin/docker start -a limesurvey
ExecStop=/snap/bin/docker stop limesurvey

[Install]
WantedBy=default.target

Et un cas particulier pour Flarum et Odoo, qui ont besoin d'avoir le path spécifié explicitement dans le fichier (ici il faudra donc remplacer VOTRE_NOM_D_UTILISATEUR par le path correct) 

sudo nano /etc/systemd/system/docker-flarum.service
[Unit]
Description=Flarum container
Requires=snap.docker.dockerd.service
After=snap.docker.dockerd.service

[Service]

WorkingDirectory=/home/VOTRE_NOM_D_UTILISATEUR/flarum/docker-flarum

Restart=always
ExecStart=/snap/bin/docker-compose up
ExecStop=/snap/bin/docker-compose down

[Install]
WantedBy=default.target
sudo nano /etc/systemd/system/docker-odoo.service
[Unit]
Description=Odoo container
Requires=snap.docker.dockerd.service
After=snap.docker.dockerd.service

[Service]

WorkingDirectory=/home/VOTRE_NOM_D_UTILISATEUR/odoo

Restart=always
ExecStart=/snap/bin/docker-compose up
ExecStop=/snap/bin/docker-compose down

[Install]
WantedBy=default.target

Pour activer le démarrage des services au démarrage de la machine 

sudo systemctl enable docker-gogs docker-dokuwiki docker-limesurvey docker-flarum docker-odoo

Étapes suivantes du wiki

Avant de passer à l'étape suivante, comme on va configurer le DNS avec votre nom de domaine et générer un vrai certificat SSL, vous pouvez supprimer les entrées qu'on avait mis dans le fichier hosts au début du tuto et redémarrer votre serveur (sudo reboot) pour supprimer le certificat SSL temporaire, on passe dans le monde réel :-)

2 - Configuration DNS

3 - SSL Let's encrypt

4 - Envoi d'e-mail

5 - Applications Nextcloud

6 - Sauvegarde chiffrée distante