Como Instalar o FileRun Usando Docker

FileRun é uma aplicação web de sincronização e compartilhamento de arquivos auto-hospedada. Pode ser executado em qualquer servidor, incluindo Linux, Windows, NAS, etc. Os arquivos são acessíveis na web e em dispositivos móveis usando um aplicativo PWA. É compatível com o Nextcloud, então você pode usar seus aplicativos de desktop e móveis para acessar seus arquivos. Você também pode acessar os arquivos usando o protocolo WebDAV. O FileRun também pode ser usado como um substituto do Google Fotos e tem suporte para plugins de escritório e imagem.

O FileRun está disponível em uma versão gratuita que suporta até 10 contas e em uma versão empresarial se você quiser mais recursos e contas. Neste tutorial, você aprenderá como instalar o FileRun usando um ambiente Docker em seu servidor Linux. Também configuraremos o Elasticsearch para fornecer suporte à pesquisa de texto completo.

Pré-requisitos

• Um servidor Linux com um mínimo de 2 núcleos de CPU e 2GB de RAM. Este tutorial funcionará em qualquer distribuição Linux.
• Um usuário não-root com privilégios sudo.
• Um nome de domínio totalmente qualificado (FQDN) apontando para o servidor. Para nossos propósitos, usaremos filerun.example.com como o nome de domínio.
• Certifique-se de que tudo está atualizado. ## Ubuntu/Debian $ sudo apt update && sudo apt upgrade ## CentOS/Fedora/Rocky Linux/AlmaLinux $ sudo dnf update
• Instale pacotes utilitários básicos. Alguns desses podem já estar instalados. ## 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 - Configurar o Firewall

Cent OS/Rocky Linux/Alma Linux

Você deve ter o firewall Firewalld instalado. Verifique o status do firewall.

$ sudo firewall-cmd --state
running

Abra as portas 80, 9443 e 443. O Portainer usa a porta 9443 para expor sua interface web via HTTPS. O Nginx Proxy Manager usa a porta 81 para sua interface.

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

Recarregue o firewall para habilitar as mudanças.

$ sudo firewall-cmd --reload

Ubuntu/Debian

Sistemas Ubuntu e Debian usam ufw (Uncomplicated Firewall) por padrão.

Verifique se o firewall está em execução.

$ sudo ufw status

Se estiver em execução, abra as portas HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abra a porta SSH se o firewall não estiver em execução.

$ sudo ufw allow "OpenSSH"

Habilite o firewall se não estiver em execução.

$ sudo ufw enable

Se estiver em execução, recarregue-o para aplicar as mudanças.

$ sudo ufw reload

Passo 2 - Instalar Docker e Docker Compose

Execute o seguinte comando para instalar o 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

Você pode receber o seguinte erro ao tentar instalar o 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

Use o seguinte comando se você receber o erro acima.

$ 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

Habilite e inicie o serviço Docker.

$ sudo systemctl start docker --now

Adicione seu nome de usuário ao grupo Docker.

$ sudo usermod -aG docker $USER

Desconecte-se do sistema e faça login novamente para aplicar a mudança.

Passo 3 - Criar Configuração Docker do FileRun

Crie um diretório para a Configuração Docker do Filerun.

$ mkdir dockerfilerun

Mude para o diretório.

$ cd ~/dockerfilerun

Crie e abra o arquivo de composição Docker para edição.

$ nano docker-compose.yml

Cole o seguinte código nele.

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

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Vamos passar pelo arquivo de composição.

• Primeiro, puxamos a imagem Docker do MariaDB para armazenar os dados. Insira uma senha root, nome de usuário MySQL, senha MySQL e o nome do banco de dados para o FileRun. Fazemos backup do banco de dados montando-o no diretório ~/dockerfilerun/db.
• Em seguida, puxamos o contêiner do FileRun que se conecta à imagem do MariaDB usando as mesmas credenciais do banco de dados. Ele também executa o servidor Apache internamente e expõe o FileRun pela porta 80. Também montamos um diretório público no host no diretório ~/dockerfilerun/html e os arquivos enviados pelo usuário no diretório ~/dockerfilerun/user-files.
• Em seguida, puxamos o contêiner Apache Tika que ajuda o Filerun a ler os metadados dos arquivos.
• E por último, puxamos o contêiner Elasticsearch que ajuda a executar uma pesquisa de texto completo no conteúdo enviado ao FileRun. O FileRun suporta apenas Elasticsearch 6.8.x no momento. Você pode usar as variáveis de ambiente para controlar o limite de memória em relação à memória disponível em seu servidor. Montaremos os dados do Elasticsearch no diretório ~/dockerfilerun/esearch.

