Ir al contenido
Oleaflyv0.4.12

Ejecutar un servidor

Qué almacena Oleafly Server, qué necesita y cómo instalarlo con un solo comando, o ejecutarlo con Docker Compose, Coolify, Render, Railway o un servicio de Linux sencillo, y después convertirte en su primer administrador.

Oleafly Server es el servidor de colaboración que hay detrás de la colaboración en tiempo real. Tu laboratorio, departamento o institución lo ejecuta en sus propias máquinas o en su propia cuenta en la nube. Las personas lo añaden en Oleafly e inician sesión con una cuenta que ya tienen, como GitHub o el acceso de una universidad. Cuando alguien comparte un proyecto en el servidor, las personas que añade reciben una copia completa que se mantiene sincronizada mientras editan. Con el acceso desde el navegador activado, también pueden abrirlo en un navegador web.

Esta guía es para la persona que gestiona el servidor de un laboratorio, un curso o un grupo de coautores. Conviene que te manejes con una terminal. Algunas configuraciones también te piden editar un archivo de configuración. No necesitas escribir código.

Para tu revisión de seguridad, lee Seguridad del servidor. Cubre el autoalojamiento, el inicio de sesión, las claves de dispositivo, los cambios firmados, los registros de seguridad y de acceso, y la imagen del contenedor con su lista de materiales de software.

El servidor lo guarda todo en una carpeta de datos, definida por OLEAFLY_DATA_DIR:

  • Cuentas: el nombre visible de cada miembro, la dirección de su avatar, sus direcciones de correo verificadas, y su ID de usuario y su nombre de usuario en el proveedor de inicio de sesión. El servidor nunca ve ni almacena una contraseña.
  • Dispositivos: cada ordenador que inició sesión, con su nombre, su sistema operativo, su clave pública y cuándo se vio por última vez. Los tokens de inicio de sesión se almacenan solo como hashes.
  • El registro de seguridad: inicios de sesión e inicios de sesión rechazados, dispositivos añadidos y con la sesión cerrada, cambios en miembros, roles y ajustes, proyectos compartidos, archivados y restaurados, cambios en quién puede abrir un proyecto e invitaciones de invitados. Cada entrada lleva la hora y la dirección IP.
  • Ajustes del servidor que los administradores cambian en Oleafly.
  • Registros de acceso a proyectos, para los proyectos cuyo propietario activa uno: quién abrió el proyecto, se unió a él o descargó una copia, con el nombre del dispositivo y la hora. Solo el propietario del proyecto puede leerlo.
  • Invitaciones de invitados: la dirección de correo invitada, el proyecto, el rol y quién la envió.
  • Proyectos compartidos: todos los archivos y el historial completo de cambios, con los comentarios, las sugerencias, el chat y los nombres de versión que les pertenecen.
  • PDF compilados: para cada proyecto compartido, el PDF más reciente, con su archivo SyncTeX, que la aplicación de un propietario o un editor envió tras una compilación correcta, con quién lo compiló y cuándo.

Las entradas del registro de seguridad y de los registros de acceso, y las invitaciones de invitados respondidas o caducadas, se eliminan pasados OLEAFLY_SECURITY_LOG_DAYS días, 365 por defecto. Los archivos que un proyecto ya no usa, como la copia antigua de una figura reemplazada, se eliminan 30 días después de que el proyecto los usó por última vez. Cada PDF compilado reemplaza al anterior. Cuando un propietario deja de compartir un proyecto, el servidor lo conserva en modo de solo lectura durante OLEAFLY_ARCHIVE_DAYS días, 30 por defecto, y después lo elimina. Durante ese tiempo solo el propietario y los administradores que estén en el proyecto pueden descargarlo.

Los proyectos no están cifrados en el servidor. Cualquiera que pueda leer la carpeta de datos, el disco de la máquina o tus copias de seguridad puede leer todos los proyectos almacenados allí. Eso incluye a quien gestiona la máquina y a la empresa que la aloja.

Dentro de Oleafly las reglas son más estrictas. Ningún rol de servidor, administrador incluido, puede abrir un proyecto a menos que el propietario del proyecto lo haya añadido. Si un proyecto debe quedar fuera del alcance de quienes gestionan un servidor, ejecuta un servidor aparte para él.

El ordenador de cada miembro también guarda una copia completa de cada proyecto compartido con él. Pide a los miembros que activen el cifrado de disco, como FileVault en macOS, BitLocker en Windows o LUKS en Linux.

  • Una máquina que se quede encendida. Sirve cualquier máquina Linux, o una cuenta en un servicio de alojamiento como Render o Railway. Una máquina virtual pequeña basta para empezar. Vigila su memoria y su disco a medida que crezcan los proyectos. El servidor funciona en x86-64 y ARM.
  • Un nombre de dominio para el servidor, como collab.example.org, con un registro DNS que apunte a la máquina. Render y Railway te dan una dirección si no tienes ninguna. Si la máquina no tiene dirección pública, lee Sin dirección pública.
  • Una forma de que las personas inicien sesión: al menos un proveedor de inicio de sesión, como una aplicación OAuth de GitHub o el acceso de tu institución. El servidor no arranca sin uno. Una cuenta de correo desde la que el servidor pueda enviar es opcional. Con ella, un administrador también puede permitir que las personas inicien sesión con un enlace por correo. Lee Inicio de sesión y acceso.

