Come installare FileRun utilizzando Docker

FileRun è un’applicazione web di sincronizzazione e condivisione file auto-ospitata. Può funzionare su qualsiasi server, inclusi Linux, Windows, NAS, ecc. I file sono accessibili sul web e sui dispositivi mobili utilizzando un’app PWA. È compatibile con Nextcloud, quindi puoi utilizzare le sue app desktop e mobili per accedere ai tuoi file. Puoi anche accedere ai file utilizzando il protocollo WebDAV. FileRun può anche essere utilizzato come sostituto di Google Foto e supporta plugin per ufficio e immagini.

FileRun è disponibile in una versione gratuita che può supportare fino a 10 account e in una versione enterprise se desideri più funzionalità e account. In questo tutorial, imparerai come installare FileRun utilizzando un ambiente Docker sul tuo server Linux. Configureremo anche Elasticsearch per fornire supporto alla ricerca full-text.

Prerequisiti

• Un server Linux con un minimo di 2 core CPU e 2 GB di RAM. Questo tutorial funzionerà su ogni distribuzione Linux.
• Un utente non root con privilegi sudo.
• Un nome di dominio completamente qualificato (FQDN) che punta al server. Per i nostri scopi, utilizzeremo filerun.example.com come nome di dominio.
• Assicurati che tutto sia aggiornato. ## Ubuntu/Debian $ sudo apt update && sudo apt upgrade ## CentOS/Fedora/Rocky Linux/AlmaLinux $ sudo dnf update
• Installa pacchetti di utilità di base. Alcuni di questi potrebbero già essere installati. ## Ubuntu/Debian $ sudo apt install wget curl nano unzip -y ## CentOS/Rocky Linux/AlmaLinux $ sudo dnf install wget curl nano unzip yum-utils -y

Passo 1 - Configura il Firewall

Cent OS/Rocky Linux/Alma Linux

Dovresti avere installato il firewall Firewalld. Controlla lo stato del firewall.

$ sudo firewall-cmd --state
running

Apri le porte 80, 9443 e 443. Portainer utilizza la porta 9443 per esporre la sua interfaccia web tramite HTTPS. Nginx Proxy Manager utilizza la porta 81 per la sua interfaccia.

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

Ricarica il firewall per abilitare le modifiche.

$ sudo firewall-cmd --reload

Ubuntu/Debian

I sistemi Ubuntu e Debian utilizzano ufw (Uncomplicated Firewall) per impostazione predefinita.

Controlla se il firewall è in esecuzione.

$ sudo ufw status

Se è in esecuzione, apri le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Apri la porta SSH se il firewall non è in esecuzione.

$ sudo ufw allow "OpenSSH"

Abilita il firewall se non è in esecuzione.

$ sudo ufw enable

Se è in esecuzione, ricaricalo per applicare le modifiche.

$ sudo ufw reload

Passo 2 - Installa Docker e Docker Compose

Esegui il seguente comando per installare 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

Potresti ricevere il seguente errore durante il tentativo di installare Docker.

ror: 
 Problema: problema con il pacchetto installato buildah-1:1.26.2-1.el9_0.x86_64
  - il pacchetto buildah-1:1.26.2-1.el9_0.x86_64 richiede runc >= 1.0.0-26, ma nessuno dei fornitori può essere installato
  - il pacchetto containerd.io-1.6.9-3.1.el9.x86_64 confligge con runc fornito da runc-4:1.1.3-2.el9_0.x86_64
  - il pacchetto containerd.io-1.6.9-3.1.el9.x86_64 obsoleta runc fornito da runc-4:1.1.3-2.el9_0.x86_64
  - impossibile installare il miglior candidato per il lavoro

Usa il seguente comando se ricevi l’errore sopra.

$ 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

Abilita e avvia il servizio Docker.

$ sudo systemctl start docker --now

Aggiungi il tuo nome utente al gruppo Docker.

$ sudo usermod -aG docker $USER

Disconnettiti dal sistema e riconnettiti per applicare la modifica.

Passo 3 - Crea la Configurazione Docker di FileRun

Crea una directory per la Configurazione Docker di Filerun.

$ mkdir dockerfilerun

Passa alla directory.

