HowtoForge

So installierst du FileRun mit Docker auf Linux

von ·

FileRun ist eine selbst gehostete, webbasierte Anwendung zur Synchronisierung und Freigabe von Dateien. Sie kann auf jedem Server laufen, einschließlich Linux, Windows, NAS usw. Die Dateien sind im Web und mobil über eine PWA-App zugänglich. Sie ist mit Nextcloud kompatibel, so dass du die Desktop- und Mobile-Apps von Nextcloud nutzen kannst, um auf deine Dateien zuzugreifen. Du kannst auch über das WebDAV-Protokoll auf die Dateien zugreifen. FileRun kann auch als Ersatz für Google Fotos verwendet werden und unterstützt Office- und Image-Plugins.

FileRun gibt es als kostenlose Version, die bis zu 10 Konten unterstützt, und als Unternehmensversion, wenn du mehr Funktionen und Konten möchtest. In diesem Tutorial lernst du, wie du FileRun mit einer Docker-Umgebung auf deinem Linux-Server installierst. Außerdem werden wir Elasticsearch so konfigurieren, dass es eine Volltextsuche unterstützt.

Voraussetzungen

  • Ein Linux-Server mit mindestens 2 CPU-Kernen und 2 GB RAM. Dieses Tutorial läuft auf jeder Linux-Distribution.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Ein vollständig qualifizierter Domainname (FQDN), der auf den Server verweist. Für unsere Zwecke werden wir filerun.example.com als Domänennamen verwenden.
  • Stelle sicher, dass alles auf dem neuesten Stand ist. 
    ## Ubuntu/Debian
$ sudo apt update && sudo apt upgrade

## CentOS/Fedora/Rocky Linux/AlmaLinux
$ sudo dnf update
  • Installiere grundlegende Hilfspakete wie wget und curl. Einige davon sind vielleicht schon installiert. 
    ## Ubuntu/Debian
$ sudo apt install wget curl nano unzip -y

## CentOS/Rocky Linux/AlmaLinux
$ sudo dnf install wget curl nano unzip yum-utils -y

Schritt 1 – Firewall konfigurieren

Cent OS/Rocky Linux/Alma Linux

Du solltest die Firewall Firewalld installiert haben. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Öffne die Ports 80, 9443 und 443. Portainer verwendet Port 9443, um seine Web-UI über HTTPS zu öffnen. Der Nginx Proxy Manager verwendet Port 81 für seine Benutzeroberfläche.

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

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Ubuntu/Debian

Ubuntu- und Debian-Systeme verwenden standardmäßig ufw (Uncomplicated Firewall).

Prüfe, ob die Firewall aktiv ist.

$ sudo ufw status

Wenn sie läuft, dann öffne die HTTP- und HTTPS-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Öffne den SSH-Port, wenn die Firewall nicht läuft.

$ sudo ufw allow "OpenSSH"

Aktiviere die Firewall, wenn sie nicht aktiv ist.

$ sudo ufw enable

Wenn sie läuft, lade sie neu, um die Änderungen zu übernehmen.

$ sudo ufw reload

Schritt 2 – Installiere Docker und Docker Compose

Führe den folgenden Befehl aus, um Docker zu installieren.

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

Beim Versuch, Docker zu installieren, kann die folgende Fehlermeldung erscheinen.

ror: 
 Problem: problem with installed package buildah-1:1.26.2-1.el9_0.x86_64
  - package buildah-1:1.26.2-1.el9_0.x86_64 requires runc >= 1.0.0-26, but none of the providers can be installed
  - package containerd.io-1.6.9-3.1.el9.x86_64 conflicts with runc provided by runc-4:1.1.3-2.el9_0.x86_64
  - package containerd.io-1.6.9-3.1.el9.x86_64 obsoletes runc provided by runc-4:1.1.3-2.el9_0.x86_64
  - cannot install the best candidate for the job

Verwende den folgenden Befehl, wenn du die obige Fehlermeldung erhältst.

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

Ubuntu

Installiere Ubuntu Pakete wie curl, GNUpg und die SSL root CA-Zertifikate.

$ 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

Aktiviere und starte den Docker-Dienst.

$ sudo systemctl start docker --now

Füge deinen Benutzernamen zur Docker-Gruppe hinzu.

$ sudo usermod -aG docker $USER

Melde dich aus dem System ab und melde dich wieder an, um die Änderung zu übernehmen.

Schritt 3 – FileRun Docker Configuration erstellen

Erstelle ein Verzeichnis für Filerun Docker Configuration.

$ mkdir dockerfilerun

Wechsle in das Verzeichnis.

$ cd ~/dockerfilerun