Cada versión se publica como una imagen de contenedor, ghcr.io/oleafly/oleafly-server. El instalador y sus archivos de Compose están en la página de versiones de Oleafly Server (se abre en una pestaña nueva). El servidor como un único programa de Linux está en la página de versiones de Oleafly (se abre en una pestaña nueva).

OpciónCuándo usarla
Un comandoUna máquina Linux de la que te ocupas tú. El instalador configura Docker, Caddy y HTTPS, y hace unas pocas preguntas. Empieza aquí si no estás seguro.
Docker Compose a manoPrefieres colocar y editar cada archivo tú mismo.
CoolifyYa gestionas un servidor Coolify.
Render o RailwayPrefieres pagar un servicio de alojamiento a ocuparte de una máquina.
Linux sin DockerUna máquina virtual de la universidad en la que no puedes usar Docker.

El servidor lee sus ajustes de variables de entorno. Almacenamiento, copias de seguridad y límites enumera todas.

En una máquina Linux de la que te ocupas tú, el instalador lo configura todo y solo pregunta lo que necesita saber.

Qué hace el instaladorEl instalador sigue seis pasos en orden. Comprueba que la máquina usa Linux en x86-64 o ARM y que los puertos 80 y 443 están libres. Instala Docker si falta, después de preguntar. Descarga los archivos de la versión y comprueba cada uno con SHA256SUMS. Pregunta el dominio, el nombre del servidor, cómo inicia sesión la gente y, si quieres, el correo. Escribe los ajustes en .env e inicia el servidor con Caddy en /opt/oleafly-server. Cuando el servidor responde por HTTPS, muestra el código de configuración para el primer administrador.Comprobar la máquinaLinux, x86-64 o ARMPuertos 80 y 443 libresDockerSe instala si falta,después de preguntarteDescargar y verificarLos archivos de la versión,comprobados con SHA256SUMSUnas preguntasDominio, nombre del servidor,inicio de sesión, correoArrancarServidor y Caddyen /opt/oleafly-serverCódigo de configuraciónSe muestra cuandoel servidor respondeQué hace el instaladorEl instalador sigue seis pasos en orden. Comprueba que la máquina usa Linux en x86-64 o ARM y que los puertos 80 y 443 están libres. Instala Docker si falta, después de preguntar. Descarga los archivos de la versión y comprueba cada uno con SHA256SUMS. Pregunta el dominio, el nombre del servidor, cómo inicia sesión la gente y, si quieres, el correo. Escribe los ajustes en .env e inicia el servidor con Caddy en /opt/oleafly-server. Cuando el servidor responde por HTTPS, muestra el código de configuración para el primer administrador.Comprobar la máquinaLinux, x86-64 o ARMPuertos 80 y 443 libresDockerSe instala si falta,después de preguntarteDescargar y verificarLos archivos de la versión,comprobados con SHA256SUMSUnas preguntasDominio, nombre del servidor,inicio de sesión, correoArrancarServidor y Caddyen /opt/oleafly-serverCódigo de configuraciónSe muestra cuandoel servidor responde
Un solo comando: comprobación, Docker, descarga y verificación, unas preguntas, arranque y luego el código de configuración.

Antes de ejecutarlo, comprueba que:

  • La máquina ejecuta Linux en x86-64 o ARM, como Ubuntu 24.04 o Debian 13, y puedes usar sudo en ella.
  • Nada más en la máquina usa los puertos 80 y 443. Abre los puertos TCP 80 y 443 y el puerto UDP 443 en cualquier cortafuegos que haya delante.
  • El registro DNS de tu dominio apunta a la máquina. Si todavía no lo hace, la instalación termina igualmente, y Caddy sigue intentando obtener un certificado hasta que el registro esté en su sitio.
  • Tienes los datos de al menos un proveedor de inicio de sesión, como el ID de cliente y el secreto de una aplicación OAuth de GitHub. Para GitHub, la dirección de callback es https:// y tu dominio, seguidos de /auth/callback/github.

Después ejecuta:

Ventana del terminal
curl -fsSL https://oleafly.com/server/install.sh | sudo sh

El instalador:

  1. Comprueba la máquina y que los puertos 80 y 443 están libres.
  2. Comprueba si hay Docker. Si falta, el instalador pregunta antes de instalarlo con el propio script de Docker.
  3. Descarga los archivos de la versión más reciente de las versiones de Oleafly Server (se abre en una pestaña nueva) y comprueba cada uno con el SHA256SUMS de la versión. Si un archivo no coincide, se detiene sin cambiar nada.
  4. Pide tu dominio, el nombre del servidor y cómo inician sesión las personas. También ofrece configurar el correo y guardar los archivos en un bucket de S3. Ambos son opcionales.
  5. Muestra un resumen y pregunta antes de cambiar nada. Después escribe sus archivos en /opt/oleafly-server, con tus ajustes en .env, que solo puede leer root.
  6. Arranca el servidor con Caddy delante, espera a que tu dominio responda por HTTPS e imprime la dirección y el código de configuración.

