So installierst du FileRun mit Docker auf Linux
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.comals 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/dbmounten. - 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/htmlund 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/esearchmounten.
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.
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.
Klicke auf die Schaltfläche Weiter, um die Seite mit den Systemanforderungen zu öffnen.
Wenn alles in Ordnung ist, klicke auf die Schaltfläche Weiter, um zur Seite mit den Datenbankeinstellungen zu gelangen.
Gib deinen Datenbanknamen, deinen Benutzer und dein Passwort ein und klicke auf die Schaltfläche Weiter, um fortzufahren.
Hier werden dir die Anmeldedaten angezeigt. Klicke auf die Schaltfläche Weiter, um die Anmeldeseite zu öffnen.
Gib deine Anmeldedaten aus dem vorherigen Schritt ein und klicke auf die Schaltfläche Anmelden, um das Dashboard von FileRun zu öffnen.
Klicke auf den Link Superuser ganz links unten auf dem Bildschirm und dann auf 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.
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.
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.
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.
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?