$ cd ~/dockerfilerun

Crea e apri il file di composizione Docker per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice al suo interno.

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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Esaminiamo il file di composizione.

• Prima di tutto, scarichiamo l’immagine Docker di MariaDB per memorizzare i dati. Inserisci una password root, un nome utente MySQL, una password MySQL e il nome del database per FileRun. Effettuiamo il backup del database montandolo nella directory ~/dockerfilerun/db.
• Successivamente, scarichiamo il container FileRun che si connette all’immagine MariaDB utilizzando le stesse credenziali del database. Esegue anche il server Apache in-house ed espone FileRun tramite la porta 80. Montiamo anche una directory pubblica sull’host nella directory ~/dockerfilerun/html e i corrispondenti file caricati dagli utenti nella directory ~/dockerfilerun/user-files.
• Successivamente, scarichiamo il container Apache Tika che aiuta Filerun a leggere i metadati dei file.
• Infine, scarichiamo il container Elasticsearch che aiuta a eseguire una ricerca full-text sui contenuti caricati su FileRun. FileRun supporta solo Elasticsearch 6.8.x al momento. Puoi utilizzare le variabili ambientali per controllare il limite di memoria rispetto alla memoria disponibile sul tuo server. Montiamo i dati di Elasticsearch nella directory ~/dockerfilerun/esearch.

Crea la directory per Elasticsearch. Docker crea directory per i volumi automaticamente, ma Elasticsearch funziona solo quando la directory locale è di proprietà dell’utente e il gruppo ha 1000 come ID.

$ mkdir esearch

Imposta i permessi corretti utilizzando i seguenti comandi.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Prima di avviare il container, dobbiamo aumentare i limiti sui conteggi mmap affinché Elasticsearch funzioni. Apri il file /etc/sysctl.conf per la modifica.

$ sudo nano /etc/sysctl.conf

Incolla la seguente riga in fondo.

vm.max_map_count = 262144

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Questo renderà la modifica permanente, ma solo se riavvii il sistema.

Esegui il seguente comando per implementare la modifica subito.

$ sudo sysctl -w vm.max_map_count=262144

Riavvia il servizio Docker.

$ sudo systemctl restart docker

Passo 4 - Esegui il Container Docker di FileRun

Esegui il seguente comando per avviare il container Docker.

$ docker compose up -d

Il processo richiederà del tempo per completarsi, inclusi il download delle immagini Docker, la creazione di una rete e l’avvio dei container richiesti.

Controlla lo stato dei container.

$ docker ps

Riceverai un output simile.

Il passo successivo è installare SSL utilizzando Nginx per renderlo più sicuro. Utilizzeremo il server Nginx per farlo.

Passo 5 - Installa Nginx

CentOS/Rocky Linux/Alma Linux

Per installare l’ultima versione di Nginx, devi installare il repository ufficiale di Nginx.

Installa il pacchetto pre-requisito.

$ sudo dnf install yum-utils

Crea e apri il repository yum di Nginx.

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

Incolla il seguente codice.

[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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Installa Nginx.

$ sudo dnf install nginx

Abilita e avvia il server Nginx.

$ sudo systemctl start nginx --now

Configura SELinux per consentire connessioni di rete da Filerun.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 e Debian 11 vengono forniti con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.

Importa la chiave di firma di Nginx.

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

Aggiungi il repository per la versione stabile di 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

Per Debian, utilizza il seguente comando invece.

$ 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

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.1

Passo 6 - Installa SSL

Ubuntu/Debian

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.

Ubuntu 22.04 e Debian 11 vengono forniti con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.

$ sudo snap install core

Installa Certbot.

$ sudo snap install --classic certbot

Utilizza il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

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

CentOS/Rocky Linux/Alma Linux

Certbot richiede il repository EPEL per funzionare.

$ sudo dnf install epel-release

Utilizzeremo Snapd per installare Certbot. Installa Snapd.

$ sudo dnf install snapd

Abilita e avvia il servizio Snap.

$ sudo systemctl enable snapd --now

Installa il pacchetto core di Snap.

$ sudo snap install core
$ sudo snap refresh core

Crea i collegamenti necessari affinché Snapd funzioni.

$ 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

Esegui il seguente comando per installare Certbot.

$ sudo snap install --classic certbot

Abilita Certbot creando il collegamento simbolico al suo eseguibile.

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

Esegui il seguente comando per generare un certificato SSL.

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

Abbiamo generato il certificato SSL utilizzando l’opzione certonly di Certbot utilizzando Nginx. Installa il certificato utilizzando il server Nginx ma non modifica nulla.

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/filerun.example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

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

Per verificare se il rinnovo SSL funziona correttamente, esegui un test del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 7 - Configura Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/filerun.conf per la modifica.

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

Incolla il seguente codice al suo interno. Sostituisci filerun.example.com con il tuo nome di dominio.

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

   # Abilita le versioni TLS (TLSv1.3 è richiesto per il prossimo HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Abilita il 0-RTT di TLSv1.3. Usa $ssl_early_data quando fai reverse proxy per
   # prevenire attacchi di replay.
   #
   # @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 --- recupera i record OCSP dall'URL nel ssl_certificate e memorizzali nella 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;
   }
}

