Comment installer FileRun en utilisant Docker

FileRun est une application web de synchronisation et de partage de fichiers auto-hébergée. Elle peut fonctionner sur n’importe quel serveur, y compris Linux, Windows, NAS, etc. Les fichiers sont accessibles sur le web et mobile via une application PWA. Elle est compatible avec Nextcloud, vous pouvez donc utiliser ses applications de bureau et mobiles pour accéder à vos fichiers. Vous pouvez également accéder aux fichiers en utilisant le protocole WebDAV. FileRun peut également être utilisé comme un remplacement de Google Photos et prend en charge les plugins de bureau et d’image.

FileRun est disponible en version gratuite, qui peut prendre en charge jusqu’à 10 comptes, et en version entreprise si vous souhaitez plus de fonctionnalités et de comptes. Dans ce tutoriel, vous apprendrez à installer FileRun en utilisant un environnement Docker sur votre serveur Linux. Nous allons également configurer Elasticsearch pour fournir un support de recherche en texte intégral.

Prérequis

• Un serveur Linux avec un minimum de 2 cœurs CPU et 2 Go de RAM. Ce tutoriel fonctionnera sur chaque distribution Linux.
• Un utilisateur non-root avec des privilèges sudo.
• Un nom de domaine entièrement qualifié (FQDN) pointant vers le serveur. Pour nos besoins, nous utiliserons filerun.example.com comme nom de domaine.
• Assurez-vous que tout est à jour. ## Ubuntu/Debian $ sudo apt update && sudo apt upgrade ## CentOS/Fedora/Rocky Linux/AlmaLinux $ sudo dnf update
• Installez des paquets utilitaires de base. Certains d’entre eux peuvent déjà être installés. ## Ubuntu/Debian $ sudo apt install wget curl nano unzip -y ## CentOS/Rocky Linux/AlmaLinux $ sudo dnf install wget curl nano unzip yum-utils -y

Étape 1 - Configurer le pare-feu

CentOS/Rocky Linux/Alma Linux

Vous devriez avoir le pare-feu Firewalld installé. Vérifiez l’état du pare-feu.

$ sudo firewall-cmd --state
running

Ouvrez les ports 80, 9443 et 443. Portainer utilise le port 9443 pour exposer son interface web via HTTPS. Nginx Proxy Manager utilise le port 81 pour son interface.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Rechargez le pare-feu pour activer les changements.

$ sudo firewall-cmd --reload

Ubuntu/Debian

Les systèmes Ubuntu et Debian utilisent ufw (Uncomplicated Firewall) par défaut.

Vérifiez si le pare-feu est en cours d’exécution.

$ sudo ufw status

S’il est en cours d’exécution, ouvrez alors les ports HTTP et HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Ouvrez le port SSH si le pare-feu n’est pas en cours d’exécution.

$ sudo ufw allow "OpenSSH"

Activez le pare-feu s’il n’est pas en cours d’exécution.

$ sudo ufw enable

S’il est en cours d’exécution, rechargez-le pour appliquer les changements.

$ sudo ufw reload

Étape 2 - Installer Docker et Docker Compose

Exécutez la commande suivante pour installer Docker.

CentOS/Rocky Linux/Alma Linux

$ sudo dnf install -y yum-utils
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Vous pouvez obtenir l’erreur suivante lors de la tentative d’installation de Docker.

ror: 
 Problème : problème avec le paquet installé buildah-1:1.26.2-1.el9_0.x86_64
  - le paquet buildah-1:1.26.2-1.el9_0.x86_64 nécessite runc >= 1.0.0-26, mais aucun des fournisseurs ne peut être installé
  - le paquet containerd.io-1.6.9-3.1.el9.x86_64 entre en conflit avec runc fourni par runc-4:1.1.3-2.el9_0.x86_64
  - le paquet containerd.io-1.6.9-3.1.el9.x86_64 obsolète runc fourni par runc-4:1.1.3-2.el9_0.x86_64
  - impossible d'installer le meilleur candidat pour le travail

Utilisez la commande suivante si vous obtenez l’erreur ci-dessus.

$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-compose-plugin --allowerasing

Ubuntu

$ sudo apt install ca-certificates curl gnupg lsb-release
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
$ sudo apt update
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Debian