Después conviértete en el primer administrador.

Puedes volver a ejecutar el instalador en cualquier momento. Cuando encuentra un servidor en /opt/oleafly-server, deja .env como está, restituye los demás archivos y reinicia el servidor. Eso repara la mayoría de las configuraciones rotas.

Tus datos están en el volumen de Docker oleafly-server_oleafly-data. Para instalar en un sitio distinto de /opt/oleafly-server, define OLEAFLY_DIR, por ejemplo curl -fsSL https://oleafly.com/server/install.sh | sudo OLEAFLY_DIR=/srv/oleafly sh, y usa esa carpeta en los comandos de abajo.

Si tu institución no permite canalizar un script hacia un shell, descarga install.sh y SHA256SUMS de la última versión (se abre en una pestaña nueva) en una misma carpeta. Comprueba el script, léelo y luego ejecútalo:

Ventana del terminal
sha256sum --check --ignore-missing SHA256SUMS
sudo sh install.sh

Para un script o una herramienta de aprovisionamiento, añade --yes y pasa las respuestas como variables de entorno. OLEAFLY_INSTALL_DOCKER=yes permite que el instalador añada Docker si falta.

Ventana del terminal
curl -fsSL https://oleafly.com/server/install.sh | sudo \
OLEAFLY_DOMAIN=collab.example.org \
OLEAFLY_SERVER_NAME='Smith Lab' \
OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId \
OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret \
OLEAFLY_INSTALL_DOCKER=yes \
sh -s -- --yes

El instalador usa sin preguntar cualquier ajuste que encuentre en el entorno, con o sin --yes. sudo sh /opt/oleafly-server/install.sh --help los enumera todos, incluidos OpenID Connect, el correo y S3. Los valores escritos en una línea de comandos pueden acabar en el historial de tu shell, así que una herramienta de aprovisionamiento debería pasar los secretos desde su propio almacén de secretos.

  • Estado: sudo sh /opt/oleafly-server/install.sh status muestra si el servidor está en marcha y si tu dominio responde por HTTPS con un certificado válido.

  • Actualización: haz primero una copia de seguridad, como explica Actualizar. Después ejecuta el comando de abajo. Descarga los archivos y la imagen de la versión más reciente, conserva .env, reinicia el servidor y espera a que responda. Las personas conectadas se reconectan solas. El instalador nunca pasa un servidor a una versión anterior.

    Ventana del terminal
    curl -fsSL https://oleafly.com/server/install.sh | sudo sh -s -- update
  • Desinstalación: sudo sh /opt/oleafly-server/install.sh uninstall detiene y elimina los contenedores. Tus datos y .env se quedan, salvo que escribas delete cuando lo pregunte. Eliminarlos borra todos los proyectos compartidos del servidor, todas las cuentas y el registro de seguridad. Las personas conservan sus propias copias de los proyectos en sus ordenadores.

Si el instalador se detiene con un problema que no puedes resolver, infórmalo (se abre en una pestaña nueva) con lo que imprimió.

Esta configuración ejecuta dos contenedores. oleafly-server es el servidor, y solo otros contenedores pueden llegar a él. caddy obtiene un certificado de Let’s Encrypt, sirve HTTPS en los puertos 80 y 443 y pasa las solicitudes al servidor, incluidas las conexiones en tiempo real.