Crie o diretório para o Elasticsearch. O Docker cria diretórios para volumes automaticamente, mas o Elasticsearch só funciona quando o diretório local é de propriedade do usuário e o grupo tem 1000 como seu ID.

$ mkdir esearch

Defina as permissões corretas usando os seguintes comandos.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Antes de iniciar o contêiner, precisamos aumentar os limites nas contagens de mmap para que o Elasticsearch funcione. Abra o arquivo /etc/sysctl.conf para edição.

$ sudo nano /etc/sysctl.conf

Cole a seguinte linha no final.

vm.max_map_count = 262144

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado. Isso tornará a mudança permanente, mas apenas se você reiniciar o sistema.

Execute o seguinte comando para implementar a mudança agora.

$ sudo sysctl -w vm.max_map_count=262144

Reinicie o serviço Docker.

$ sudo systemctl restart docker

Passo 4 - Executar o Contêiner Docker do FileRun

Execute o seguinte comando para iniciar o contêiner Docker.

$ docker compose up -d

O processo levará algum tempo para ser concluído, incluindo a obtenção das imagens Docker, a criação de uma rede e o lançamento dos contêineres necessários.

Verifique o status dos contêineres.

$ docker ps

Você receberá uma saída semelhante.

O próximo passo é instalar SSL usando Nginx para torná-lo mais seguro. Usaremos o servidor Nginx para fazer isso.

Passo 5 - Instalar Nginx

CentOS/Rocky Linux/Alma Linux

Para instalar a versão mais recente do Nginx, você precisa instalar o repositório oficial do Nginx.

Instale o pacote pré-requisito.

$ sudo dnf install yum-utils

Crie e abra o repositório yum do Nginx.

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

Cole o seguinte código.

[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

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Instale o Nginx.

$ sudo dnf install nginx

Habilite e inicie o servidor Nginx.

$ sudo systemctl start nginx --now

Configure o SELinux para permitir conexões de rede do Filerun.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 e Debian 11 vêm com uma versão mais antiga do Nginx. Para instalar a versão mais recente, você precisa baixar o repositório oficial do Nginx.

Importe a chave de assinatura do Nginx.

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

Adicione o repositório para a versão estável do 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

Para Debian, use o seguinte comando em vez disso.

$ 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

Atualize os repositórios do sistema.

$ sudo apt update

Instale o Nginx.

$ sudo apt install nginx

Verifique a instalação.

$ nginx -v
nginx version: nginx/1.22.1

Passo 6 - Instalar SSL

Ubuntu/Debian

Precisamos instalar o Certbot para gerar o certificado SSL. Você pode instalar o Certbot usando o repositório do Ubuntu ou pegar a versão mais recente usando a ferramenta Snapd. Usaremos a versão Snapd.

Ubuntu 22.04 e Debian 11 vêm com o Snapd instalado por padrão. Execute os seguintes comandos para garantir que sua versão do Snapd esteja atualizada.

$ sudo snap install core

Instale o Certbot.

$ sudo snap install --classic certbot

Use o seguinte comando para garantir que o comando Certbot possa ser executado criando um link simbólico para o diretório /usr/bin.

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

CentOS/Rocky Linux/Alma Linux

O Certbot requer o repositório EPEL para funcionar.

$ sudo dnf install epel-release

Usaremos o Snapd para instalar o Certbot. Instale o Snapd.

$ sudo dnf install snapd

Habilite e inicie o serviço Snap.

$ sudo systemctl enable snapd --now

Instale o pacote core do Snap.

$ sudo snap install core
$ sudo snap refresh core

Crie links necessários para o Snapd funcionar.

$ 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

Emita o seguinte comando para instalar o Certbot.

$ sudo snap install --classic certbot

Habilite o Certbot criando o link simbólico para seu executável.

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

Execute o seguinte comando para gerar um Certificado SSL.

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

Geramos o certificado SSL usando a opção certonly do Certbot usando o Nginx. Ele instala o certificado usando o servidor Nginx, mas não modifica nada.

O comando acima fará o download de um certificado para o diretório /etc/letsencrypt/live/filerun.example.com em seu servidor.

Gere um certificado de grupo Diffie-Hellman.

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

Para verificar se a renovação do SSL está funcionando bem, faça um teste do processo.

$ sudo certbot renew --dry-run

Se você não ver erros, está tudo certo. Seu certificado será renovado automaticamente.

Passo 7 - Configurar Nginx

Abra o arquivo /etc/nginx/nginx.conf para edição.

$ sudo nano /etc/nginx/nginx.conf

Adicione a seguinte linha antes da linha include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Crie e abra o arquivo /etc/nginx/conf.d/filerun.conf para edição.

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

Cole o seguinte código nele. Substitua filerun.example.com pelo seu nome de domínio.

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-GCM-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 "";
}

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Verifique sua configuração do Nginx.

