Cómo instalar FileRun usando Docker

FileRun es una aplicación web de sincronización y compartición de archivos autohospedada. Puede ejecutarse en cualquier servidor, incluyendo Linux, Windows, NAS, etc. Los archivos son accesibles en la web y en dispositivos móviles utilizando una aplicación PWA. Es compatible con Nextcloud, por lo que puedes usar sus aplicaciones de escritorio y móviles para acceder a tus archivos. También puedes acceder a los archivos utilizando el protocolo WebDAV. FileRun también puede usarse como un reemplazo de Google Photos y tiene soporte para complementos de oficina e imagen.

FileRun está disponible en una versión gratuita que puede soportar hasta 10 cuentas y como una versión empresarial si deseas más funciones y cuentas. En este tutorial, aprenderás cómo instalar FileRun utilizando un entorno Docker en tu servidor Linux. También configuraremos Elasticsearch para proporcionar soporte de búsqueda de texto completo.

Requisitos previos

• Un servidor Linux con un mínimo de 2 núcleos de CPU y 2GB de RAM. Este tutorial funcionará en cualquier distribución de Linux.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completamente calificado (FQDN) que apunte al servidor. Para nuestros propósitos, usaremos filerun.example.com como el nombre de dominio.
• Asegúrate de que todo esté actualizado. ## Ubuntu/Debian $ sudo apt update && sudo apt upgrade ## CentOS/Fedora/Rocky Linux/AlmaLinux $ sudo dnf update
• Instala paquetes de utilidad básicos. Algunos de estos pueden ya 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

Paso 1 - Configurar el Firewall

Cent OS/Rocky Linux/Alma Linux

Deberías tener instalado el firewall Firewalld. Verifica el estado del firewall.

$ sudo firewall-cmd --state
running

Abre los puertos 80, 9443 y 443. Portainer utiliza el puerto 9443 para exponer su interfaz web a través de HTTPS. Nginx Proxy Manager utiliza el puerto 81 para su interfaz.

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

Recarga el firewall para habilitar los cambios.

$ sudo firewall-cmd --reload

Ubuntu/Debian

Los sistemas Ubuntu y Debian utilizan ufw (Uncomplicated Firewall) por defecto.

Verifica si el firewall está en funcionamiento.

$ sudo ufw status

Si está en funcionamiento, abre los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abre el puerto SSH si el firewall no está en funcionamiento.

$ sudo ufw allow "OpenSSH"

Habilita el firewall si no está en funcionamiento.

$ sudo ufw enable

Si está en funcionamiento, recárgalo para aplicar los cambios.

$ sudo ufw reload

Paso 2 - Instalar Docker y Docker Compose

Ejecuta el siguiente comando para instalar 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

Es posible que obtengas el siguiente error al intentar instalar 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

Utiliza el siguiente comando si obtienes el error anterior.

$ 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

Habilita e inicia el servicio Docker.

$ sudo systemctl start docker --now

Agrega tu nombre de usuario al grupo Docker.

$ sudo usermod -aG docker $USER

Cierra sesión del sistema y vuelve a iniciar sesión para aplicar el cambio.

Paso 3 - Crear la Configuración de Docker de FileRun

Crea un directorio para la Configuración de Docker de Filerun.

$ mkdir dockerfilerun

Cambia al directorio.

$ cd ~/dockerfilerun

Crea y abre el archivo de composición de Docker para editar.

$ nano docker-compose.yml

Pega el siguiente código en él.

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

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te solicite.

Vamos a revisar el archivo de composición.

• Primero, descargamos la imagen de Docker de MariaDB para almacenar los datos. Ingresa una contraseña de root, nombre de usuario de MySQL, contraseña de MySQL y el nombre de la base de datos para FileRun. Respaldamos la base de datos montándola en el directorio ~/dockerfilerun/db.
• A continuación, descargamos el contenedor de FileRun que se conecta a la imagen de MariaDB utilizando las mismas credenciales de base de datos. También ejecuta el servidor Apache internamente y expone FileRun a través del puerto 80. También montamos un directorio público en el host en el directorio ~/dockerfilerun/html y los archivos subidos por el usuario en el directorio ~/dockerfilerun/user-files.
• Luego, descargamos el contenedor de Apache Tika que ayuda a FileRun a leer los metadatos de los archivos.
• Y por último, descargamos el contenedor de Elasticsearch que ayuda a ejecutar una búsqueda de texto completo en el contenido subido en FileRun. FileRun solo admite Elasticsearch 6.8.x en este momento. Puedes usar las variables de entorno para controlar el límite de memoria con respecto a la memoria disponible en tu servidor. Montaremos los datos de Elasticsearch en el directorio ~/dockerfilerun/esearch.