Despliegue con Docker ComposeOleafly en cada ordenador se conecta por HTTPS a Caddy en tu máquina. Caddy tiene el certificado y pasa las peticiones por HTTP sin cifrar al contenedor oleafly-server. El servidor guarda su base de datos y sus archivos en un volumen de datos de Docker, y puede guardar los archivos en un bucket de S3.Tu máquina, con Docker ComposeOleaflyEn cadaordenadorCaddyHTTPScertificadooleafly-serverAjustes en .envVolumen de datosBase de datos,archivosBucket de S3OpcionalDespliegue con Docker ComposeOleafly en cada ordenador se conecta por HTTPS a Caddy en tu máquina. Caddy tiene el certificado y pasa las peticiones por HTTP sin cifrar al contenedor oleafly-server. El servidor guarda su base de datos y sus archivos en un volumen de datos de Docker, y puede guardar los archivos en un bucket de S3.Tu máquina, con Docker ComposeOleaflyEn cada ordenadorCaddyCertificado HTTPSoleafly-serverAjustes en .envVolumen de datosBase de datos, archivosBucket de S3Opcional, archivosHTTPSHTTP
Docker Compose: Caddy gestiona el HTTPS delante del servidor, y el volumen de datos guarda la base de datos y los archivos.
  1. Instala Docker Engine y el plugin de Compose siguiendo las instrucciones de Docker (se abre en una pestaña nueva).

  2. Haz que el registro DNS de tu dominio apunte a la máquina. Abre los puertos TCP 80 y 443 y el puerto UDP 443 en cualquier cortafuegos que haya delante. Caddy necesita el puerto 80 para obtener el certificado.

  3. Crea una carpeta para el servidor, descarga en ella los archivos de la versión más reciente, compruébalos y crea tu archivo de ajustes:

    Ventana del terminal
    sudo mkdir -p /opt/oleafly-server && cd /opt/oleafly-server
    base=https://github.com/Oleafly/oleafly-server/releases/latest/download
    for f in docker-compose.yml Caddyfile env.example litestream.yml SHA256SUMS; do sudo curl -fsSLO "$base/$f"; done
    sha256sum --check --ignore-missing SHA256SUMS
    sudo install -m 600 env.example .env
  4. Edita .env con sudoedit .env. Define OLEAFLY_DOMAIN con tu dominio sin https://, define OLEAFLY_SERVER_NAME y rellena al menos un proveedor de inicio de sesión. Deja vacías las líneas de los proveedores que no uses. Pon un valor entre comillas simples si contiene $ o #.

  5. Arráncalo. El primer arranque descarga la imagen del servidor, ghcr.io/oleafly/oleafly-server, en la misma versión que los archivos.

    Ventana del terminal
    sudo docker compose up -d
  6. Comprueba que responde. Esto imprime 200:

    Ventana del terminal
    curl -sS -o /dev/null -w '%{http_code}\n' https://collab.example.org/healthz
  7. Conviértete en el primer administrador. El código de configuración está en el registro:

    Ventana del terminal
    sudo docker compose logs oleafly-server | grep 'Setup code'

Tus datos están en el volumen de Docker oleafly-server_oleafly-data. Caddy guarda sus certificados en oleafly-server_caddy-data.

Docker abre por sí mismo los puertos 80 y 443, incluso cuando hay un cortafuegos en el host como ufw. Eso es lo que necesita Caddy. No añadas una entrada ports: al servicio oleafly-server. Para llegar al servidor desde la propia máquina, publícalo como 127.0.0.1:8080:8080 para que no quede expuesto a la red.

Si cambias el Caddyfile, ejecuta sudo docker compose up -d --force-recreate caddy. Para actualizar más adelante, descarga los archivos de la versión nueva de la misma manera y vuelve a ejecutar sudo docker compose up -d.

Siete ajustes pueden contener secretos: OLEAFLY_SETUP_CODE, OLEAFLY_GITHUB_CLIENT_SECRET, OLEAFLY_OIDC_<NAME>_CLIENT_SECRET, OLEAFLY_SMTP_URL, OLEAFLY_BLOB_STORE, OLEAFLY_S3_ACCESS_KEY_ID y OLEAFLY_S3_SECRET_ACCESS_KEY. Cada uno tiene además una versión _FILE que nombra un archivo que contiene el valor. Define una de las dos, no ambas.

Por ejemplo, para pasar el secreto de cliente de GitHub como secreto de Docker, guárdalo en secrets/github_client_secret junto a docker-compose.yml, deja que lo lea el usuario del servidor (ID 10001) y borra la línea OLEAFLY_GITHUB_CLIENT_SECRET de .env:

Ventana del terminal
sudo chown 10001:10001 secrets/github_client_secret
sudo chmod 400 secrets/github_client_secret

Después crea docker-compose.override.yml junto a docker-compose.yml. Compose lo lee automáticamente, y el instalador no lo toca cuando actualiza los demás archivos.

services:
oleafly-server:
environment:
OLEAFLY_GITHUB_CLIENT_SECRET_FILE: /run/secrets/github_client_secret
secrets:
- github_client_secret
secrets:
github_client_secret:
file: ./secrets/github_client_secret

Vuelve a ejecutar sudo docker compose up -d.

Coolify pone su propio proxy delante del servidor y obtiene el certificado, así que esta configuración no tiene Caddy. Coolify puede compilar el servidor a partir del repositorio de Oleafly, o ejecutar la imagen publicada, que se salta la compilación.

Despliegue con CoolifyOleafly en cada ordenador se conecta, opcionalmente a través de Cloudflare, al proxy de Coolify, que gestiona el HTTPS y pasa las peticiones a oleafly-server. El servidor guarda sus datos en un volumen de Docker. Cuando Cloudflare está delante del proxy de Coolify, cada petición pasa por dos proxies, así que pon OLEAFLY_PROXY_HOPS a 2.OleaflyEn cadaordenadorCloudflareOpcionalProxy de CoolifyHTTPSoleafly-serverEn tu servidorde CoolifyVolumen de datosCon los dos delante, ponOLEAFLY_PROXY_HOPS=2Despliegue con CoolifyOleafly en cada ordenador se conecta, opcionalmente a través de Cloudflare, al proxy de Coolify, que gestiona el HTTPS y pasa las peticiones a oleafly-server. El servidor guarda sus datos en un volumen de Docker. Cuando Cloudflare está delante del proxy de Coolify, cada petición pasa por dos proxies, así que pon OLEAFLY_PROXY_HOPS a 2.OleaflyEn cada ordenadorCloudflareOpcionalProxy de CoolifyHTTPSoleafly-serverEn tu servidor de CoolifyVolumen de datosCon los dos delante, ponOLEAFLY_PROXY_HOPS=2
Coolify: su proxy gestiona el HTTPS. Si además tienes Cloudflare delante, pon OLEAFLY_PROXY_HOPS=2.

