So installieren Sie FileRun mit Docker

FileRun ist eine selbst gehostete, webbasierte Anwendung zum Synchronisieren und Teilen von Dateien. Sie kann auf jedem Server, einschließlich Linux, Windows, NAS usw., betrieben werden. Die Dateien sind über das Web und mobil mit einer PWA-App zugänglich. Es ist mit Nextcloud kompatibel, sodass Sie die Desktop- und mobilen Apps verwenden können, um auf Ihre Dateien zuzugreifen. Sie können auch auf die Dateien über das WebDAV-Protokoll zugreifen. FileRun kann auch als Ersatz für Google Fotos verwendet werden und unterstützt Büro- und Bild-Plugins.

FileRun ist als kostenlose Version verfügbar, die bis zu 10 Konten unterstützen kann, und als Unternehmensversion, wenn Sie mehr Funktionen und Konten wünschen. In diesem Tutorial lernen Sie, wie Sie FileRun in einer Docker-Umgebung auf Ihrem Linux-Server installieren. Wir werden auch Elasticsearch konfigurieren, um die Unterstützung für die Volltextsuche bereitzustellen.

Voraussetzungen

• Ein Linux-Server mit mindestens 2 CPU-Kernen und 2 GB RAM. Dieses Tutorial funktioniert auf jeder Linux-Distribution.
• Ein Nicht-Root-Benutzer mit Sudo-Rechten.
• Ein vollständig qualifizierter Domainname (FQDN), der auf den Server zeigt. Für unsere Zwecke verwenden wir filerun.example.com als Domainnamen.
• Stellen Sie sicher, dass alles aktualisiert ist. ## Ubuntu/Debian $ sudo apt update && sudo apt upgrade ## CentOS/Fedora/Rocky Linux/AlmaLinux $ sudo dnf update
• Installieren Sie grundlegende Dienstprogramme. Einige davon sind möglicherweise bereits 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

CentOS/Rocky Linux/Alma Linux

Sie sollten die Firewalld-Firewall installiert haben. Überprüfen Sie den Status der Firewall.

$ sudo firewall-cmd --state
running

Öffnen Sie die Ports 80, 9443 und 443. Portainer verwendet Port 9443, um seine Web-UI über HTTPS bereitzustellen. Nginx Proxy Manager verwendet Port 81 für seine UI.

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

Laden Sie die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Ubuntu/Debian

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

Überprüfen Sie, ob die Firewall läuft.

$ sudo ufw status

Wenn sie läuft, öffnen Sie die HTTP- und HTTPS-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

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

$ sudo ufw allow "OpenSSH"

Aktivieren Sie die Firewall, wenn sie nicht läuft.

$ sudo ufw enable

Wenn sie läuft, laden Sie sie neu, um die Änderungen anzuwenden.

$ sudo ufw reload

Schritt 2 - Docker und Docker Compose installieren

Führen Sie 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

Möglicherweise erhalten Sie den folgenden Fehler, während Sie versuchen, Docker zu installieren.

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

Verwenden Sie den folgenden Befehl, wenn Sie den obigen Fehler erhalten.

$ 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

Aktivieren und starten Sie den Docker-Dienst.

$ sudo systemctl start docker --now

Fügen Sie Ihren Benutzernamen zur Docker-Gruppe hinzu.

$ sudo usermod -aG docker $USER

Melden Sie sich vom System ab und wieder an, um die Änderung anzuwenden.

Schritt 3 - Erstellen Sie die FileRun Docker-Konfiguration

Erstellen Sie ein Verzeichnis für die FileRun Docker-Konfiguration.

$ mkdir dockerfilerun

Wechseln Sie in das Verzeichnis.

$ cd ~/dockerfilerun

Erstellen und öffnen Sie die Docker-Compose-Datei zur Bearbeitung.

$ nano docker-compose.yml

Fügen Sie den folgenden Code 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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Lassen Sie uns die Compose-Datei durchgehen.

