Cómo instalar FileRun utilizando Docker

FileRun es una aplicación web autoalojada para sincronizar y compartir archivos. Puede ejecutarse en cualquier servidor, incluyendo Linux, Windows, NAS, etc. Se puede acceder a los archivos desde la web y el móvil mediante una aplicación PWA. Es compatible con Nextcloud, por lo que puedes utilizar sus aplicaciones de escritorio y móvil para acceder a tus archivos. También puedes acceder a los archivos utilizando el protocolo WebDAV. FileRun también puede utilizarse como sustituto de Google Fotos y es compatible con plugins de oficina y de imagen.

FileRun está disponible como versión gratuita, que admite hasta 10 cuentas, y como versión empresarial, si quieres más funciones y cuentas. En este tutorial, aprenderás a instalar FileRun utilizando un entorno Docker en tu servidor Linux. También configuraremos Elasticsearch para que admita búsquedas de texto completo.

Requisitos previos

• Un servidor Linux con un mínimo de 2 núcleos de CPU y 2 GB de RAM. Este tutorial funcionará en todas las distribuciones de Linux.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completo (FQDN) que apunte al servidor. Para nuestros propósitos, utilizaremos filerun.example.com como 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 los paquetes de utilidades básicas. Es posible que algunos ya estén 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 cortafuegos

Cent OS/Rocky Linux/Alma Linux

Deberías tener instalado el cortafuegos Firewalld. Comprueba el estado del cortafuegos.

$ sudo firewall-cmd --state
running

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

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

Recarga el cortafuegos para activar los cambios.

$ sudo firewall-cmd --reload

Ubuntu/Debian

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

Comprueba si el cortafuegos se está ejecutando.

$ sudo ufw status

Si lo está, abre los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abre el puerto SSH si el cortafuegos no se está ejecutando.

$ sudo ufw allow "OpenSSH"

Habilita el cortafuegos si no se está ejecutando.

$ sudo ufw enable

Si se está ejecutando, vuelve a cargarlo para aplicar los cambios.

$ sudo ufw reload

Paso 2 – Instala 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 te aparece 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

Añade tu nombre de usuario al grupo Docker.

$ sudo usermod -aG docker $USER

Sal del sistema y vuelve a entrar para aplicar el cambio.

Paso 3 – Crear la Configuración Docker de FileRun

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

$ mkdir dockerfilerun

Cambia al directorio.

$ cd ~/dockerfilerun

Crea y abre el archivo Docker compose para editarlo.

$ nano docker-compose.yml

Pega en él el siguiente código.

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 pulsando Ctrl + X e introduciendo Y cuando se te pida.

Repasemos el archivo de composición.

• En primer lugar, extraemos la imagen docker MariaDB para almacenar los datos. Introduce una contraseña de root, un nombre de usuario MySQL, una contraseña MySQL y el nombre de la base de datos para FileRun. Hacemos una copia de seguridad de la base de datos montándola en el directorio ~/dockerfilerun/db.
• A continuación, tiramos del contenedor FileRun, que se conecta a la imagen MariaDB utilizando las mismas credenciales de la base de datos. También ejecuta el servidor interno Apache 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 correspondientes archivos subidos por el usuario en el directorio ~/dockerfilerun/user-files.
• A continuación, tiramos del contenedor Apache Tika, que ayuda a Filerun a leer los metadatos de los archivos.
• Y, por último, tiramos del contenedor Elasticsearch, que ayuda a ejecutar una búsqueda de texto completo en el contenido cargado en FileRun. Por el momento, FIleRun sólo es compatible con Elasticsearch 6.8.x. Puedes utilizar 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 sólo funciona cuando el directorio local es propiedad del usuario y el grupo tiene 1000 como 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 de los recuentos mmap para que Elasticsearch funcione. Abre el archivo /etc/sysctl.conf para editarlo.

$ sudo nano /etc/sysctl.conf

Pega la siguiente línea en la parte inferior.

vm.max_map_count = 262144

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Esto hará que el cambio sea permanente, pero sólo si reinicias el sistema.

Ejecuta el siguiente comando para aplicar el cambio ahora mismo.

$ sudo sysctl -w vm.max_map_count=262144

Reinicia el servicio Docker.