Antes de empezar, haz que el registro DNS de tu dominio, como collab.example.org, apunte al servidor de Coolify. Después crea la aplicación OAuth de GitHub como se describe en GitHub, con la dirección de callback https://collab.example.org/auth/callback/github. Ten a mano su ID de cliente y su secreto.

  1. En tu proyecto de Coolify, selecciona + New, luego Public Repository, e introduce https://github.com/Oleafly/Oleafly. Mantén la rama main.
  2. Define Build Pack como Docker Compose, Base Directory como / y Docker Compose Location como /deploy/server/docker-compose.coolify.yml, y luego selecciona Continue.
  3. En Advanced › Build, define Build arguments como Managed manually in Dockerfile. La imagen del servidor no necesita argumentos de compilación. Si se deja en automático, Coolify escribe todas las variables, secretos incluidos, en el historial de compilación de la imagen.
  4. En General, define el dominio de oleafly-server como https://collab.example.org:8080 y guarda. El :8080 le dice al proxy de Coolify en qué puerto escucha el servidor. Las personas siguen conectándose por el puerto HTTPS habitual, y Coolify define OLEAFLY_PUBLIC_URL como https://collab.example.org por ti.
  5. En Environment Variables, rellena OLEAFLY_SERVER_NAME, que Coolify marca como obligatorio, y después OLEAFLY_GITHUB_CLIENT_ID y OLEAFLY_GITHUB_CLIENT_SECRET. Deja vacías las variables que no uses.
  6. Selecciona Deploy. La primera compilación compila el servidor y tarda unos minutos. Cuando termina, Coolify muestra el recurso como en marcha y saludable.
  7. Abre https://collab.example.org/healthz en un navegador. Muestra {"status":"ok"}.
  8. Abre Logs, elige el contenedor oleafly-server y copia el código de la línea más reciente que empieza por Setup code:.
  9. Conviértete en el primer administrador con ese código.

Si el servidor no arranca, su registro nombra el ajuste que no puede usar. Cuando dice que OLEAFLY_PUBLIC_URL no está definido, falta el paso 4. Un dominio que empieza por http:// se rechaza, porque el servidor necesita HTTPS.

Si Cloudflare está delante de Coolify, porque tu registro DNS pasa por el proxy de Cloudflare o un túnel lleva al proxy de Coolify, define OLEAFLY_PROXY_HOPS como 2. Sin eso, el registro de seguridad muestra la dirección del proxy para todos, y todos comparten un único límite de inicios de sesión.

El archivo de Coolify tiene sitio para GitHub y para un proveedor de OpenID Connect llamado UNIVERSITY. Define OLEAFLY_OIDC_UNIVERSITY_LABEL con el texto que deben ver las personas, como GitLab. Su dirección de callback termina en /auth/callback/university. Para más proveedores, despliega desde un fork con tu propia copia del archivo.

Los datos están en un volumen de Docker cuyo nombre termina en oleafly-data. Encuéntralo con docker volume ls --filter name=oleafly-data. La imagen no tiene shell, así que la Terminal de Coolify no puede abrir una en el contenedor del servidor. Los registros y la comprobación de estado funcionan como de costumbre.

Ejecutar la imagen publicada se salta la compilación, lo que conviene a un servidor Coolify pequeño. Sigue los pasos anteriores con dos cambios. En el paso 2, define Docker Compose Location como /deploy/server/docker-compose.coolify-image.yml. Omite el paso 3, porque no se compila nada. El archivo sigue una serie de versiones, así que cada Redeploy descarga la versión más reciente de esa serie.

Deploy to Render (se abre en una pestaña nueva) lee el Blueprint del repositorio de Oleafly. Crea un servicio web a partir de la imagen publicada, con un disco de 1 GB para la carpeta de datos. Render solo asocia discos a los tipos de instancia de pago, así que el servicio arranca en el de pago más pequeño, en la región de Oregón de Render. Para otra región, despliega desde un fork con region definido en render.yaml.

  1. Abre el enlace e inicia sesión en Render.
  2. Render pide OLEAFLY_SERVER_NAME y el ID de cliente y el secreto de GitHub. Rellena el nombre y deja vacíos por ahora los campos de GitHub. Su dirección de callback depende de la dirección del servicio, que todavía no tienes.
  3. Selecciona Deploy Blueprint. Cuando el servicio esté activo, su página muestra su dirección, como https://oleafly-server.onrender.com. El Blueprint define OLEAFLY_PUBLIC_URL con esa dirección.
  4. Crea la aplicación OAuth de GitHub como se describe en GitHub, con esa dirección seguida de /auth/callback/github como dirección de callback. Añade el ID de cliente y el secreto en Environment del servicio. Render reinicia el servidor con ellos.
  5. Busca la línea Setup code: más reciente en Logs del servicio y conviértete en el primer administrador.