$ sudo apt install ca-certificates curl gnupg lsb-release
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
$ sudo apt update
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Activez et démarrez le service Docker.

$ sudo systemctl start docker --now

Ajoutez votre nom d’utilisateur au groupe Docker.

$ sudo usermod -aG docker $USER

Déconnectez-vous du système et reconnectez-vous pour appliquer le changement.

Étape 3 - Créer la configuration Docker de FileRun

Créez un répertoire pour la configuration Docker de FileRun.

$ mkdir dockerfilerun

Passez au répertoire.

$ cd ~/dockerfilerun

Créez et ouvrez le fichier de composition Docker pour l’édition.

$ nano docker-compose.yml

Collez le code suivant dedans.

version: '3.8'

services:
  db:
    image: mariadb:10.5
    container_name: filerun_mariadb
    environment:
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      MYSQL_USER: your_filerun_username
      MYSQL_PASSWORD: your_filerun_password
      MYSQL_DATABASE: your_filerun_database
    volumes:
      - ./db:/var/lib/mysql

  web:
    image: filerun/filerun
    container_name: filerun_web
    environment:
      FR_DB_HOST: db
      FR_DB_PORT: 3306
      FR_DB_NAME: your_filerun_database
      FR_DB_USER: your_filerun_username
      FR_DB_PASS: your_filerun_password
      APACHE_RUN_USER: www-data
      APACHE_RUN_USER_ID: 33
      APACHE_RUN_GROUP: www-data
      APACHE_RUN_GROUP_ID: 33
    depends_on:
      - db
    links:
      - db
      - tika
      - elasticsearch
    ports:
      - "8080:80"
    volumes:
      - ./html:/var/www/html
      - ./user-files:/user-files

  tika:
    image: apache/tika
    container_name: filerun_tika

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:6.8.23
    container_name: filerun_search
    environment:
      - cluster.name=docker-cluster
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65535
        hard: 65535
    mem_limit: 1g
    volumes:
      - ./esearch:/usr/share/elasticsearch/data

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Passons en revue le fichier de composition.

• Tout d’abord, nous tirons l’image Docker de MariaDB pour stocker les données. Entrez un mot de passe root, un nom d’utilisateur MySQL, un mot de passe MySQL et le nom de la base de données pour FileRun. Nous sauvegardons la base de données en la montant dans le répertoire ~/dockerfilerun/db.
• Ensuite, nous tirons le conteneur FileRun qui se connecte à l’image MariaDB en utilisant les mêmes identifiants de base de données. Il exécute également le serveur Apache en interne et expose FileRun via le port 80. Nous montons également un répertoire public sur l’hôte dans le répertoire ~/dockerfilerun/html et les fichiers téléchargés par les utilisateurs dans le répertoire ~/dockerfilerun/user-files.
• Ensuite, nous tirons le conteneur Apache Tika qui aide FileRun à lire les métadonnées des fichiers.
• Enfin, nous tirons le conteneur Elasticsearch qui aide à exécuter une recherche en texte intégral sur le contenu téléchargé sur FileRun. FileRun ne prend en charge que Elasticsearch 6.8.x pour le moment. Vous pouvez utiliser les variables d’environnement pour contrôler la limite de mémoire par rapport à la mémoire disponible sur votre serveur. Nous allons monter les données Elasticsearch dans le répertoire ~/dockerfilerun/esearch.

Créez le répertoire pour Elasticsearch. Docker crée des répertoires pour les volumes automatiquement, mais Elasticsearch ne fonctionne que lorsque le répertoire local est possédé par l’utilisateur et que le groupe a 1000 comme ID.

$ mkdir esearch

Définissez les permissions correctes en utilisant les commandes suivantes.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Avant de démarrer le conteneur, nous devons augmenter les limites sur les comptes mmap pour qu’Elasticsearch fonctionne. Ouvrez le fichier /etc/sysctl.conf pour l’édition.

$ sudo nano /etc/sysctl.conf

Collez la ligne suivante en bas.

vm.max_map_count = 262144

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité. Cela rendra le changement permanent mais seulement si vous redémarrez le système.

Exécutez la commande suivante pour mettre en œuvre le changement immédiatement.