• Zuerst ziehen wir das MariaDB-Docker-Image zum Speichern der Daten. Geben Sie 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 im Verzeichnis ~/dockerfilerun/db einhängen.
• Als nächstes ziehen wir den FileRun-Container, der sich mit dem MariaDB-Image unter Verwendung der gleichen Datenbankanmeldeinformationen verbindet. Es führt auch den Apache-Server intern aus und stellt FileRun über Port 80 bereit. Wir hängen auch ein öffentliches Verzeichnis auf dem Host im Verzeichnis ~/dockerfilerun/html und die entsprechenden vom Benutzer hochgeladenen Dateien im Verzeichnis ~/dockerfilerun/user-files ein.
• 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, der bei der Durchführung einer Volltextsuche auf Inhalten hilft, die in FileRun hochgeladen wurden. FileRun unterstützt derzeit nur Elasticsearch 6.8.x. Sie können die Umgebungsvariablen verwenden, um das Speicherkontingent in Bezug auf den verfügbaren Speicher auf Ihrem Server zu steuern. Wir werden die Elasticsearch-Daten im Verzeichnis ~/dockerfilerun/esearch einhängen.

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

$ mkdir esearch

Setzen Sie die richtigen Berechtigungen mit den folgenden Befehlen.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Bevor wir den Container starten, müssen wir die Limits für die mmap-Zählungen erhöhen, damit Elasticsearch funktioniert. Öffnen Sie die Datei /etc/sysctl.conf zur Bearbeitung.

$ sudo nano /etc/sysctl.conf

Fügen Sie die folgende Zeile am Ende hinzu.

vm.max_map_count = 262144

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben. Dies macht die Änderung dauerhaft, aber nur, wenn Sie das System neu starten.

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

$ sudo sysctl -w vm.max_map_count=262144

Starten Sie den Docker-Dienst neu.

$ sudo systemctl restart docker

Schritt 4 - Führen Sie den FileRun Docker-Container aus

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

$ docker compose up -d

Der Prozess wird einige Zeit in Anspruch nehmen, einschließlich des Abrufens der Docker-Images, des Erstellens eines Netzwerks und des Startens der erforderlichen Container.

Überprüfen Sie den Status der Container.

$ docker ps

Sie erhalten eine ähnliche Ausgabe.

Der nächste Schritt besteht darin, SSL mit Nginx zu installieren, um es sicherer zu machen. Wir werden den Nginx-Server dafür verwenden.

Schritt 5 - Installieren Sie Nginx

CentOS/Rocky Linux/Alma Linux

Um die neueste Version von Nginx zu installieren, müssen Sie das offizielle Nginx-Repository installieren.

Installieren Sie das erforderliche Paket.

$ sudo dnf install yum-utils

Erstellen und öffnen Sie das Nginx-Yum-Repository.

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

Fügen Sie 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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Installieren Sie Nginx.

$ sudo dnf install nginx

Aktivieren und starten Sie den Nginx-Server.

$ sudo systemctl start nginx --now

Konfigurieren Sie SELinux, um Netzwerkverbindungen von FileRun zuzulassen.

$ 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, müssen Sie das offizielle Nginx-Repository herunterladen.

Importieren Sie den Signaturschlü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ügen Sie 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 verwenden Sie stattdessen den folgenden Befehl.

$ 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

Aktualisieren Sie die System-Repositorys.

$ sudo apt update

Installieren Sie Nginx.

$ sudo apt install nginx

Überprüfen Sie 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 generieren. Sie können Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Ubuntu 22.04 und Debian 11 werden standardmäßig mit Snapd ausgeliefert. Führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihre Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core

Installieren Sie Certbot.

$ sudo snap install --classic certbot

Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.

$ 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. Installieren Sie Snapd.

$ sudo dnf install snapd

Aktivieren und starten Sie den Snap-Dienst.

$ sudo systemctl enable snapd --now

Installieren Sie das Snap-Core-Paket.

$ sudo snap install core
$ sudo snap refresh core

Erstellen Sie die erforderlichen 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

Führen Sie den folgenden Befehl aus, um Certbot zu installieren.

$ sudo snap install --classic certbot

Aktivieren Sie Certbot, indem Sie den symbolischen Link zu seiner ausführbaren Datei erstellen.

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

Führen Sie den folgenden Befehl aus, um ein SSL-Zertifikat zu generieren.

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

Wir haben das SSL-Zertifikat mit der certonly-Option von Certbot unter Verwendung von Nginx generiert. Es installiert das Zertifikat mit dem Nginx-Server, ändert jedoch nichts.

Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/filerun.example.com auf Ihrem Server herunter.

Generieren Sie ein Diffie-Hellman-Gruppen-Zertifikat.

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führen Sie einen Testlauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.

Schritt 7 - Nginx konfigurieren

Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.

server_names_hash_bucket_size  64;

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Erstellen und öffnen Sie die Datei /etc/nginx/conf.d/filerun.conf zur Bearbeitung.

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