Erstelle und öffne die Docker compose Datei zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Lass uns die Compose-Datei durchgehen.

  • Zuerst ziehen wir das MariaDB-Docker-Image zum Speichern der Daten. Gib ein Root-Passwort, einen MySQL-Benutzernamen, ein MySQL-Passwort und den Namen der Datenbank für FileRun ein. Wir sichern die Datenbank, indem wir sie in das Verzeichnis ~/dockerfilerun/db mounten.
  • Als Nächstes ziehen wir den FileRun-Container, der sich mit denselben Datenbank-Anmeldedaten mit dem MariaDB-Image verbindet. Er führt auch den Apache-Server intern aus und stellt FileRun über Port 80 zur Verfügung. Wir mounten auch ein öffentliches Verzeichnis auf dem Host im Verzeichnis ~/dockerfilerun/html und entsprechende vom Benutzer hochgeladene Dateien im Verzeichnis ~/dockerfilerun/user-files.
  • Als Nächstes ziehen wir den Apache Tika Container, der Filerun hilft, die Metadaten der Dateien zu lesen.
  • Und schließlich ziehen wir den Elasticsearch-Container heran, der uns hilft, eine Volltextsuche über die auf FileRun hochgeladenen Inhalte durchzuführen. FIleRun unterstützt derzeit nur Elasticsearch 6.8.x. Du kannst die Umgebungsvariablen verwenden, um die Speicherbegrenzung in Bezug auf den verfügbaren Speicher deines Servers zu steuern. Wir werden die Elasticsearch-Daten in das Verzeichnis ~/dockerfilerun/esearch mounten.

Erstelle das Verzeichnis für Elasticsearch. Docker erstellt automatisch Verzeichnisse für Volumes, aber Elasticsearch funktioniert nur, wenn das lokale Verzeichnis dem Benutzer gehört und die Gruppe die ID 1000 hat.

$ mkdir esearch

Setze die richtigen Berechtigungen mit den folgenden Befehlen.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Bevor wir den Container starten, müssen wir die Grenzen für die mmap-Anzahl erhöhen, damit Elasticsearch funktioniert. Öffne die Datei /etc/sysctl.conf zum Bearbeiten.

$ sudo nano /etc/sysctl.conf

Füge die folgende Zeile am Ende ein.

vm.max_map_count = 262144

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Dadurch wird die Änderung dauerhaft, aber nur, wenn du das System neu startest.

Führe den folgenden Befehl aus, um die Änderung sofort umzusetzen.

$ sudo sysctl -w vm.max_map_count=262144

Starte den Docker-Dienst neu.

$ sudo systemctl restart docker

Schritt 4 – Starte den FileRun Docker Container

Führe den folgenden Befehl aus, um den Docker-Container zu starten.

$ docker compose up -d

Der Vorgang wird einige Zeit in Anspruch nehmen. Dazu gehören das Abrufen der Docker-Images, das Erstellen eines Netzwerks und das Starten der benötigten Container.

Überprüfe den Status der Container.

$ docker ps

Du wirst eine ähnliche Ausgabe erhalten.

Docker Container Status

Der nächste Schritt ist die Installation von SSL mit Nginx, um die Sicherheit zu erhöhen. Dazu verwenden wir den Nginx-Server.

Schritt 5 – Nginx installieren

CentOS/Rocky Linux/Alma Linux

Um die neueste Version von Nginx zu installieren, musst du das offizielle Nginx-Repository installieren.

Installiere das Vorraussetzungspaket.

$ sudo dnf install yum-utils

Erstelle und öffne das Nginx yum Repository.

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

Füge den folgenden Code ein.

[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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere Nginx.

$ sudo dnf install nginx

Aktiviere und starte den Nginx-Server.

$ sudo systemctl start nginx --now

Konfiguriere SELinux so, dass Netzwerkverbindungen von Filerun zugelassen werden.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 und Debian 11 werden mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

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

Füge das Repository für die stabile Version von Nginx hinzu.

$ 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

Für Debian kannst du stattdessen den folgenden Befehl verwenden.

$ 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

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Schritt 6 – SSL installieren

Ubuntu/Debian

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 und Debian 11 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.

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

CentOS/Rocky Linux/Alma Linux

Certbot benötigt das EPEL-Repository, um zu funktionieren.

$ sudo dnf install epel-release

Wir werden Snapd verwenden, um Certbot zu installieren. Installiere Snapd.

$ sudo dnf install snapd

Aktiviere und starte den Snap-Dienst.

$ sudo systemctl enable snapd --now

Installiere das Snap-Kernpaket.

$ sudo snap install core
$ sudo snap refresh core

Erstelle die notwendigen Links, damit Snapd funktioniert.

$ 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

Gib den folgenden Befehl ein, um Certbot zu installieren.

$ sudo snap install --classic certbot

Aktiviere Certbot, indem du den Symlink zu seiner ausführbaren Datei erstellst.

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

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

Wir haben das SSL-Zertifikat mit der Option certonly von Certbot mit Nginx erstellt. Es installiert das Zertifikat über den Nginx-Server, ändert aber nichts.

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/filerun.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 7 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/filerun.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei ein. Ersetze filerun.example.com durch deinen Domainnamen.

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; # Enable 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;

   # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
   # prevent replay attacks.
   #
   # @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-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:50m;
   # OCSP Stapling --- fetch OCSP records from URL in ssl_certificate and cache them
   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;
   }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Starte den Nginx-Server neu.