$ sudo systemctl restart docker

Paso 4 – Ejecuta el Contenedor Docker FileRun

Ejecuta el siguiente comando para lanzar el contenedor Docker.

$ docker compose up -d

El proceso tardará algún tiempo en completarse, lo que incluye la obtención de las imágenes Docker, la creación de una red y el lanzamiento de los contenedores necesarios.

Comprueba el estado de los contenedores.

$ docker ps

Obtendrás un resultado similar.

El siguiente paso es instalar SSL utilizando Nginx para hacerlo más seguro. Para ello utilizaremos el servidor Nginx.

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 de requisitos previos.

$ 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 pulsando Ctrl + X e introduciendo Y cuando se te pida.

Instala Nginx.

$ sudo dnf install nginx

Habilita e inicia el servidor Nginx.

$ sudo systemctl start nginx --now

Configura SELinux para permitir las conexiones de red desde Filerun.

$ sudo setsebool -P httpd_can_network_connect on

Ubuntu/Debian

Ubuntu 22.04 y Debian 11 incluyen una versión antigua de Nginx. Para instalar la última versión, debes 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

Añade el repositorio de 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, utiliza en su lugar el siguiente 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

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 utilizando el repositorio de Ubuntu o descargar la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión 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

Utiliza el siguiente comando para asegurarte de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.

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

CentOS/Rocky Linux/Alma Linux

Certbot necesita el repositorio EPEL para funcionar.

$ sudo dnf install epel-release

Utilizaremos Snapd para instalar Certbot. Instala Snapd.

$ sudo dnf install snapd

Activa e inicia el servicio Snap.

$ sudo systemctl enable snapd --now

Instala el paquete central 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

Ejecuta 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 mediante la opción certonly de Certbot utilizando 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 de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

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

Para comprobar si la renovación SSL funciona correctamente, realiza una ejecución en seco del proceso.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Paso 7 – Configurar Nginx

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

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

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

Pega en él el siguiente código. Sustituye filerun.example.com por el nombre de tu 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 "";
}

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Comprueba la configuración de Nginx.

$ sudo nginx -t

Reinicia el servidor Nginx.

$ sudo systemctl restart nginx

Paso 8 – Acceder y configurar FileRun

Accede a 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 es correcto, haz clic en el botón Siguiente para pasar a la página de configuración de la base de datos.

Introduce el nombre de la base de datos, el usuario y la contraseña, y pulsa el botón Siguiente para continuar.

Aquí se te proporcionarán los datos de acceso. Pulsa el botón Siguiente para abrir la página de inicio de sesión.

Introduce tus credenciales de inicio de sesión del paso anterior y pulsa el botón Iniciar sesión para abrir el panel de control de FileRun.

Haz clic en el enlace Superusuario situado 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 en la que puedes cambiar tu contraseña predeterminada. Haz clic en el botón Guardar cambios para guardarla.

Haz clic en el enlace Panel de Control de 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.

Introduce http://elasticsearch:9200 como URL del Host de ElasticSearch. El Hostname se refiere al nombre del servicio de Elastic en el archivo docker. Haz clic en el botón Probar servidor para comprobar si funciona correctamente.

Deberías obtener una salida similar a la anterior que confirme que funciona correctamente.

Introduce tika como nombre de host del Servidor Apache Tika. Introduce 9998 como número de puerto. Marca el botón OCR Archivos PDF. Pulsa el botón Probar servidor para comprobar que funciona correctamente.

Deberías obtener una salida similar para el servidor Tika que confirme que funciona correctamente. Haz clic también en el botón Archivos de imagen OCR. 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 Contenido para activar la búsqueda de texto completo. Vuelve a hacer clic en el botón Guardar cambios para finalizar el proceso.

Paso 9 – Actualizar FileRun

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

$ cd ~/dockerfilerun

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

$ docker compose down --remove-orphans

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

$ docker compose pull

Inicia de nuevo los contenedores.

$ docker compose up -d

Tu instalación de FileRun se actualizará y se iniciará de nuevo.

Conclusión

Con esto concluye el tutorial en el que has aprendido a instalar el software de alojamiento de archivos FileRun utilizando Docker en un servidor Linux. Si tienes alguna pregunta, publícala en los comentarios a continuación.