Déployer un Wiki sur votre serveur avec Docker et GitlabCI7 min read

Dans ce tutoriel nous allons voir comment utiliser Gitlab CI et Docker Compose pour déployer un Wiki (la plateforme derrière Wikipédia) sur notre serveur.


Point sur le vocabulaire

Avant d’aller plus loin, voici les définitions de quelques termes utilisés dans cet article.

Docker compose
Docker compose est un outil proposé par docker, qui permet de décrire dans un fichier plusieurs containers ainsi que toutes leur options. Cet outil est très pratique car il permet de gérer sous git, avec le reste de notre projet, une configuration de notre application déployable en quelques minutes à l’identique sur un nouveau serveur.

MediaWiki
MediaWiki est un moteur de wiki écrit en PHP. La très populaire encyclopédie en ligne Wikipédia utilise ce moteur. C’est un outil très simple à utiliser comme solution de gestion des connaissances pour une entreprise ou un projet.

Configuration

Voici la configuration logicielle dans laquelle l’article a été rédigé. Si vos versions sont trop différentes, il se peut que l’article ne s’applique par parfaitement (n’hésitez pas à nous le faire savoir en commentaires).

MediaWiki : 1.34.0
Docker : 2.2.0.4
GitLab : Enterprise Edition 12.10.0-pre


MediaWiki propose une image docker de wiki qui semble simple à configurer au premier abord. Nous allons voir qu’il y a quelques subtilités tout de même pour aller jusqu’au déploiement.

La première étape est donc de créer un projet sur Gitlab, puis de le cloner sur notre machine.

Instanciation avec docker-compose

La mise en place de MediaWiki semble simple si on se réfère à la documentation fournie par Docker Hub. Commençons par créer un fichier docker-compose.yml à la racine de notre projet.

L’image MediaWiki pourrait très bien fonctionner seule, en utilisant sa base de donnée interne SQLite, mais on va ici la coupler à une base de donnée MariaDB pour plus de flexibilité.

version: '3.5'

services:
  db:
    image: mariadb
    restart: unless-stopped
    volumes:
      - mediawiki_database:/var/lib/mysql
    environment:
      MYSQL_DATABASE: ${DB_NAME}
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
    networks:
      - wiki

  mediawiki:
    depends_on:
      - db
    image: mediawiki
    restart: unless-stopped
    ports:
      - 80:80
    volumes:
      # - ./LocalSettings.php:/var/www/html/LocalSettings.php
      - mediawiki_images:/var/www/html/images
    networks:
      - wiki

volumes:
  mediawiki_database:
    driver: local
    driver_opts:
      o: bind
      type: none
      device: /srv/mediawiki/database
  mediawiki_images:
    driver: local
    driver_opts:
      o: bind
      type: none
      device: /srv/mediawiki/images

networks:
  wiki:

Pour la première mise en ligne, la ligne 23 doit être commentée. En effet on a pas encore de fichier de configuration. Celui-ci sera téléchargé à la fin de la procédure de mise en route du wiki.

Ici on a choisi de définir les variables DB_NAME et DB_ROOT_PASSWORD dans un fichier .env à la racine du projet.

Le fichier docker-compose.yml décrit donc les deux images nécessaires à la mise en place du wiki. On a également déclaré deux volumes (mediawiki_database et mediawiki_images) qui permettront de conserver la base de données et les images sur le serveur, en dehors des containers, et donc de ne pas les écraser à chaque nouveau déploiement. On a spécifié un emplacement sur le serveur pour ces volumes afin de les retrouver facilement en cas de besoin.

Déploiement avec GitlabCI

On utilise ici le service d’intégration continue de Gitlab (GitlabCI) pour effectuer le déploiement de nos containers. Ajoutons le fichier .gitlab-ci.yml à la racine de notre projet.

image: docker

stages:
  - Deploy on server

deploy_prod:
  stage: Deploy on server
  environment: production
  when: manual
  only:
    - master
  services:
    - docker:dind
  before_script:
    - which ssh-agent || ( apk update && apk add openssh-client )
    - mkdir -p ~/.ssh
    - echo "$SERVER_PRIVATE_KEY" | tr -d '\r' > ~/.ssh/id_rsa
    - chmod 600 ~/.ssh/id_rsa
    - eval "$(ssh-agent -s)"
    - ssh-add ~/.ssh/id_rsa
    - ssh-keyscan -H $SERVER_IP >> ~/.ssh/known_hosts
  script:
    - ssh root@$SERVER_IP "mkdir -p wiki; mkdir -p /srv/mediawiki/{database,images};"
    - scp docker-compose.yml root@${SERVER_IP}:~/wiki
    - scp .env root@${SERVER_IP}:~/wiki
    # - scp LocalSettings.php root@${SERVER_IP}:~/wiki
    - ssh root@SERVER_IP "cd ~/wiki/; docker-compose rm --stop --force; docker-compose up -d"