$ sudo systemctl restart nginx

Schritt 8 – FileRun aufrufen und konfigurieren

Rufe die URL https://filerun.example.com auf und du erhältst den folgenden Bildschirm.

FileRun Installer

Klicke auf die Schaltfläche Weiter, um die Seite mit den Systemanforderungen zu öffnen.

FileRun Server Anforderungen Seite

Wenn alles in Ordnung ist, klicke auf die Schaltfläche Weiter, um zur Seite mit den Datenbankeinstellungen zu gelangen.

FileRun Datenbank Setup Seite

Gib deinen Datenbanknamen, deinen Benutzer und dein Passwort ein und klicke auf die Schaltfläche Weiter, um fortzufahren.

FileRun Benutzeranmeldeinformationen

Hier werden dir die Anmeldedaten angezeigt. Klicke auf die Schaltfläche Weiter, um die Anmeldeseite zu öffnen.

FileRun Login-Seite

Gib deine Anmeldedaten aus dem vorherigen Schritt ein und klicke auf die Schaltfläche Anmelden, um das Dashboard von FileRun zu öffnen.

FileRun Dashboard

Klicke auf den Link Superuser ganz links unten auf dem Bildschirm und dann auf Kontoeinstellungen.

FileRun Kontoeinstellungen

Klicke auf die Registerkarte Passwort ändern, um die folgende Seite aufzurufen, auf der du dein Standardpasswort ändern kannst. Klicke auf die Schaltfläche Änderungen speichern, um sie zu speichern.

FileRun Passwort ändern Bildschirm

Klicke auf den Link Bedienfeld unten links auf der Seite, um das FileRun Bedienfeld aufzurufen. Besuche den Abschnitt Dateien >> Suchen auf der Seite. Hier werden wir einige erweiterte Dateisuch- und OCR-Funktionen aktivieren.

Gib http://elasticsearch:9200 als ElasticSearch Host URL ein. Der Hostname bezieht sich auf den Dienstnamen von Elastic in der Docker-Datei. Klicke auf die Schaltfläche Server testen, um zu prüfen, ob er richtig funktioniert.

FileRun ElasticSearch Test

Du solltest eine ähnliche Ausgabe wie oben erhalten, die bestätigt, dass er ordnungsgemäß funktioniert.

Gib tika als Hostname für den Apache Tika Server ein. Gib 9998 als Portnummer ein. Aktiviere die Schaltfläche OCR PDF-Dateien. Klicke auf die Schaltfläche Server testen, um zu prüfen, ob er ordnungsgemäß funktioniert.

FileRun Tika Test

Du solltest eine ähnliche Ausgabe für den Tika-Server erhalten, die bestätigt, dass er ordnungsgemäß funktioniert. Klicke auch auf die Schaltfläche OCR-Bilddateien. Klicke oben auf der Seite auf die Schaltfläche Änderungen speichern.

Als Nächstes änderst du den Wert der Option Standard-Suchkriterien von Name in Inhalt, um die Volltextsuche zu aktivieren. Klicke erneut auf die Schaltfläche Änderungen speichern, um den Vorgang abzuschließen.

FileRun Sucheinstellungen

Schritt 9 – FileRun aktualisieren

Die Aktualisierung von FileRun ist ein einfacher Schritt. Wechsle in das Docker-Kompositionsverzeichnis von FileRun.

$ cd ~/dockerfilerun

Als nächstes stoppst und entfernst du den bestehenden Container. Deine Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Ziehe die neueste Version des FileRun-Docker-Images.

$ docker compose pull

Starte die Container erneut.

$ docker compose up -d

Deine FileRun-Installation wird aktualisiert und neu gestartet.

Fazit

Dies ist der Abschluss des Tutorials, in dem du gelernt hast, wie du die FileRun Filehosting-Software mit Docker auf einem Linux-Server installierst. Vielleiht interessiert Dich auch unser Tutorial zur Installation von Mastodon auf Ubuntu 22.04?

Das könnte dich auch interessieren …