Si das al servicio tu propio dominio, define OLEAFLY_PUBLIC_URL con él en Environment y cambia la dirección de callback en GitHub para que coincida.

Por el disco, Render detiene el servidor en marcha antes de arrancar el nuevo, así que cada despliegue deja el servidor fuera de servicio unos segundos. Oleafly se reconecta solo.

Railway ejecuta la imagen publicada, con un volumen para la carpeta de datos.

  1. En un proyecto de Railway, selecciona + New, luego Docker Image, e introduce ghcr.io/oleafly/oleafly-server:latest. Para elegir cuándo actualizas, usa en su lugar la etiqueta propia de una versión de la página de versiones (se abre en una pestaña nueva). Railway puede iniciar un primer despliegue enseguida. Se detiene con OLEAFLY_PUBLIC_URL is not set, lo cual es de esperar en este punto.

  2. Abre el servicio. En Settings › Networking, selecciona Generate Domain e introduce el puerto 8080. Railway muestra la dirección, como oleafly-server-production.up.railway.app.

  3. En Settings › Deploy, define Healthcheck Path como /readyz.

  4. Haz clic derecho en el lienzo del proyecto, añade un volumen, asócialo al servicio del servidor y define su ruta de montaje como /data.

  5. En Variables, abre el Raw Editor y pega estas líneas con el nombre de tu propio servidor. Para los valores de GitHub, sigue GitHub. La dirección de callback es tu dirección del paso 2 con https:// delante y /auth/callback/github detrás.

    OLEAFLY_PUBLIC_URL=https://${{RAILWAY_PUBLIC_DOMAIN}}
    OLEAFLY_BIND=0.0.0.0:8080
    OLEAFLY_DATA_DIR=/data
    OLEAFLY_BEHIND_PROXY=true
    OLEAFLY_SERVER_NAME=Smith Lab
    OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId
    OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret
    PORT=8080
    RAILWAY_RUN_UID=0

    Railway monta los volúmenes como root. RAILWAY_RUN_UID=0 ejecuta el servidor como root para que pueda escribir en el volumen.

  6. Despliega los cambios. Busca la línea Setup code: más reciente en Deploy Logs del servicio y conviértete en el primer administrador.

En una máquina sin Docker, el servidor se ejecuta como un único programa bajo systemd, con Caddy delante para HTTPS.

Despliegue en Linux sin DockerOleafly en cada ordenador se conecta por HTTPS a Caddy en tu máquina Linux. Caddy pasa las peticiones a oleafly-server, que se ejecuta como servicio de systemd escuchando en 127.0.0.1 puerto 8080 y guarda sus datos en /var/lib/oleafly-server.Tu máquina LinuxOleaflyEn cadaordenadorCaddyHTTPScertificadooleafly-serverServicio de systemdCarpeta de datos/var/lib/oleafly-serverDespliegue en Linux sin DockerOleafly en cada ordenador se conecta por HTTPS a Caddy en tu máquina Linux. Caddy pasa las peticiones a oleafly-server, que se ejecuta como servicio de systemd escuchando en 127.0.0.1 puerto 8080 y guarda sus datos en /var/lib/oleafly-server.Tu máquina LinuxOleaflyEn cada ordenadorCaddyCertificado HTTPSoleafly-serverServicio de systemdCarpeta de datos/var/lib/oleafly-serverHTTPSHTTP
Linux sin Docker: systemd ejecuta el servidor, y Caddy delante gestiona el HTTPS.

Cada versión del servidor en la página de versiones (se abre en una pestaña nueva) tiene un programa ya compilado para x86-64 y para ARM, y un archivo SHA256SUMS con el que comprobarlo. El programa no necesita nada más instalado.

Descarga el archivo comprimido para tu máquina, que termina en x86_64-unknown-linux-musl.tar.gz o aarch64-unknown-linux-musl.tar.gz, y SHA256SUMS en una misma carpeta. Después compruébalo e instálalo. En una máquina ARM, usa aarch64 en lugar de x86_64:

Ventana del terminal
sha256sum --check --ignore-missing SHA256SUMS
tar -xzf oleafly-server-*-x86_64-unknown-linux-musl.tar.gz
sudo install -m 0755 oleafly-server-*-x86_64-unknown-linux-musl/oleafly-server /usr/local/bin/oleafly-server
oleafly-server --version

