Outils pour utilisateurs

Outils du site


Panneau latéral

Website
Gitlab
Twitter
Salon IRC

selfhostingforteams

Lexique

Côté système

Côté applications

Commandes de base

  • “docker ps” pour savoir quels services tournent
  • “docker run” pour créer une container (une fois pour toute, quand on installe le container)
  • “docker start NOM_DU_SERVICE” pour démarrer une container

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“

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 :

  • 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

- Le serveur redémarre sur la clef USB

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

Installation d'Ubuntu Server

- Choisir la langue “French” et le territoire “France”

- Ecran “Configurer le clavier”, suivre la procédure de détection automatique de l'agencement du clavier

- L'installeur passe à l'écran “Chargement des modules supplémentaires”

- L'installeur passe à l'écran “Configuration du réseau avec DHCP”

- L'installeur demande le nom de la machine, le nom d'utilisateur et le nom du compte utilisateur

- Ne pas activer le chiffrement

- Configurer l'horloge (détection automatique par le réseau)

- Partionnement

  • A l'écran “Partitionner les disques”, choisir “oui” pour lui demander de démonter les partitions en cours d'utilisation, et choisir le partitionnement “Manuel”
  1. 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 “SCSI” qui correspond au bon disque
  2. A la question “faut-il créer une table de partitions ?” répondre “oui”
  3. Sélectionner l'espace non alloué et choisir “partitionner automatiquement l'espace disponible”
  1. Pour le disque de data (dans notre cas, le HDD de 1TO qui est branché en SATA à l'intérieur du Vorke v1), créer une table de partition
  2. Sélectionner l'espace libre et appuyer sur “Entrée”
  3. “Créer une nouvelle partition”
  4. “Nom de la partition” : DATA
  5. Choisir le point de montage de cette partition : rentrer manuellement ”/mtn/DATA“
  6. Changer le label (étiquette) : “DATA”
  7. Choisir “Fin du paramétrage de cette partition”
  • “Terminer le partitionnement et appliquer les changements” et confirmer
  • A partir de maintenant, la seule partition du disque de 1TO est accessible à /mnt/DATA

- L'installeur installe le système

- Ne pas configurer l'outil de gestion des paquets

- A l'écran “Configuration de tasksel”, choisir “Pas de mise à jour automatique”

- A l'écran “Sélection des logiciels”, ajouter “OpenSSH server” (appuyer sur ESPACE avec le curseur sur la ligne “OpenSSH server”)

- A la fin de l'installation enlever la clef USB et appuyer sur entrée

Après l'installation

- “sudo apt-get update”

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

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 serveur 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-get update
sudo apt-get install nginx

Installer Docker

- Suivre le tuto d'installation de docker

  • Suivre les parties “Prerequisites”
  • puis “Prerequisites by Ubuntu version”
  • puis “Install the lastest version”,
  • puis dans la partie “Optional Configuration” ne suivre que les instructions de la sous-partie “Manage Docker as a non-root user”

- Ajouter Docker Compose :

  • se logger en super user “sudo su”
  • copier-coller la commande curl accessible depuis cette page
  • copier-coller la ligne “chmod”
  • taper “exit” pour quitter le mode super user

Installer Nextcloud dans Docker

  • LIRE TOUS LES POINTS DE CETTE PARTIE AVANT DE COMMENCER
  • Suivre les instructions d'installation depuis la page de Nextcloud sur le store de Docker.
  • Les commandes à exécuter sont la commande “docker pull…” puis les deux suivantes “docker run…”.
  1. Il y aura trois mots de passe à trouver : “MYSQL_ROOT_PASSWORD” (jamais utilisé), “MYSQL_PASSWORD” (peut être le même que MYSQL_ROOT_PASSWORD) et “ADMIN_PASSWORD” (le mot de passe admin du nextcloud, donc très important)
  2. Attention : pour la seconde commande (“docker run…”), ajouter l'argument ”-p 8888:8888“ après ”–name“ pour que le container soit accessible directement depuis localhost.
  3. NB : Si vous utilisez un mot de passe avec des signes de ponctuations, précédez chaque signe de ponctuation d'un antislash = “\”
  4. Changer les commandes données dans le tuto de nextcloud pour pointer le stockage de nextcloud et de sa base de données vers notre partition sur le disque de 1TO (/mnt/DATA)
       -v /mnt/DATA/nextcloud/db:/var/lib/mysql \
       -v /mnt/DATA/nextcloud/data:/data \
       -v /mnt/DATA/nextcloud/config:/config \
       -v /mnt/DATA/nextcloud/apps:/apps2 \

Configurer Nginx pour Nextcloud

Il faut créer un fichier de configuration spécifique pour Nextcloud, en voici un simplifié mais fonctionnel, 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 80;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/nextcloud_access.log combined;
  error_log /var/log/nginx/nextcloud_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:8888;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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/nextcloud /etc/nginx/sites-enabled/nextcloud
sudo service nginx reload

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

Exécuter “docker ps” pour être sûr que “nextcloud” et “nexcloud_db” tournent. Sinon faire “docker start nexcloud_db” puis “docker start nexcloud”

Pour tester, accéder à http://NOM_DE_DOMAINE_OU_IP:80

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 !

Connectez vous avec les identifiants fournis dans “ADMIN_USER” et “ADMIN_PASSWORD” lors de la création du container Nextcloud .

Installer Gogs dans Docker

- Suivre le tutoriel d'installation de gogs dans un container Docker

- AVEC QUELQUES ADAPTATIONS par rapport à notre setup

  • Créer le dossier pour stocker les fichiers du Gogs sur le disque de 1TO :
mkdir /mnt/DATA/gogs
  • Pointer le stockage vers le bon dossier (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 10080:3000 -v /mnt/DATA/gogs:/data gogs/gogs

Configurer Nginx pour Gogs

Idem que pour Nextcloud

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

server {
  listen 3000;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/gogs_access.log combined;
  error_log /var/log/nginx/gogs_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:10080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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/gogs /etc/nginx/sites-enabled/gogs
sudo service nginx reload

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 à http://NOM_DE_DOMAINE_OU_IP:3000/

Configurer Gogs

- SQLite3

- Donner un nom à l'application

- Mettre l'IP du serveur dans “domaine” et “url de l'application” à la place de localhost

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

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

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é (voir plus haut)

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 -b team-and-enterprise”

- 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 4 en tout) qui sont
- ./volumes/ET_LA_SUITE_DU_PATH

en

- /mnt/DATA/mattermost/ET_LA_SUITE_DU_PATH
  • Puis changer les ports du serveur, http et https (deux lignes) :
    - "11080:80"
    - "40443:443"

- Créer le dossier des données de mattermost sur le disque de 1TO : “sudo mkdir /mnt/DATA/mattermost”

- Maintenant on peut lancer le build : “docker-compose build” (ça peut durer un certain temps)

- On crée le container : “docker-compose up -d”

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

- On peut maintenant s'y connecter avec “http://NOM_DE_DOMAINE_OU_IP:11080/

Configurer Mattermost

- 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

Configurer Nginx pour Mattermost

Idem que pour Nextcloud

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

server {
  listen 3002;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/mattermost_access.log combined;
  error_log /var/log/nginx/mattermost_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:11080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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 service nginx reload

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 à http://NOM_DE_DOMAINE_OU_IP:3002/

Installer Kanboard dans Docker

On s'inspire des instructions disponibles ici

- Créer les dossiers pour les données de Kanboard sur le disque dur de 1TO

  • sudo mkdir -p /mnt/DATA/kanboard/data
  • sudo mkdir -p /mnt/DATA/kanboard/plugins

- Changer le propriétaire du dossier (utilisateur de Nginx à l'intérieur du container Kanboard “100”, groupe “101”). Chaque container crée des utilisateurs à sa création, dont un pour Nginx, et il faut que cet utilisateur soit propriétaire du dossier de stockage des données de Kanboard

  • sudo chown -R 100:101 /mnt/DATA/kanboard/

- On récupère Kanboard

  • docker pull kanboard/kanboard

- On lance le container

docker run -d --name kanboard -v /mnt/DATA/kanboard/data/:/var/www/app/data -v /mnt/DATA/kanboard/plugins/:/var/www/app/plugins -p 12080:80 -t kanboard/kanboard

- Les login et mot de passe par défaut sont admin / admin (pensez à les changer la première fois que vous vous logez pour créer des utilisateurs)

Configurer Nginx pour Kanboard

Idem que pour Nextcloud

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

server {
  listen 3003;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/kanboard_access.log combined;
  error_log /var/log/nginx/kanboard_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:12080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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/kanboard /etc/nginx/sites-enabled/kanboard
sudo service nginx reload

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/kanboard” 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 kanboard tourne. Sinon faire “docker start kanboard”

Pour tester, accéder à http://NOM_DE_DOMAINE_OU_IP:3003/

Installer Tiddlywiki dans Docker

La page du store Docker est ici : https://store.docker.com/community/images/mazzolino/tiddlywiki

docker pull mazzolino/tiddlywiki
sudo mkdir /mnt/DATA/tiddlywiki

Maintenant on n'a plus qu'à créer le container, ATTENTION, il faut spécifier le username et le password !

docker run -d -e USERNAME=LE_NOM_DE_L_ADMIN -e PASSWORD=LE_PASSWORD_DE_L_ADMIN -p 13080:8080 -v /mnt/DATA/tiddlywiki:/var/lib/tiddlywiki --name tiddlywiki mazzolino/tiddlywiki

Configurer Nginx pour Tiddlywiki

Idem que pour Nextcloud

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

server {
  listen 3004;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/tiddlywiki_access.log combined;
  error_log /var/log/nginx/tiddlywiki_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:13080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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/tiddlywiki /etc/nginx/sites-enabled/tiddlywiki
sudo service nginx reload

Pour être sûr que le lien a été correctement crée, exécuter : “sudo nano /etc/nginx/sites-enabled/tiddlywiki” 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 tiddlywiki tourne. Sinon faire “docker start tiddlywiki”

Pour tester, accéder à http://NOM_DE_DOMAINE_OU_IP:3004/

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

On récupère sur Github, on build, et on run en exécutant les commandes suivantes :

  • mkdir dokuwiki
  • cd dokuwiki
  • cd docker-dokuwiki/
  • docker build . -t dokuwiki-ssl
  • sudo mkdir -p /mnt/DATA/dokuwiki/
  • docker run -d -p 14080:80 –name dokuwiki dokuwiki-ssl

Pour continuer l'installation, il faut se connecter au service : http://ADRESSE_IP_DU_SERVEUR:14080/install.php

Configurer Dokuwiki

Pensez à mettre en wiki fermé si vous le souhaitez!

Voilà les commandes pour garder vos data même quand vous arrêtez le container

# create data container
docker run --volumes-from dokuwiki --name dokuwiki-data busybox

# now you can safely delete dokuwiki container
docker stop dokuwiki && docker rm dokuwiki

# to restore dokuwiki, create new dokuwiki container and attach dokuwiki-data volume to it
docker run -d -p 14080:80 --volumes-from dokuwiki-data --name dokuwiki dokuwiki-ssl

Voilà toutes les commandes nécessaires, mais si vous voulez plus d'infos, vous pouvez vous diriger vers la page Docker de Dokuwiki

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

  • 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 !

Configurer Nginx pour Dokuwiki

Idem que pour Nextcloud

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

server {
  listen 3005;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/dokuwiki_access.log combined;
  error_log /var/log/nginx/dokuwiki_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:14080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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 service nginx reload

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 à http://NOM_DE_DOMAINE_OU_IP:3005/

Installer Flarum dans Docker

Flarum s'installe avec docker-compose, il suffit de créer le fichier de config pour docker-compose

Pour faire propre, on crée un dossier réservé aux data de Flarum

cd
mkdir flarum
cd flarum
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 :

flarum:
  image: mondedie/docker-flarum
  container_name: flarum
  links:
    - mariadb:mariadb
  ports:
    - "15080:8888"
  environment:
    - FORUM_URL=http://IP_OU_NOM_DE_DOMAINE:15080
    - DB_PASS=XXXXXXXXXXXXXXXX
  volumes:
    - /mnt/DATA/flarum/assets:/flarum/app/assets
    - /mnt/DATA/flarum/extensions:/flarum/app/extensions

mariadb:
  image: mariadb:10.1
  container_name: flarum_mariadb
  volumes:
    - /mnt/DATA/flarum_mariadb/mysql/db:/var/lib/mysql
  environment:
    - MYSQL_ROOT_PASSWORD=XXXXXXXXXXXXXXXX
    - MYSQL_DATABASE=flarum
    - MYSQL_USER=flarum
    - MYSQL_PASSWORD=XXXXXXXXXXXXXXXX
  • 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
  • Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut
  • 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

Finalement exécuter la commande : “docker-compose up -d”

Configurer Flarum

Loggez-vous sur http://NOM_DE_DOMAINE_OU_IP:15080

MySQL Host : flarum_mariadb

MySQL Database : celui que vous avez mis dans MYSQL_DATABASE de mariadb (“flarum” par défaut dans le fichier de conf)

MySQL Username : celui que vous avez mis dans MYSQL_USER de mariadb (“flarum” par défaut dans le fichier de conf)

Pour les infos admins, créer un login et un mot de passe qui seront ceux de l'utilisateur root

ATTENTION SI VOTRE SERVEUR EST SUR VOTRE RÉSEAU LOCAL ET QUE VOUS UTILISEZ SON IP LOCAL POUR INSTALLER TOUS LES CONTAINERS (PLUTÔT QU'UN NOM DE DOMAINE)

Le problème est que la config de flarum est permanente et dépendante de l'IP qu'on lui a donné. Donc si vous n'êtes pas dans la configuration réseau finale de l'utilisation du serveur, et que vous avez donné l'IP local de votre serveur sur le réseau sur lequel vous suivez ce wiki, il y a un fichier de config PHP écrit en dur dans flarum, et qu'il faudra corriger :

  • docker exec -ti flarum vi /flarum/app/config.php
  • il est possible que flarum ait mis “localhost” à la place de votre IP locale ; dans ce cas tout part en live et même pour le temps d'un test et il faut mettre l'IP locale du serveur en dur : dans vi aller sur localhost, supprimer avec SUPPR, appuyer sur “i” pour rentrer en mode “insertion”, taper l'IP de votre serveur sur le réseau local, appuyer sur “échap” pour quitter le mode “insertion”, et taper ”:“ puis “wq” (write and quit) et appuyer sur entrée
  • docker commit flarum
  • docker stop flarum
  • docker start flarum

Configurer Nginx pour Flarum

Idem que pour Nextcloud

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

server {
  listen 3006;
  server_name NOM_DE_DOMAINE_OU_IP;
  
  access_log /var/log/nginx/flarum_access.log combined;
  error_log /var/log/nginx/flarum_error.log warn;

  # change this value it according to $UPLOAD_MAX_SIZE
  client_max_body_size 10G; 

  location / {
    proxy_pass http://localhost:15080;
  }
}

Il faut remplacer “NOM_DE_DOMAINE_OU_IP” par le nom de domaine ou l'IP du serveur trouvée plus haut.

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 service nginx reload

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 à http://NOM_DE_DOMAINE_OU_IP:3006/

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)

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=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a gogs
ExecStop=/usr/bin/docker stop -t 4 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”)

Ensuite, il suffit de copier ce fichier pour les autres containers :

  • sudo cp /etc/systemd/system/docker-gogs.service /etc/systemd/system/docker-kanboard.service
  • sudo cp /etc/systemd/system/docker-gogs.service /etc/systemd/system/docker-dokuwiki.service
  • sudo cp /etc/systemd/system/docker-gogs.service /etc/systemd/system/docker-tiddlywiki.service
  • sudo cp /etc/systemd/system/docker-gogs.service /etc/systemd/system/docker-db_nextcloud.service
  • sudo cp /etc/systemd/system/docker-gogs.service /etc/systemd/system/docker-nextcloud.service
  • FLARUM
  • MARIADB

Maintenant il faut les éditer un par un, pour spécifier la “Description” (le nom du service) et mettre les bons noms de services dans “ExecStart” et ExecStop” : kanboard, dokuwiki, tiddlywiki, db_nextcloud et nextcloud

ATTENTION au cas spécial du service nextcloud qui utilise une base de données. Par conséquent, le container “db_nextcloud” doit bien être lancé juste après le démarrage de docker, mais le container “nextcloud”, lui, doit être lancé après le container db_nextcloud (voir la description du fichier plus bas)

  • sudo nano /etc/systemd/system/docker-kanboard.service
  • sudo nano /etc/systemd/system/docker-dokuwiki.service
  • sudo nano /etc/systemd/system/docker-tiddlywiki.service
  • sudo nano /etc/systemd/system/docker-db_nextcloud.service
  • FLARUM
  • MARIADB

Pour le cas particulier de nextcloud : sudo nano /etc/systemd/system/docker-nextcloud.service

[Unit]
Description=Nextcloud container
Requires=docker-db_nextcloud.service
After=docker-db_nextcloud.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a nextcloud
ExecStop=/usr/bin/docker stop -t 4 nextcloud

[Install]
WantedBy=default.target

TODO QUAND LE SERVEUR A ETE PLACE A SON ENDROIT DEFINITIF

selfhostingforteams.txt · Dernière modification: 2017/03/02 22:06 par Emilien