$ sudo sysctl -w vm.max_map_count=262144

Redémarrez le service Docker.

$ sudo systemctl restart docker

Étape 4 - Exécuter le conteneur Docker FileRun

Exécutez la commande suivante pour lancer le conteneur Docker.

$ docker compose up -d

Le processus prendra un certain temps pour se terminer, ce qui inclut le téléchargement des images Docker, la création d’un réseau et le lancement des conteneurs requis.

Vérifiez l’état des conteneurs.

$ docker ps

Vous obtiendrez une sortie similaire.

La prochaine étape consiste à installer SSL en utilisant Nginx pour le rendre plus sécurisé. Nous allons utiliser le serveur Nginx pour cela.

Étape 5 - Installer Nginx

CentOS/Rocky Linux/Alma Linux

Pour installer la dernière version de Nginx, vous devez installer le dépôt officiel de Nginx.

Installez le paquet pré-requis.

$ sudo dnf install yum-utils

Créez et ouvrez le dépôt yum de Nginx.

$ sudo nano /etc/yum.repos.d/nginx.repo

Collez le code suivant.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Installez Nginx.

$ sudo dnf install nginx

Activez et démarrez le serveur Nginx.

$ sudo systemctl start nginx --now

Configurez SELinux pour autoriser les connexions réseau de FileRun.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 et Debian 11 sont livrés avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.

Importez la clé de signature de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Ajoutez le dépôt pour la version stable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Pour Debian, utilisez la commande suivante à la place.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Mettez à jour les dépôts du système.

$ sudo apt update

Installez Nginx.

$ sudo apt install nginx

Vérifiez l’installation.

$ nginx -v
nginx version: nginx/1.22.1

Étape 6 - Installer SSL

Ubuntu/Debian

Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.

Ubuntu 22.04 et Debian 11 sont livrés avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour.

$ sudo snap install core

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

CentOS/Rocky Linux/Alma Linux

Certbot nécessite le dépôt EPEL pour fonctionner.

$ sudo dnf install epel-release

Nous allons utiliser Snapd pour installer Certbot. Installez Snapd.

$ sudo dnf install snapd

Activez et démarrez le service Snap.

$ sudo systemctl enable snapd --now

Installez le paquet de base Snap.

$ sudo snap install core
$ sudo snap refresh core

Créez les liens nécessaires pour que Snapd fonctionne.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Émettez la commande suivante pour installer Certbot.

$ sudo snap install --classic certbot

Activez Certbot en créant le lien symbolique vers son exécutable.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Exécutez la commande suivante pour générer un certificat SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d filerun.example.com

Nous avons généré le certificat SSL en utilisant l’option certonly de Certbot avec Nginx. Il installe le certificat en utilisant le serveur Nginx mais ne modifie rien.

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/filerun.example.com sur votre serveur.

Générez un certificat de groupe Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Pour vérifier si le renouvellement SSL fonctionne correctement, effectuez un essai à sec du processus.

$ sudo certbot renew --dry-run

Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 7 - Configurer Nginx

Ouvrez le fichier /etc/nginx/nginx.conf pour l’édition.

$ sudo nano /etc/nginx/nginx.conf

Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier /etc/nginx/conf.d/filerun.conf pour l’édition.

$ sudo nano /etc/nginx/conf.d/filerun.conf

Collez le code suivant dedans. Remplacez filerun.example.com par votre nom de domaine.

upstream backend {
   server 127.0.0.1:8080;
   keepalive 32;
}

server {
  listen 80 default_server;
  server_name filerun.example.com;
  return 301 https://$server_name$request_uri;
}