$ sudo nginx -t

Reinicie o servidor Nginx.

$ sudo systemctl restart nginx

Passo 8 - Acessar e Configurar o FileRun

Visite a URL https://filerun.example.com e você verá a seguinte tela.

Clique no botão Próximo para abrir a página de requisitos do sistema.

Se tudo estiver ok, clique no botão Próximo para avançar para a página de configuração do banco de dados.

Preencha seu nome de banco de dados, usuário e senha, e clique no botão Próximo para prosseguir.

Aqui você receberá os detalhes de login. Clique no botão Próximo para abrir a página de login.

Digite suas credenciais de login da etapa anterior e clique no botão Entrar para abrir o painel do FileRun.

Clique no link Superusuário na parte inferior esquerda da tela e clique em Configurações da Conta.

Clique na aba Alterar senha para acessar a seguinte página onde você pode alterar sua senha padrão. Clique no botão Salvar alterações para salvar.

Clique no link Painel de Controle na parte inferior esquerda da página para acessar o Painel de Controle do FileRun. Visite a seção Arquivos >> Pesquisa da página. Aqui habilitaremos alguns recursos avançados de pesquisa de arquivos e OCR.

Digite http://elasticsearch:9200 como a URL do Host do ElasticSearch. O Nome do Host refere-se ao nome do serviço do Elastic no arquivo docker. Clique no botão Testar servidor para testar se está funcionando corretamente.

Você deve obter uma saída semelhante acima que confirma que está funcionando corretamente.

Digite tika como o nome do servidor Apache Tika. Digite 9998 como o número da porta. Marque o botão OCR PDF Files. Clique no botão Testar servidor para testar se está funcionando corretamente.

Você deve obter uma saída semelhante para o servidor Tika que confirma que está funcionando corretamente. Além disso, clique no botão OCR image files. Clique no botão Salvar alterações na parte superior da página.

Em seguida, altere o valor da opção Critérios de pesquisa padrão de Nome para Conteúdos para habilitar a pesquisa de texto completo. Clique no botão Salvar alterações novamente para finalizar o processo.

Passo 9 - Atualizar o FileRun

Atualizar o FileRun é um passo simples. Mude para o diretório de composição Docker do FileRun.

$ cd ~/dockerfilerun

Em seguida, pare e remova o contêiner existente. Seus dados serão mantidos, no entanto.

$ docker compose down --remove-orphans

Puxe a versão mais recente da imagem Docker do FileRun.

$ docker compose pull

Inicie os contêineres novamente.

$ docker compose up -d

Sua instalação do FileRun está atualizada e iniciada novamente.

Conclusão

Este conclui o tutorial onde você aprendeu como instalar o software de hospedagem de arquivos FileRun usando Docker em um servidor Linux. Se você tiver alguma dúvida, poste nos comentários abaixo.