# Questo blocco è utile per il debug di TLS v1.3. Sentiti libero di rimuoverlo
# e utilizzare direttamente la variabile `$ssl_early_data` esposta da NGINX se lo desideri.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione Nginx.

$ sudo nginx -t

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Passo 8 - Accedi e Configura FileRun

Visita l’URL https://filerun.example.com e vedrai la seguente schermata.

Clicca sul pulsante Avanti per aprire la pagina dei requisiti di sistema.

Se tutto è a posto, clicca sul pulsante Avanti per passare alla pagina di configurazione del database.

Compila il nome del tuo database, utente e password, e clicca sul pulsante Avanti per procedere.

Qui ti verranno forniti i dettagli di accesso. Clicca sul pulsante Avanti per aprire la pagina di accesso.

Inserisci le tue credenziali di accesso dal passaggio precedente e clicca sul pulsante Accedi per aprire il dashboard di FileRun.

Clicca sul link Superuser in basso a sinistra dello schermo e clicca su Impostazioni Account.

Clicca sulla scheda Cambia password per accedere alla seguente pagina dove puoi cambiare la tua password predefinita. Clicca sul pulsante Salva modifiche per salvare.

Clicca sul link Pannello di Controllo in basso a sinistra della pagina per accedere al Pannello di Controllo di FileRun. Visita la sezione File >> Ricerca della pagina. Qui abiliteremo alcune funzionalità avanzate di ricerca file e OCR.

Inserisci http://elasticsearch:9200 come URL dell’host ElasticSearch. L’hostname si riferisce al nome del servizio di Elastic nel file docker. Clicca sul pulsante Test server per testare se funziona correttamente.

Dovresti ricevere un output simile sopra che conferma che funziona correttamente.

Inserisci tika come hostname del server Apache Tika. Inserisci 9998 come numero di porta. Seleziona il pulsante OCR PDF Files. Clicca sul pulsante Test server per testare se funziona correttamente.

Dovresti ricevere un output simile per il server Tika che conferma che funziona correttamente. Inoltre, clicca sul pulsante OCR image files. Clicca sul pulsante Salva modifiche in cima alla pagina.

Successivamente, cambia il valore dell’opzione Criteri di ricerca predefiniti da Nome a Contenuti per abilitare la ricerca full-text. Clicca nuovamente sul pulsante Salva modifiche per completare il processo.

Passo 9 - Aggiorna FileRun

Aggiornare FileRun è un passaggio semplice. Passa alla directory di composizione Docker di FileRun.

$ cd ~/dockerfilerun

Successivamente, ferma e rimuovi il container esistente. I tuoi dati verranno comunque mantenuti.

$ docker compose down --remove-orphans

Scarica l’ultima versione dell’immagine Docker di FileRun.

$ docker compose pull

Avvia nuovamente i container.

$ docker compose up -d

La tua installazione di FileRun è aggiornata e avviata nuovamente.

Conclusione

Questo conclude il tutorial in cui hai imparato come installare il software di hosting file FileRun utilizzando Docker su un server Linux. Se hai domande, pubblicale nei commenti qui sotto.