Con la CLI de GitHub instalada, gh attestation verify oleafly-server-*-x86_64-unknown-linux-musl.tar.gz --repo Oleafly/Oleafly también comprueba que GitHub compiló el archivo comprimido a partir del repositorio de Oleafly. El archivo comprimido incluye la unidad de systemd, oleafly-server.service.

Para compilar tú mismo el programa, ejecuta esto desde un clon del repositorio de Oleafly en cualquier ordenador con Docker. Usa --platform linux/arm64 para un servidor ARM.

Ventana del terminal
docker buildx build --platform linux/amd64 --target binary --output type=local,dest=dist -f crates/oleafly-server/Dockerfile .

Esto escribe dist/oleafly-server. Cópialo a /usr/local/bin/oleafly-server en el servidor y hazlo ejecutable.

  1. Crea el archivo de ajustes. Solo root puede leerlo:

    Ventana del terminal
    sudo install -d -m 0755 /etc/oleafly-server
    sudo install -m 0600 /dev/null /etc/oleafly-server/oleafly-server.env
    sudoedit /etc/oleafly-server/oleafly-server.env

    Pon un ajuste por línea. OLEAFLY_BIND=127.0.0.1:8080 mantiene el servidor fuera de la red para que solo Caddy pueda llegar a él. No definas OLEAFLY_DATA_DIR, porque la unidad lo define.

    OLEAFLY_PUBLIC_URL=https://collab.example.org
    OLEAFLY_BIND=127.0.0.1:8080
    OLEAFLY_BEHIND_PROXY=true
    OLEAFLY_SERVER_NAME=Smith Lab
    OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId
    OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret
  2. Instala y arranca la unidad desde el archivo comprimido descomprimido, o desde deploy/server en un clon del repositorio. Después busca el código de configuración:

    Ventana del terminal
    sudo install -m 0644 oleafly-server.service /etc/systemd/system/oleafly-server.service
    sudo systemctl daemon-reload
    sudo systemctl enable --now oleafly-server
    sudo journalctl -u oleafly-server | grep 'Setup code'

La unidad ejecuta el servidor como un usuario que systemd crea para él, con una vista de solo lectura del resto del sistema. El único sitio donde puede escribir es /var/lib/oleafly-server, donde guarda sus datos. En disco esa carpeta es /var/lib/private/oleafly-server.

Para mantener el secreto de cliente fuera del archivo de ajustes, usa una credencial de systemd. Guarda el secreto en /etc/oleafly-server/github-client-secret con modo 600, borra la línea OLEAFLY_GITHUB_CLIENT_SECRET del archivo de ajustes, ejecuta sudo systemctl edit oleafly-server y añade:

[Service]
LoadCredential=github-client-secret:/etc/oleafly-server/github-client-secret
Environment=OLEAFLY_GITHUB_CLIENT_SECRET_FILE=%d/github-client-secret

Después ejecuta sudo systemctl restart oleafly-server.

Instala Caddy con sus instrucciones para tu distribución (se abre en una pestaña nueva). Sustituye /etc/caddy/Caddyfile por estas líneas y ejecuta sudo systemctl reload caddy. Caddy obtiene el certificado y deja pasar las conexiones en tiempo real.

collab.example.org {
reverse_proxy 127.0.0.1:8080
}

Para nginx o Apache, o un servidor web que tu universidad ya gestione, lee Detrás de un proxy inverso.

Si la máquina no tiene dirección pública, por ejemplo un ordenador de tu laboratorio detrás del cortafuegos de la universidad, Cloudflare Tunnel puede hacerla accesible. Necesitas una cuenta de Cloudflare con tu dominio. Cloudflare gestiona HTTPS para el nombre de host, así que las solicitudes se descifran en la red de Cloudflare antes de llegar a tu máquina. Cuenta a Cloudflare entre las partes que pueden leer el tráfico hacia tu servidor.

