Installation et présentation de Filebrowser - Partie 1

Table des matières

Présentation générale 📚

Filebrowser est un simple logiciel se présentant sous la forme d’une interface web épurée et simple pour gérer vos fichiers à distance, au travers de votre navigateur web.

Il est écrit en Go avec une interface web embarquée en VueJS ❤️. Concernant la base de données utilisée, filebrowser utilise bbolt. Votre base de données sera alors auto-contenue dans un seul fichier. Facile à sauvegarder et à restaurer.

Le design minimal de filebrowser le rend facile à installer, configurer et à auto-héberger sur son serveur personnel. Tout cela avec un nombre de fonctionnalités impressionnantes.

Avec filebrowser, vous pourrez facilement:

  • uploader vos fichiers
  • télécharger vos fichiers
  • éditer vos fichiers
  • partager vos fichiers

Il permet également de créer et gérer plusieurs comptes utilisateurs et d’isoler chaque utilisateur dans son espace de stockage privé.

Screenshots

Démo de filebrowser Démo de filebrowser
Page de login intégrée de filebrowser Page de login intégrée de filebrowser
Éditeur de fichiers intégré de filebrowser Éditeur de fichiers intégré de filebrowser

Links 🔗

Comment déployer filebrowser sur votre serveur personnel sans utiliser Docker 🧑‍🎓

Comme décrit dans le documentation officielle d’installation, vous pouvez utiliser l’image Docker filebrowser/ filebrowser pour facilement déployer un conteneur fournissant le service filebrowser.

Dans cet article nous allons voir:

  • comment configurer filebrowser comme un service system systemd.
  • comment configurer un Reverse Proxy httpd permettant entre autre de faire du Offload TLS.
  • comment intégrer filebrowser à fail2ban pour sécuriser les accès.

Pourquoi ai-je préféré une intégration système complète via systemd plutôt qu’un déploiement via conteneur ?

Très simple: mon serveur personnel n’a actuellement pas de support de docker ni d’aucun runtime de conteneur…

Etape 1: Installer filebrowser

C’est une étape simple et rapide. Aller sur la page de release de filebrowser et télécharger la variante correspondant à votre architecture.

Extraire le binaire et l’installer à l’emplacement /usr/bin/filebrowser.

Exemple:

$ tar xvf linux-amd64-filebrowser.tar.gz
$ sudo mv filebrowser /usr/bin/filebrowser
$ sudo chown root:root /usr/bin/filebrowser
$ sudo chmod 0755 /usr/bin/filebrowser

Etape 2: Intégration système et déploiement de la configuration 🚀

Nous sommes en 2022 📅. Nous n’allons donc pas faire des choses répétées manuellement. Certains outils comme ansible existent et permettent de créer de la documentation exécutable de ce que nous avons fait et comment. J’ai tendance à ne pas aimer ansible … mais pour ce genre de besoin simple il est parfait.

Voici les versions logicielles que nous allons utiliser:

$ ansible --version
ansible [core 2.13.2]
  config file = /home/riton/.ansible.cfg
  configured module search path = ['/home/riton/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /home/riton/.local/lib/python3.10/site-packages/ansible
  ansible collection location = /home/riton/.ansible/collections:/usr/share/ansible/collections
  executable location = /home/riton/.local/bin/ansible
  python version = 3.10.4 (main, Jun 29 2022, 12:14:53) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Comme à l’accoutumé, lorsque nous devons modéliser quelque chose, nous appliquons la méthode du plus général au plus spécifique. En d’autres mots, nous commençons par écrire la logique décrivant le comportement que nous voulons, puis nous descendons progressivement vers les détails de l’implémentation.

Tout le pseudo code ansible présenté ci-dessous peut-être trouvé dans ce repository: https://github.com/riton/ansible-filebrowser-role.

Etape 1 avec Ansible: Le playbook

 1---
 2- hosts: all
 3  gather_facts: true
 4  become: true
 5
 6  vars:
 7    # Dans quel répertoire stocker les fichiers uploadés avec filebrowser
 8    storage_data_dir: '/path/to/filebrowser/root_dir'
 9    sysconfig_options: "SEE THAT LATER"
10
11  tasks:
12    # C'est là où se fera toute la configuration du service
13    # filebrowser à proprement parler
14    - import_role:
15        name: 'filebrowser'
16
17    - name: 'Configure HTTPd reverse proxy for filebrowser'
18      import_role:
19        name: 'filebrowser'
20        tasks_from: 'reverse_proxy.yml'
21
22    - name: 'Configure fail2ban for filebrowser'
23      import_role:
24        name: 'filebrowser'
25        tasks_from: 'fail2ban.yml'

Ce n’est qu’un playbook d’exemple. Vous devrez sans aucun doute l’adapter à vos besoins.

Le playbook se décompose en trois parties:

  1. L’intégration système de filebrowser et sa configuration (line 14-15)
  2. La configuration du Reverse Proxy (line 19-20)
  3. L’intégration de filebrowser à fail2ban (line 24-25)

Etape 2 avec Ansible: Écrire le rôle filebrowser

Ce rôle va être en charge de faire l’intégration système ainsi que la configuration de filebrowser.

Nous commençons par la création d’un utilisateur système dédié au service:

  • tasks/main.yaml
  • vars/main.yaml
 1    ---
 2    - name: Create system group
 3      group:
 4        name: '{{ groupname }}'
 5        system: true
 6
 7    - name: Create system user
 8      user:
 9        name: '{{ username }}'
10        comment: 'filebrowser system user'
11        shell: '/bin/false'
12        group: '{{ groupname }}'
13        system: true
14        home: '{{ data_dir }}'
15        createhome: true
16

Le répertoire /var/lib/filebrowser sera utilisé:

  • en tant que home directory de l’utilisateur système filebrowser.
  • pour stocker la base de données de notre instance filebrowser.

Maintenant que nous avons créé l’utilisateur système, nous avons besoins de créer certains répertoires appartenant à cet utilisateur:

  • pour le fichier de logs de filebrowser dans le fichier /var/log/filebrowser/filebrowser.log.
  • pour le fichier de base de données. Il doit théoriquement avoir été pré-créé par ansible grâce au paramètre createhome: true.
  • tasks/main.yaml
  • vars/main.yaml
 1    - name: Create directories
 2      file:
 3        path: '{{ item }}'
 4        state: 'directory'
 5        owner: '{{ username }}'
 6        group: '{{ groupname }}'
 7        mode: '0700'
 8      loop:
 9        - '{{ data_dir }}'
10        - '{{ log_dir }}'
11
12    - name: Initialize log file
13      file:
14        path: '{{ log_dir }}/filebrowser.log'
15        state: 'touch'
16        owner: '{{ username }}'
17        group: '{{ groupname }}'
18        mode: '0640'
19

Nous pré-créons un fichier vide /var/log/filebrowser/filebrowser.log et donnons un accès complet à l’utilisateur système filebrowser sur ce fichier.


Par la suite, nous allons créer un simple fichier de sysconfig permettant à systemd de sourcer des variables d’environnement.

Le répertoire par défaut des fichiers sysconfig est:

  • /etc/sysconfig sur les systèmes d’exploitation de la famille Red Hat.
  • /etc/default sur les systèmes d’exploitation de la famille Debian.

J’ai ici fait le choix d’utiliser un fichier de sysconfig à la place d’un fichier de configuration pour filebrowser. C’est plus rapide et simple à gérer et ne demande aucune logique supplémentaire dans le modèle.

  • tasks/main.yaml
  • vars/main.yaml
  • templates/sysconfig.j2
1    - name: Create sysconfig file
2      template:
3        src: 'sysconfig.j2'
4        dest: '{{ sysconfig_file }}'
5        owner: 'root'
6        group: 'root'
7        mode: '0640'
8

Nous déclarons ici une variable OPTIONS que nous utiliserons plus tard dans notre service systemd.

Note: Nous utilisons ici la variable sysconfig_options que nous nous avions déclaré de façon globale dans notre playbook. Cela permet de très facilement et rapidement retrouver les options que nous avons utilisé pour configurer filebrowser.


Nous voilà à l’étape finale: la création du service systemd.

Ce fichier sera créé et géré par ansible. Le répertoire /etc/systemd/system semble donc plus approprié que les répertoires /usr/lib/systemd/system ou /lib/systemd/system.

  • tasks/main.yaml
  • templates/systemd.j2
1    - name: Create systemd service file
2      template:
3        src: 'systemd.j2'
4        dest: '/etc/systemd/system/filebrowser.service'
5        owner: 'root'
6        group: 'root'
7        mode: '0644'
8

L’intégration systemd peut-être décrite comme:

  • le programme /usr/bin/filebrowser sera exécuté par l’utilisateur système filebrowser.
  • les arguments en ligne de commande passés au programme /usr/bin/filebrowser sont contenus dans la variable $OPTIONS.
  • le fichier /etc/sysconfig/filebrowser est utilisé pour initialiser les variables d’environnement et DOIT exister. C’est depuis ce fichier que sera initialisé la variable $OPTIONS.
  • le processus filebrowser est isolé du système, à l’exception de répertoires /var/lib/filebrowser, /var/log/filebrowser et /path/to/filebrowser/root_dir (provenant des variables globales du playbook).
  • le processus filebrowser sera démarré depuis le répertoire /path/to/filebrowser/root_dir. Par défaut, filebrowser écrit ses données dans ce répertoire.

💡 Tout le code ansible présenté peut-être trouvé dans le repository https://github.com/riton/ansible-filebrowser-role.

Conclusion

Nous avons vu comment déployer filebrowser sur notre système en utilisant systemd pour démarrer et gérer le processus.

👉 Le rôle ansible présenté ne gère actuellement pas le service filebrowser. Cela est laissé en exercice au lecteur motivé 🧑‍🎓.

Dans le prochain article dédié à filebrowser, nous verrons une configuration minimaliste d’un reverse proxy pouvant être utilisé pour géré la partie TLS (chiffrement du traffic) et exposer ce service sur Internet.

A suivre…