On a choisi de n’effectuer la tâche de déploiement que lors d’un commit sur la branche master, et de manière manuelle.

Avant l’exécution du déploiement à proprement parlé (before_script), on met en place une clé ssh qui nous permettra de nous connecter en ssh à notre serveur. Les variables $SERVER_PRIVATE_KEY et $SERVER_IP sont configurées dans notre projet Gitlab (Settings -> CI / CD -> Variables).

Le déploiement se passe ensuite en 3 temps :

Premièrement on crée sur le serveur un dossier wiki dans le répertoire home, et les deux dossiers des volumes mediawiki_database et mediawiki_images qu’on a déclaré dans notre fichier docker-compose.yml. L’option -p permet de ne pas déclencher d’erreur si l’un des dossiers qu’on essaie de créer existe déjà.

Ensuite on copie le fichier docker-compose.yml et le fichier .env dans le dossier wiki qu’on vient de créer sur le serveur. La ligne 26 est commentée car on n’a pas encore de fichier de configuration à fournir.

Et enfin on redémarre les containers docker avec l’enchainement des commandes docker-compose rm --stop --force et docker-compose up -d.

Voilà, tout est prêt ! Reste à faire un commit sur la branche master, et un push sur le dépôt origin et la machine Gitlab CI se lancera. Au bout de quelques dizaines de secondes le wiki sera en ligne. On conseille de placer un tag sur ce commit car il sera toujours la première version à déployer sur un nouveau serveur pour une nouvelle installation.

Configuration du Wiki

Une fois sur le site, une page vous indique qu’aucun fichier LocalSettings.php n’a été trouvé (ce qui est parfaitement normal, il va être généré par les écrans qui suivent), et vous invite à commencer par configurer le wiki, ce qu’on va faire.

Sélection de la langue

Configuration de MediaWiki : sélection de la langue.

On veut une procédure d’installation et un wiki en français.

Statut du serveur

Paramétrage de MediaWiki : bienvenue.

Ici le système de configuration fait une passe rapide sur l’état du serveur. Pour ces captures d’écran, pour plus de simplicité, on a lancé le docker en local sur notre PC, d’où http://localhost comme nom de serveur. Continuons.

Connexion à la basse de données

Paramétrage de MediaWiki : page de connexion à la base de donnée

Il y a une subtilité sur cette page : le nom d’hôte de la base de données. Comme souvent avec docker, il ne faut pas donner l’URL ou l’IP de notre serveur, ni localhost, mais bien le nom qu’on a donné au container dans notre fichier docker-compose.yml. Pour nous ça sera donc db.

On peut laisser le nom de la base de données à sa valeur par défaut. Pour les identifiants de la base de donnée, on laisse root, et on renseigne le mot de passe (le même que celui qui est écrit dans notre fichier .env).

A l’étape suivante on a laissé “Utiliser le même compte que pour l’installation” pour le compte d’accès Web à la base de données.

Nommage du wiki

Paramétrage de MediaWiki : page de nommage de l'instance et de création du compte administrateur.

Vient maintenant le temps de créer le wiki en lui donnant un nom, et de créer le premier compte utilisateur. Cet utilisateur sera administrateur. On laisse coché “me poser davantage de questions” puisqu’on veut configurer quelques options, mais là on laisse libre cours à votre imagination.

Téléchargement du fichier de configuration

Paramétrage de MediaWiki : page de fin de configuration

Après quelques clics sur le bouton continuer, on arrive enfin sur cette page qui nous propose de télécharger le fichier LocalSettings.php. Il contient une partie des informations qu’on vient de renseigner à travers tous ces écrans. On récupère donc ce fichier et on le place à la racine de notre projet.

Dernière étape

Il ne nous reste plus qu’à dé-commenter la ligne 23 de notre fichier docker-compose.yml, et la ligne 26 du fichier .gitlab-ci.yml, ce qui permettra à MediaWiki de charger la configuration que nous venons d’effectuer.

Un commit de ces modifications sur la branche master, et un push sur le dépôt origin, et hop ! Le wiki est en ligne.

Related Posts

Leave a Reply