Despliegue con Cloudflare TunnelOleafly en cada ordenador se conecta por HTTPS a Cloudflare. Un contenedor cloudflared en tu máquina abre un túnel hacia Cloudflare, así que la máquina no necesita una dirección pública. Las peticiones llegan por el túnel a cloudflared, que las pasa a oleafly-server.Tu máquina, sin dirección públicaOleaflyEn cadaordenadorCloudflareHTTPScloudflaredAbre el túneloleafly-serverVolumen de datosDespliegue con Cloudflare TunnelOleafly en cada ordenador se conecta por HTTPS a Cloudflare. Un contenedor cloudflared en tu máquina abre un túnel hacia Cloudflare, así que la máquina no necesita una dirección pública. Las peticiones llegan por el túnel a cloudflared, que las pasa a oleafly-server.Tu máquina, sin dirección públicaOleaflyEn cada ordenadorCloudflareHTTPScloudflaredAbre el túneloleafly-serverVolumen de datosTúnel
Cloudflare Tunnel: tu máquina abre el túnel por sí misma, así que no necesita una dirección pública.
  1. Sigue los pasos de Docker Compose a mano hasta editar .env. Define OLEAFLY_DOMAIN con el nombre de host que vayas a usar, como collab.example.org. El instalador de un solo comando no encaja aquí, porque arranca Caddy.

  2. Arranca solo el servidor. Aquí no hace falta Caddy:

    Ventana del terminal
    sudo docker compose up -d oleafly-server
  3. En el panel de Cloudflare, ve a Networking › Tunnels, selecciona Create Tunnel, ponle un nombre y vuelve a seleccionar Create Tunnel. Copia el token del comando de instalación que muestra.

  4. Arranca el túnel junto al servidor. El comando read espera a que pegues el token y no lo muestra:

    Ventana del terminal
    read -rs TUNNEL_TOKEN && export TUNNEL_TOKEN
    sudo --preserve-env=TUNNEL_TOKEN docker run -d --name oleafly-tunnel --restart unless-stopped --network oleafly-server_default -e TUNNEL_TOKEN cloudflare/cloudflared:2026.10.0 tunnel --no-autoupdate run
  5. De vuelta en el panel, abre el túnel. En Routes, selecciona Add route y luego Published application. En Hostname, introduce el subdominio y elige tu dominio. Define Service URL como http://oleafly-server:8080 y selecciona Add route.

  6. Comprueba que responde en https://collab.example.org/healthz y después conviértete en el primer administrador.

En una máquina sin Docker, instala cloudflared desde el repositorio de paquetes de Cloudflare (se abre en una pestaña nueva), ejecuta sudo cloudflared service install seguido del token y define Service URL como http://127.0.0.1:8080.

Cloudflare deja pasar las conexiones en tiempo real y pone la dirección del visitante al final de X-Forwarded-For, así que mantén OLEAFLY_BEHIND_PROXY=true. Cuando el túnel lleva a otro proxy, como el de Coolify, y no directamente al servidor, define también OLEAFLY_PROXY_HOPS=2. Cloudflare rechaza solicitudes de más de 100 MB en sus planes Free y Pro, así que define OLEAFLY_MAX_PROJECT_MB en 100 o menos, o los proyectos grandes no se podrán subir. No pongas Cloudflare Access delante del servidor, porque Oleafly no puede superar su página de inicio de sesión.

Cuando actualices el servidor más adelante, descarga los archivos de la versión nueva y nombra el servicio para que Caddy siga apagado: sudo docker compose up -d oleafly-server.

Un servidor nuevo no tiene administrador. Hasta que alguien termine la configuración, el servidor genera un nuevo código de configuración de un solo uso cada vez que arranca y lo escribe en su registro.

  1. Busca en el registro la línea más reciente que empieza por Setup code::
    • Instalación con un solo comando: el instalador lo imprime cuando termina. Para verlo otra vez, ejecuta cd /opt/oleafly-server && sudo docker compose logs oleafly-server | grep 'Setup code'
    • Docker Compose a mano: sudo docker compose logs oleafly-server | grep 'Setup code' en la carpeta del servidor
    • Coolify: los registros del servicio oleafly-server
    • systemd: sudo journalctl -u oleafly-server | grep 'Setup code'
  2. En Oleafly, abre Ajustes → Colaboración, selecciona Añadir servidor e introduce la dirección de tu servidor. Oleafly detecta que el servidor necesita configuración y pide el Código de configuración.
  3. Introduce el código e inicia sesión con cualquier proveedor que hayas configurado. Te conviertes en el administrador del servidor, y el código deja de funcionar.

Cualquiera que tenga el código antes de que lo uses puede hacerse administrador, así que pégalo únicamente en Oleafly.

También puedes elegir el código tú mismo con OLEAFLY_SETUP_CODE: al menos 12 letras o dígitos, con guiones o espacios si quieres. El servidor entonces nunca lo imprime. El registro solo dice Setup code: set by OLEAFLY_SETUP_CODE, e introduces el valor que definiste. Quítalo de tus ajustes cuando termine la configuración.

Después, deja entrar a las personas. Inicio de sesión y acceso explica cómo.

  • Con la instalación de un solo comando, sudo sh /opt/oleafly-server/install.sh status comprueba los contenedores y HTTPS de una vez.
  • https://collab.example.org/healthz responde 200 mientras el proceso del servidor está en marcha.
  • /readyz responde 200 solo mientras el servidor puede escribir en su base de datos y en su carpeta de datos. Cuando no puede, por ejemplo con el disco lleno, responde 503 y nombra lo que falló, database o storage.
  • La imagen de Docker comprueba /readyz por sí misma, así que docker ps y Coolify muestran un servidor no saludable en lugar de uno en marcha que no puede guardar nada.
  • En Oleafly, Probar la conexión en Ajustes → Colaboración comprueba la dirección, HTTPS, la versión, las conexiones en tiempo real, las opciones de inicio de sesión y el reloj del servidor. Pruebas de conexión en la consola de administración ejecuta las mismas comprobaciones.
Vista previa de la imagen

No se pudieron cargar las respuestas de la IA

Inténtalo de nuevo o busca en la documentación.