Crea el directorio para Elasticsearch. Docker crea directorios para volúmenes automáticamente, pero Elasticsearch solo funciona cuando el directorio local es propiedad del usuario y el grupo tiene 1000 como su ID.

$ mkdir esearch

Establece los permisos correctos utilizando los siguientes comandos.

$ chmod g+rwx esearch
$ sudo chgrp 1000 esearch

Antes de iniciar el contenedor, necesitamos aumentar los límites en los conteos de mmap para que Elasticsearch funcione. Abre el archivo /etc/sysctl.conf para editar.

$ sudo nano /etc/sysctl.conf

Pega la siguiente línea al final.

vm.max_map_count = 262144

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te solicite. Esto hará que el cambio sea permanente, pero solo si reinicias el sistema.

Ejecuta el siguiente comando para implementar el cambio ahora mismo.

$ sudo sysctl -w vm.max_map_count=262144

Reinicia el servicio Docker.

$ sudo systemctl restart docker

Paso 4 - Ejecutar el Contenedor Docker de FileRun

Ejecuta el siguiente comando para lanzar el contenedor Docker.

$ docker compose up -d

El proceso tomará algún tiempo para completarse, lo que incluye obtener las imágenes de Docker, crear una red y lanzar los contenedores requeridos.

Verifica el estado de los contenedores.

$ docker ps

Obtendrás una salida similar.

El siguiente paso es instalar SSL usando Nginx para hacerlo más seguro. Usaremos el servidor Nginx para hacerlo.

Paso 5 - Instalar Nginx

CentOS/Rocky Linux/Alma Linux

Para instalar la última versión de Nginx, necesitas instalar el repositorio oficial de Nginx.

Instala el paquete previo requerido.

$ sudo dnf install yum-utils

Crea y abre el repositorio yum de Nginx.

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

Pega el siguiente 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

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te solicite.

Instala Nginx.

$ sudo dnf install nginx

Habilita e inicia el servidor Nginx.

$ sudo systemctl start nginx --now

Configura SELinux para permitir conexiones de red desde FileRun.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 y Debian 11 vienen con una versión más antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

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

Agrega el repositorio para la versión estable de 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, usa el siguiente comando en su lugar.

$ 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

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.1

Paso 6 - Instalar SSL

Ubuntu/Debian

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot usando el repositorio de Ubuntu o obtener la última versión usando la herramienta Snapd. Usaremos la versión de Snapd.

Ubuntu 22.04 y Debian 11 vienen con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.

$ sudo snap install core

Instala Certbot.

$ sudo snap install --classic certbot

Usa el siguiente comando para asegurarte de que el comando Certbot pueda ejecutarse creando un enlace simbólico al directorio /usr/bin.

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

CentOS/Rocky Linux/Alma Linux

Certbot requiere el repositorio EPEL para funcionar.

$ sudo dnf install epel-release

Usaremos Snapd para instalar Certbot. Instala Snapd.

$ sudo dnf install snapd

Habilita e inicia el servicio Snap.

$ sudo systemctl enable snapd --now

Instala el paquete core de Snap.

$ sudo snap install core
$ sudo snap refresh core

Crea los enlaces necesarios para que Snapd funcione.

$ 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

Emite el siguiente comando para instalar Certbot.

$ sudo snap install --classic certbot

Habilita Certbot creando el enlace simbólico a su ejecutable.

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

Ejecuta el siguiente comando para generar un certificado SSL.

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

Hemos generado el certificado SSL utilizando la opción certonly de Certbot usando Nginx. Instala el certificado utilizando el servidor Nginx pero no modifica nada.

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/filerun.example.com en tu servidor.

Genera un certificado de grupo Diffie-Hellman.

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

Para verificar si la renovación de SSL está funcionando bien, haz una prueba del proceso.