server {
   listen 443 ssl http2;
   server_name filerun.example.com;

   http2_push_preload on; # Activer le HTTP/2 Server Push

   ssl_certificate /etc/letsencrypt/live/filerun.example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/filerun.example.com/privkey.pem;
   ssl_trusted_certificate /etc/letsencrypt/live/filerun.example.com/chain.pem;
   ssl_session_timeout 1d;

   # Activer les versions TLS (TLSv1.3 est requis pour le prochain HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Activer le 0-RTT de TLSv1.3. Utilisez $ssl_early_data lors du reverse proxy pour
   # éviter les attaques de rejeu.
   #
   # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
   ssl_early_data on;

   ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-GCM-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:50m;
   # OCSP Stapling --- récupérer les enregistrements OCSP à partir de l'URL dans ssl_certificate et les mettre en cache
   ssl_stapling on;
   ssl_stapling_verify on;
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   add_header X-Early-Data $tls1_3_early_data;

   access_log /var/log/nginx/filerun.access.log main;
   error_log  /var/log/nginx/filerun.error.log;

   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-Forwarded-Protocol $scheme;
       proxy_buffers 256 16k;
       proxy_buffer_size 16k;
       proxy_read_timeout 1800s;
       proxy_connect_timeout 1800s;
       proxy_http_version 1.1;
       proxy_pass http://backend;
   }
}

# Ce bloc est utile pour déboguer TLS v1.3. N'hésitez pas à le supprimer
# et à utiliser la variable `$ssl_early_data` exposée par NGINX directement si vous
# souhaitez le faire.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Vérifiez votre configuration Nginx.

$ sudo nginx -t

Redémarrez le serveur Nginx.

$ sudo systemctl restart nginx

Étape 8 - Accéder et configurer FileRun

Visitez l’URL https://filerun.example.com et vous obtiendrez l’écran suivant.

Cliquez sur le bouton Suivant pour ouvrir la page des exigences système.

Si tout est en ordre, cliquez sur le bouton Suivant pour passer à la page de configuration de la base de données.

Remplissez votre nom de base de données, utilisateur et mot de passe, puis cliquez sur le bouton Suivant pour continuer.

Ici, vous recevrez les détails de connexion. Cliquez sur le bouton Suivant pour ouvrir la page de connexion.

Entrez vos identifiants de connexion de l’étape précédente et cliquez sur le bouton Se connecter pour ouvrir le tableau de bord de FileRun.

Cliquez sur le lien Superutilisateur en bas à gauche de l’écran et cliquez sur Paramètres du compte.

Cliquez sur l’onglet Changer le mot de passe pour accéder à la page suivante où vous pouvez changer votre mot de passe par défaut. Cliquez sur le bouton Enregistrer les modifications pour sauvegarder.

Cliquez sur le lien Panneau de contrôle en bas à gauche de la page pour accéder au Panneau de contrôle de FileRun. Visitez la section Fichiers >> Recherche de la page. Ici, nous allons activer certaines fonctionnalités avancées de recherche de fichiers et d’OCR.

Entrez http://elasticsearch:9200 comme URL de l’hôte ElasticSearch. Le nom d’hôte fait référence au nom de service d’Elastic dans le fichier docker. Cliquez sur le bouton Tester le serveur pour tester s’il fonctionne correctement.

Vous devriez obtenir une sortie similaire ci-dessus qui confirme qu’il fonctionne correctement.

Entrez tika comme nom d’hôte du serveur Apache Tika. Entrez 9998 comme numéro de port. Cochez la case OCR PDF Files. Cliquez sur le bouton Tester le serveur pour tester s’il fonctionne correctement.

Vous devriez obtenir une sortie similaire pour le serveur Tika qui confirme qu’il fonctionne correctement. Cliquez également sur le bouton OCR image files. Cliquez sur le bouton Enregistrer les modifications en haut de la page.

Ensuite, changez la valeur de l’option Critères de recherche par défaut de Nom à Contenu pour activer la recherche en texte intégral. Cliquez à nouveau sur le bouton Enregistrer les modifications pour terminer le processus.

Étape 9 - Mettre à jour FileRun

Mettre à jour FileRun est une étape simple. Passez au répertoire de composition Docker de FileRun.

$ cd ~/dockerfilerun

Ensuite, arrêtez et supprimez le conteneur existant. Vos données seront conservées cependant.

$ docker compose down --remove-orphans

Tirez la dernière version de l’image Docker de FileRun.

$ docker compose pull

Démarrez à nouveau les conteneurs.

$ docker compose up -d

Votre installation de FileRun est mise à jour et redémarrée.

Conclusion

Cela conclut le tutoriel où vous avez appris à installer le logiciel d’hébergement de fichiers FileRun en utilisant Docker sur un serveur Linux. Si vous avez des questions, postez-les dans les commentaires ci-dessous.