TODO :

• Test backup croisé incrémental :
• Retester Collabora dans 1 mois ?

New:

• Vrai test de création d'utilisateurs : est-ce qu'on peut créer des groupes ? gérer les accès aux données ? est-ce qu'on peut inviter des gens extérieurs et ne partager qu'une partie avec eux ?
• changer mdptrub
• Mil Jérémy :
  • Arborescence de cette page : faire différents niveaux de titres pour clarifier et avoir une belle TOC
  • Indiquer quand le fichier hosts n'est plus nécessaire
  • Création de comptes et contrôle d'accés :
    • Wekan : TODO, voir si des kanbans séparés peuvent être visibles par groupe
    • Odoo : pas besoin, non ?
    • Flarum : TODO, accès limités à des forums ?
• Odoo : pour se connecter il faut taper URL:PORT/web/login, puis si ça timeout à la connexion, retaper URL:PORT/web . Pas mal de temps passé à essayer de comprendre et débuguer ça, problème connu du côté de Odoo, à fouiller et/ou reporter à nouveau auprès du projet.

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

• Depuis le compte admin TODO, cliquer sur l'icône bonhomme tout en haut à droite, puis admin, puis “extension manager”
• Vérifier que l'extension “ACL Manager by Andreas Gohr” est bien installée.
• Utilisateurs : C'est l'admin qui crée les nouveaux utilisateurs et les groupes d'utilisateurs, depuis la Page Admin → User Manager. Si un nouvel utilisateur est ajouté à un groupe qui n'existe pas encore, le groupe est créé à la volée
• Namespaces : Les namespaces sont des regroupements de page, comme des dossiers. Tout est expliqué dans la doc dokuwiki
• Et finalement, on peut aller dans le “Access Control List Management”, également depuis le menu admin, pour attribuer à chaque utilisateur et chaque liste les droits sur les pages et les namespaces
• NB : ici un rappel de la syntaxe dokuwiki

NEXTCLOUD :

• Depuis le compte admin, icône en haut à droite, “utilisateurs”
• A partir de là on crée des utilisateurs et des groupes d'utilisateurs
• Ensuite, chaque dossier et chaque fichier peut être partagé avec un groupe ou un utilisateur
• Une fois qu'un dossier ou document a été partagé, on peut cliquer sur l'icône de partage pour gérer les permissions de chaque groupe ou utilisateur avec qui le dossier/document a été partagé

MATTERMOST :

• A la première connexion sur Mattermost, on propose à l'admin de créer une “team” sur le serveur
• Sur un serveur, il y aura plusieurs “teams”, et dans chaque “teams”, plusieurs utilisateurs qui discuteront dans des “channels publics” (accessibles à tous) et dans des “channels privés”, où l'utilisateur qui a crée le channel invitera explicitement tous les utilisateurs avec qui il veut échanger
• Un utilisateur invité à une team ne saura même pas que d'autres teams existent sur le serveur
• Pour ajouter un utilisateur au serveur, on va dans la team dans laquelle on voudrait l'avoir, et dans le menu tout en haut à gauche à côté de l'icône du nom du compte, on trouve “manage members”, où on peut changer les privilèges d'un utilisateur ou supprimer un utilisateur
• Pour réellement supprimer le compte utilisateur du serveur, dans le même menu mais depuis le compte admin on trouve “system console”. Et dans l'onglet “user”, on peut supprimer un compte utilisateur avec les options “revoke sessions” et “deactivate”.

GOGS :

• C'est l'admin qui crée les utilisateurs, en allant dans “administration” puis “utilisateurs”
• Quand on crée un dépôt, on peut choisir s'il est public (visible par tout le monde à son url) ou privé
• Pour partager un dépôt avec d'autres utilisateurs, on va dans le dépôt, puis dans paramètres, puis collaboration, et on peut ajouter un utilisateur créé précédemment sur le serveur
• Dans les paramètres du dépôt, tout en bas, on peut le supprimer

Côté système

• Cron : Job scheduler d'Unix
• Rsync : Outil de synchro et copie de fichiers, utilisé pour backup distant

Côté applications

• Docker : Packager d'applications

Commandes de base

• “docker ps” pour savoir quels services tournent
• “docker run” pour créer une container (une fois pour toutes, quand on installe le container)
• “docker start NOM_DU_SERVICE” pour démarrer une container
• Vous pouvez à tout moment nettoyer votre historique de bash en tapant “nano ~/.bash_history” et en supprimant tout le contenu du fichier

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

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“

• Snap : Nextcloud — Docker — Wekan

• Containers : Gogs — Dokuwiki

• Multi-containers (docker compose) : Flarum — Mattermost — Odoo