$ sudo certbot renew --dry-run

Si no ves errores, estás listo. Tu certificado se renovará automáticamente.

Paso 7 - Configurar Nginx

Abre el archivo /etc/nginx/nginx.conf para editar.

$ sudo nano /etc/nginx/nginx.conf

Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te solicite.

Crea y abre el archivo /etc/nginx/conf.d/filerun.conf para editar.

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

Pega el siguiente código en él. Reemplaza filerun.example.com con tu nombre de 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; # Habilitar 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;

   # Habilitar versiones TLS (TLSv1.3 es requerido para el próximo HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Habilitar 0-RTT de TLSv1.3. Usa $ssl_early_data al hacer proxy inverso para
   # prevenir ataques de repetición.
   #
   # @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 --- obtener registros OCSP de la URL en ssl_certificate y almacenarlos en caché
   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;
   }
}

# Este bloque es útil para depurar TLS v1.3. Siéntete libre de eliminar esto
# y usar la variable `$ssl_early_data` expuesta por NGINX directamente si así lo
# deseas.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te solicite.

Verifica tu configuración de Nginx.

$ sudo nginx -t

Reinicia el servidor Nginx.

$ sudo systemctl restart nginx

Paso 8 - Acceder y Configurar FileRun

Visita la URL https://filerun.example.com y obtendrás la siguiente pantalla.

Haz clic en el botón Siguiente para abrir la página de requisitos del sistema.

Si todo está bien, haz clic en el botón Siguiente para avanzar a la página de configuración de la base de datos.

Completa el nombre de tu base de datos, usuario y contraseña, y haz clic en el botón Siguiente para continuar.

Aquí se te proporcionarán los detalles de inicio de sesión. Haz clic en el botón Siguiente para abrir la página de inicio de sesión.

Ingresa tus credenciales de inicio de sesión del paso anterior y haz clic en el botón Iniciar sesión para abrir el panel de control de FileRun.

Haz clic en el enlace Superusuario en la parte inferior izquierda de la pantalla y haz clic en Configuración de la Cuenta.

Haz clic en la pestaña Cambiar contraseña para acceder a la siguiente página donde puedes cambiar tu contraseña predeterminada. Haz clic en el botón Guardar cambios para guardar.

Haz clic en el enlace Panel de Control en la parte inferior izquierda de la página para acceder al Panel de Control de FileRun. Visita la sección Archivos >> Búsqueda de la página. Aquí habilitaremos algunas funciones avanzadas de búsqueda de archivos y OCR.

Ingresa http://elasticsearch:9200 como la URL del Host de ElasticSearch. El nombre del host se refiere al nombre del servicio de Elastic en el archivo docker. Haz clic en el botón Probar servidor para verificar si está funcionando correctamente.

Deberías obtener una salida similar a la anterior que confirma que está funcionando correctamente.

Ingresa tika como el nombre del servidor Apache Tika. Ingresa 9998 como el número de puerto. Marca el botón OCR PDF Files. Haz clic en el botón Probar servidor para verificar si está funcionando correctamente.

Deberías obtener una salida similar para el servidor Tika que confirma que está funcionando correctamente. Además, marca el botón OCR image files. Haz clic en el botón Guardar cambios en la parte superior de la página.

A continuación, cambia el valor de la opción Criterios de búsqueda predeterminados de Nombre a Contenidos para habilitar la búsqueda de texto completo. Haz clic en el botón Guardar cambios nuevamente para finalizar el proceso.

Paso 9 - Actualizar FileRun

Actualizar FileRun es un paso simple. Cambia al directorio de composición de Docker de FileRun.

$ cd ~/dockerfilerun

A continuación, detén y elimina el contenedor existente. Tus datos se conservarán.

$ docker compose down --remove-orphans

Descarga la última versión de la imagen de Docker de FileRun.

$ docker compose pull

Inicia los contenedores nuevamente.

$ docker compose up -d

Tu instalación de FileRun está actualizada y se ha iniciado nuevamente.

Conclusión

Esto concluye el tutorial donde aprendiste cómo instalar el software de alojamiento de archivos FileRun utilizando Docker en un servidor Linux. Si tienes alguna pregunta, publícalas en los comentarios a continuación.