Come installare FileRun utilizzando Docker

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
1. Cent OS/Rocky Linux/Alma Linux
2. Ubuntu/Debian
1. CentOS/Rocky Linux/Alma Linux
2. Ubuntu
3. Debian
1. CentOS/Rocky Linux/Alma Linux
2. Ubuntu/Debian
1. Ubuntu/Debian
2. CentOS/Rocky Linux/Alma Linux
FileRun è una sincronizzazione di file self-hosted e condivide un'applicazione basata sul Web. Può essere eseguito 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. È inoltre possibile accedere ai file utilizzando il protocollo WebDAV. FileRun può anche essere utilizzato come sostituto di Google Foto e supporta plug-in per ufficio e immagini.

FileRun è disponibile come versione gratuita che può supportare fino a 10 account e come versione aziendale se desideri più funzionalità e account. In questo tutorial imparerai come installare FileRun utilizzando un ambiente Docker sul tuo server Linux. Inoltre, configureremo Elasticsearch per fornire il supporto per la ricerca full-text.
Prerequisiti
- A Linux server with a minimum of 2 CPU cores and 2GB of RAM. This tutorial will run on every Linux distribution.
- A non-root user with sudo privileges.
- A fully qualified domain name (FQDN) pointing to the server. For our purposes, we will use filerun.example.com as the domain name.
- Make sure everything is updated.
```
## Ubuntu/Debian
$ sudo apt update && sudo apt upgrade

## CentOS/Fedora/Rocky Linux/AlmaLinux
$ sudo dnf update
```
- Install basic utility packages. Some of these may already be installed.
```
## Ubuntu/Debian
$ sudo apt install wget curl nano unzip -y

## CentOS/Rocky Linux/AlmaLinux
$ sudo dnf install wget curl nano unzip yum-utils -y
```
Passaggio 1: configurare il firewall
Sistema operativo Cent/Rocky Linux/Alma Linux
Dovresti avere il firewall Firewalld installato. Controlla lo stato dei firewall.
```
$ sudo firewall-cmd --state
running
```
Apri le porte 80, 9443 e 443. Portainer utilizza la porta 9443 per esporre la sua interfaccia utente Web tramite HTTPS. Nginx Proxy Manager utilizza la porta 81 per la sua interfaccia utente.
```
$ 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
```
Passaggio 2: installa Docker e Docker Compose
Eseguire 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
```
È possibile che venga visualizzato il seguente errore durante il tentativo di installazione di Docker.
```
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
```
Utilizzare il seguente comando se si ottiene 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
```
Disconnettersi dal sistema e riconnettersi per applicare la modifica.
Passaggio 3: creare la configurazione Docker di FileRun
Crea una directory per Filerun Docker Configuration.
```
$ mkdir dockerfilerun
```
Passa alla rubrica.
```
$ 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 immettendo Y quando richiesto.
Esaminiamo il file di composizione.
- Per prima cosa, estraiamo l'immagine docker di MariaDB per l'archiviazione dei dati. Inserisci una password root, nome utente MySQL, password MySQL e il nome del database per FileRun. Facciamo il backup del database montandolo nella directory ~/dockerfilerun/db.
- Successivamente, estraiamo il contenitore FileRun che si connette all'immagine MariaDB utilizzando le stesse credenziali del database. Inoltre esegue internamente il server Apache ed espone FileRun tramite la porta 80. Montiamo anche una directory pubblica sull'host nella directory ~/dockerfilerun/html e i corrispondenti file caricati dall'utente nella ~/dockerfilerun/user-files directory.
- Successivamente, estraiamo il contenitore Apache Tika che aiuta Filerun a leggere i metadati dei file.
- E infine, estraiamo il contenitore Elasticsearch che aiuta a eseguire una ricerca full-text sui contenuti caricati su FileRun. FIleRun supporta solo Elasticsearch 6.8.x al momento. È possibile utilizzare le variabili di ambiente per controllare il limite di memoria rispetto alla memoria disponibile sul server. Monteremo i dati di Elasticsearch nella directory ~/dockerfilerun/esearch.
Crea la directory per Elasticsearch. Docker crea automaticamente le directory per i volumi, ma Elasticsearch funziona solo quando la directory locale è di proprietà dell'utente e il gruppo ha 1000 come ID.
```
$ mkdir esearch
```
Impostare le autorizzazioni corrette utilizzando i seguenti comandi.
```
$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch
```
Prima di avviare il contenitore, dobbiamo aumentare i limiti sui conteggi mmap affinché Elasticsearch funzioni. Apri il file /etc/sysctl.conf per modificarlo.
```
$ sudo nano /etc/sysctl.conf
```
Incolla la seguente riga in basso.
```
vm.max_map_count = 262144
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto. Ciò renderà permanente la modifica, ma solo se si riavvia il sistema.
Esegui il seguente comando per implementare subito la modifica.
```
$ sudo sysctl -w vm.max_map_count=262144
```
Riavvia il servizio Docker.
```
$ sudo systemctl restart docker
```
Passaggio 4: eseguire il contenitore Docker FileRun
Eseguire il comando seguente per avviare il contenitore Docker.
```
$ docker compose up -d
```
Il processo richiederà del tempo per essere completato, il che include l'acquisizione delle immagini Docker, la creazione di una rete e l'avvio dei contenitori richiesti.
Controlla lo stato dei contenitori.
```
$ docker ps
```
Otterrai un risultato simile.
Il passaggio successivo consiste nell'installare SSL utilizzando Nginx per renderlo più sicuro. Useremo il server Nginx per farlo.
Passaggio 5: installa Nginx
CentOS/Rocky Linux/Alma Linux
Per installare l'ultima versione di Nginx, devi installare il repository Nginx ufficiale.
Installa il pacchetto prerequisito.
```
$ 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 immettendo Y quando richiesto.
Installa Nginx.
```
$ sudo dnf install nginx
```
Abilita e avvia il server Nginx.
```
$ sudo systemctl start nginx --now
```
Configura SELinux per consentire le 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 precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.
Importa la chiave di firma Nginxs.
```
$ 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 Nginxs.
```
$ 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, usa invece il seguente comando.
```
$ 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
```
Verificare l'installazione.
```
$ nginx -v
nginx version: nginx/1.22.1
```
Passaggio 6: installa SSL
Ubuntu/Debian
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo 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 Cerbot.
```
$ sudo snap install --classic certbot
```
Utilizzare il seguente comando per assicurarsi 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 che il repository EPEL funzioni.
```
$ sudo dnf install epel-release
```
Useremo Snapd per installare Certbot. Installa Snapd.
```
$ sudo dnf install snapd
```
Abilita e avvia il servizio Snap.
```
$ sudo systemctl enable snapd --now
```
Installa il pacchetto principale 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
```
Immetti il seguente comando per installare Certbot.
```
$ sudo snap install --classic certbot
```
Abilita Certbot creando il link simbolico al suo eseguibile.
```
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
```
Eseguire il seguente comando per generare un certificato SSL.
```
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -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 precedente 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, eseguire un'esecuzione a secco del processo.
```
$ sudo certbot renew --dry-run
```
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 7: configurare Nginx
Apri il file /etc/nginx/nginx.conf per la modifica.
```
$ sudo nano /etc/nginx/nginx.conf
```
Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
```
server_names_hash_bucket_size  64;
```
Salva il file premendo Ctrl + X e immettendo 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; # 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 "";
}
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Verifica la configurazione di Nginx.
```
$ sudo nginx -t
```
Riavvia il server Nginx.
```
$ sudo systemctl restart nginx
```
Passaggio 8: accedere e configurare FileRun
Visita l'URL https://filerun.example.com e otterrai la seguente schermata.
Fare clic sul pulsante Avanti per aprire la pagina dei requisiti di sistema.
Se tutto è a posto, fare clic sul pulsante Avanti per passare alla pagina di configurazione del database.
Inserisci il nome del database, l'utente e la password e fai clic sul pulsante Avanti per procedere.
Qui ti verranno forniti i dati di accesso. Fare clic sul pulsante Avanti per aprire la pagina di accesso.
Inserisci le credenziali di accesso del passaggio precedente e fai clic sul pulsante Accedi per aprire la dashboard di FileRuns.
Fare clic sul collegamento Superutente nella parte inferiore più a sinistra dello schermo e fare clic su Impostazioni account.
Fare clic sulla scheda Modifica password per accedere alla pagina seguente in cui è possibile modificare la password predefinita. Fare clic sul pulsante Salva modifiche per salvare.
Fare clic sul collegamento 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 funzioni avanzate di ricerca file e OCR.
Inserisci http://elasticsearch:9200 come URL dell'host ElasticSearch. Il nome host fa riferimento al nome del servizio Elastics nel file docker. Fare clic sul pulsante Test server per verificare se funziona correttamente.
Dovresti ottenere un output simile sopra che conferma che funziona correttamente.
Immettere tika come nome host del server Apache Tika. Inserisci 9998 come numero di porta. Seleziona il pulsante File PDF OCR. Fare clic sul pulsante Test server per verificare se funziona correttamente.
Dovresti ottenere un output simile per il server Tika che conferma che funziona correttamente. Inoltre, fare clic sul pulsante File immagine OCR. Fai clic sul pulsante Salva modifiche nella parte superiore della pagina.
Successivamente, modifica il valore dell'opzione Criteri di ricerca predefiniti da Nome a Contenuto per abilitare la ricerca full-text. Fare di nuovo clic sul pulsante Salva modifiche per terminare il processo.
Passaggio 9: aggiorna FileRun
L'aggiornamento di FileRun è un passaggio semplice. Passa alla directory di composizione Docker di FileRuns.
```
$ cd ~/dockerfilerun
```
Successivamente, arresta e rimuovi il contenitore esistente. I tuoi dati verranno comunque conservati.
```
$ docker compose down --remove-orphans
```
Estrai l'ultima versione dell'immagine docker FileRun.
```
$ docker compose pull
```
Riavvia i contenitori.
```
$ docker compose up -d
```
L'installazione di FileRun viene aggiornata e riavviata.
Conclusione
Questo conclude il tutorial in cui hai imparato come installare il software di file hosting FileRun utilizzando Docker su un server Linux. Se hai domande, pubblicale nei commenti qui sotto.

Come installare FileRun utilizzando Docker

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Sistema operativo Cent/Rocky Linux/Alma Linux

Ubuntu/Debian

Passaggio 2: installa Docker e Docker Compose

CentOS/Rocky Linux/Alma Linux

Ubuntu

Debian

Passaggio 3: creare la configurazione Docker di FileRun

Passaggio 4: eseguire il contenitore Docker FileRun

Passaggio 5: installa Nginx

CentOS/Rocky Linux/Alma Linux

Ubuntu/Debian

Passaggio 6: installa SSL

Ubuntu/Debian

CentOS/Rocky Linux/Alma Linux

Passaggio 7: configurare Nginx

Passaggio 8: accedere e configurare FileRun

Passaggio 9: aggiorna FileRun

Conclusione