• Applications Nextcloud (cf ce tuto) : Notes — Calendar — Mind Map — Tasks — Contacts — Collabora

• codimd ? garradin ? libreERP plutôt que odoo ? CryptPad ? CodiMD ?

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

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

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 :

• Sur Windows : utiliser Rufus, tutoriel dispo ici
• Sur Linux : utiliser le programme DD en ligne de commande, tutoriel dispo ici

- 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”

- 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

• Choisir le partitionnement “Manuel”

• Choisir le disque sur lequel installer le système (on reconnait le SSD interne à sa taille), et appuyer sur entrée en sélectionnant la ligne qui correspond au bon disque
• Choisir “Add Partition” puis laisser la ligne “Size” vide, format ext4 et Mount à /

• Pour le disque de data (dans notre cas, le HDD de 1TO qui est branché en SATA à l'intérieur du Vorke v1),
• Choisir “Add partition”, laisser la ligne “Size” vide, format ext4, mais choisir “autre” pour la ligne “Mount” et entrer ”/media/DATA“ manuellement.

• Sélectionner “Terminé” puis confirmer.

• A partir de maintenant, la seule partition du disque de 1TO est accessible à /media/DATA

• L'installation commence en tâche de fond.

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

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

• Pour vérifier qu'il y a une partition “ls /dev/sda*”
• Pour vérifier qu'elle est montable “sudo mount /dev/sda1 /media/DATA” (le terminal doit répondre qu'elle est déjà montée)
• Si elle est pas montable, c'est qu'elle est créée mais pas formatée alors il faut exécuter la commande suivante : “sudo mkfs.ext4 /dev/sda1”

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

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

- 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

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

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 !

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/

- 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

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

- AVEC QUELQUES ADAPTATIONS par rapport à notre setup

• Installer Gogs pour Docker

docker pull gogs/gogs

• Lancer le container en pointant le stockage vers le dossier adapté (sur le disque de 1TO dans notre cas, et on rajoute -d pour lancer le container en “détâché” / tâche de fond) :

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

• Lancer docker

docker start 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

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.

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”

• Changer tous les débuts de path (il y en a 7 en tout, mais ça peut changer suivant les version) qui sont

- ./volumes/ET_LA_SUITE_DU_PATH

en

- /media/DATA/mattermost/ET_LA_SUITE_DU_PATH

• Dans ce fichier, décommenter les lignes suivantes :

args:
         - edition=team
         - PUID=1000
         - PGID=1000

• Puis changer les ports du serveur, http et https (deux lignes) :

    - "12080:80"
    - "12443:443"

• Faire de même dans le fichier app/Dockerfile avec “nano app/Dockerfile”

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://)

(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

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/

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

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

- Pour installer bootstrap :

• Loggez vous en admin

• Naviguer dans le menu : Admin > Extension manager > onglet “Search and Install”

• Chercher “bootstrap”. Le bon est le second de la liste: “Bootstrap3 Template by Giuseppe Di Terlizzi”, cliquez sur “install” à droite, l'opération prend quelques instants, le temps de le télécharger puis dokuwiki vous affiche un message de succès.

- Pour activer Bootstrap :

• Recharger la page pour que les changements soient pris en compte

• Naviguer dans le menu : Admin > Configuration settings

• Dans le tableau, à ligne “template”, sélectionnez “bootstrap3” dans le menu déroulant

• Cliquez sur Save en bas de la page, wala!

- Pour choisir le thème de Bootswatch.com

• Naviguer dans le menu : Admin > Configuration settings
• Dans la section “bootstrapTheme” choisir “Bootswatch.com theme”
• Dans la section “bootswatchTheme” choisir thème de Bootswatch à utiliser, lumen est plutôt cool sisi tkt oklm

- Exécuter les commandes suivantes dans le terminal :

• docker commit dokuwiki
• docker stop dokuwiki
• docker start dokuwiki

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 !

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/

(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

• Il y a deux mots de passe à fournir : “MYSQL_PASSWORD” est le même que “DB_PASS”, et le deuxième mot de passe est MYSQL_ROOT_PASSWORD (des passwords pas trop compliqués parce que ça n'a pas l'air de passer)

• On a modifié “container_name” de la db pour ne pas utiliser de nom générique pour le container

• 15080 est le port qu'il faudra utiliser dans la ligne “proxy_pass” du fichier nginx

• Et surtout, les chemin des volumes ont été modifiés pour qu'ils soient situés sur le disque de 1TO

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”

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/

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

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

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 démarrer le container de Gogs
• de le faire après que Docker ait démarré (attributs “requires” et “after”)

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

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