Fügen Sie den folgenden Code ein. Ersetzen Sie filerun.example.com durch Ihren 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; # HTTP/2 Server Push aktivieren

   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;

   # Aktivieren Sie TLS-Versionen (TLSv1.3 ist für das kommende HTTP/3 QUIC erforderlich).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Aktivieren Sie TLSv1.3's 0-RTT. Verwenden Sie $ssl_early_data, wenn Sie einen Reverse-Proxy verwenden,
   # um Wiederholungsangriffe zu verhindern.
   #
   # @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 --- holen Sie OCSP-Datensätze von der URL in ssl_certificate und cachen Sie sie
   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;
   }
}

# Dieser Block ist nützlich zur Fehlersuche von TLS v1.3. Bitte entfernen Sie dies
# und verwenden Sie die von NGINX direkt bereitgestellte Variable `$ssl_early_data`, wenn Sie
# dies wünschen.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Überprüfen Sie Ihre Nginx-Konfiguration.

$ sudo nginx -t

Starten Sie den Nginx-Server neu.

$ sudo systemctl restart nginx

Schritt 8 - Greifen Sie auf FileRun zu und konfigurieren Sie es

Besuchen Sie die URL https://filerun.example.com, und Sie erhalten den folgenden Bildschirm.

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

Wenn alles in Ordnung ist, klicken Sie auf die Schaltfläche Weiter, um zur Datenbankeinrichtungsseite zu gelangen.

Geben Sie Ihren Datenbanknamen, Benutzer und Passwort ein und klicken Sie auf die Schaltfläche Weiter, um fortzufahren.

Hier erhalten Sie die Anmeldedaten. Klicken Sie auf die Schaltfläche Weiter, um zur Anmeldeseite zu gelangen.

Geben Sie Ihre Anmeldedaten aus dem vorherigen Schritt ein und klicken Sie auf die Schaltfläche Anmelden, um das Dashboard von FileRun zu öffnen.

Klicken Sie auf den Link Superuser ganz unten links auf dem Bildschirm und klicken Sie auf Kontoeinstellungen.

Klicken Sie auf die Registerkarte Passwort ändern, um auf die folgende Seite zuzugreifen, auf der Sie Ihr Standardpasswort ändern können. Klicken Sie auf die Schaltfläche Änderungen speichern, um zu speichern.

Klicken Sie auf den Link Steuerfeld unten links auf der Seite, um auf das FileRun-Steuerfeld zuzugreifen. Besuchen Sie den Abschnitt Dateien >> Suchen auf der Seite. Hier werden wir einige erweiterte Dateisuch- und OCR-Funktionen aktivieren.

Geben Sie http://elasticsearch:9200 als ElasticSearch-Host-URL ein. Der Hostname bezieht sich auf den Dienstnamen von Elastic in der Docker-Datei. Klicken Sie auf die Schaltfläche Testserver, um zu testen, ob es ordnungsgemäß funktioniert.

Sie sollten eine ähnliche Ausgabe erhalten, die bestätigt, dass es ordnungsgemäß funktioniert.

Geben Sie tika als Hostnamen des Apache Tika-Servers ein. Geben Sie 9998 als Portnummer ein. Aktivieren Sie die Schaltfläche OCR PDF-Dateien. Klicken Sie auf die Schaltfläche Testserver, um zu testen, ob es ordnungsgemäß funktioniert.

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

Ändern Sie als Nächstes den Wert der Option Standard-Suchkriterien von Name auf Inhalt, um die Volltextsuche zu aktivieren. Klicken Sie erneut auf die Schaltfläche Änderungen speichern, um den Vorgang abzuschließen.

Schritt 9 - Aktualisieren Sie FileRun

Das Upgrade von FileRun ist ein einfacher Schritt. Wechseln Sie in das Docker-Compose-Verzeichnis von FileRun.

$ cd ~/dockerfilerun

Stoppen und entfernen Sie als Nächstes den vorhandenen Container. Ihre Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Ziehen Sie die neueste Version des FileRun-Docker-Images.

$ docker compose pull

Starten Sie die Container erneut.

$ docker compose up -d

Ihre FileRun-Installation wurde aktualisiert und erneut gestartet.

Fazit

Damit endet das Tutorial, in dem Sie gelernt haben, wie Sie die FileRun-Dateihosting-Software mit Docker auf einem Linux-Server installieren. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.