# Ejecutar un servidor de colaboración

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](/docs/collaboration/server-access/#browser-access) 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](/security/). 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.

## Qué guarda el servidor

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.

### Quién puede leer los proyectos

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.

## Lo que necesitas

- **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](#without-a-public-address).
- **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](/docs/collaboration/server-access/).

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](https://github.com/Oleafly/oleafly-server/releases). El servidor como un único programa de Linux está en la [página de versiones de Oleafly](https://github.com/Oleafly/Oleafly/releases).

## Elige cómo ejecutarlo

| Opción | Cuándo usarla |
| --- | --- |
| [Un comando](#install-with-one-command) | Una 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 mano](#docker-compose-by-hand) | Prefieres colocar y editar cada archivo tú mismo. |
| [Coolify](#coolify) | Ya gestionas un servidor Coolify. |
| [Render](#render) o [Railway](#railway) | Prefieres pagar un servicio de alojamiento a ocuparte de una máquina. |
| [Linux sin Docker](#linux-without-docker) | Una 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](/docs/collaboration/server-operations/#settings) enumera todas.

## Instalar con un solo comando

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

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](/docs/collaboration/server-access/#sign-in-providers), 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`.

:::note[Durante la beta]
Instala la versión candidata, Oleafly Server 0.1.1-rc, para que el servidor coincida con Oleafly 0.4.7-rc:

```sh
curl -fsSL https://github.com/Oleafly/oleafly-server/releases/download/server-v0.1.1-rc/install.sh | sudo sh
```

El comando de abajo instala la 0.1.0, que es más antigua. Si ejecutas la imagen de otra manera, como con Compose, Coolify, Render o Railway, usa `ghcr.io/oleafly/oleafly-server:0.1.1-rc`.
:::

Después ejecuta:

```sh
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](https://github.com/Oleafly/oleafly-server/releases) 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](#become-the-first-admin).

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.

### Lee primero el instalador

Si tu institución no permite canalizar un script hacia un shell, descarga `install.sh` y `SHA256SUMS` de la [última versión](https://github.com/Oleafly/oleafly-server/releases/latest) en una misma carpeta. Comprueba el script, léelo y luego ejecútalo:

```sh
sha256sum --check --ignore-missing SHA256SUMS
sudo sh install.sh
```

### Instalar sin preguntas

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.

```sh
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, actualizaciones y desinstalación

- **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](/docs/collaboration/server-operations/#updating). 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.

  ```sh
  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](https://github.com/Oleafly/oleafly-server/issues/new/choose) con lo que imprimió.

## Docker Compose a mano

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.

1. Instala Docker Engine y el plugin de Compose siguiendo [las instrucciones de Docker](https://docs.docker.com/engine/install/).
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:

   ```sh
   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](/docs/collaboration/server-access/#sign-in-providers). 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.

   ```sh
   sudo docker compose up -d
   ```

6. Comprueba que responde. Esto imprime `200`:

   ```sh
   curl -sS -o /dev/null -w '%{http_code}\n' https://collab.example.org/healthz
   ```

7. [Conviértete en el primer administrador](#become-the-first-admin). El código de configuración está en el registro:

   ```sh
   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`.

### Mantener los secretos fuera de .env

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`:

```sh
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.

```yaml
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

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](#deploy-the-published-image), que se salta la compilación.

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](/docs/collaboration/server-access/#github), con la dirección de callback `https://collab.example.org/auth/callback/github`. Ten a mano su ID de cliente y su secreto.

### Compilar desde el repositorio

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](#become-the-first-admin) 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.

### Desplegar la imagen publicada

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.

## Render

[Deploy to Render](https://render.com/deploy?repo=https://github.com/Oleafly/Oleafly) 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](/docs/collaboration/server-access/#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](#become-the-first-admin).

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

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](https://github.com/Oleafly/Oleafly/releases). 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](/docs/collaboration/server-access/#github). La dirección de callback es tu dirección del paso 2 con `https://` delante y `/auth/callback/github` detrás.

   ```ini
   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](#become-the-first-admin).

## Linux sin Docker

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

### Descargar el servidor

Cada versión del servidor en la [página de versiones](https://github.com/Oleafly/Oleafly/releases) 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`:

```sh
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.

```sh
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.

### Ejecutarlo con systemd

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

   ```sh
   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.

   ```ini
   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:

   ```sh
   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:

```ini
[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`.

### Poner HTTPS delante

Instala Caddy con [sus instrucciones para tu distribución](https://caddyserver.com/docs/install). 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](/docs/collaboration/server-operations/#behind-a-reverse-proxy).

## Sin dirección pública

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.

1. Sigue los pasos de [Docker Compose a mano](#docker-compose-by-hand) 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:

   ```sh
   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:

   ```sh
   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](#become-the-first-admin).

En una máquina sin Docker, instala `cloudflared` desde el [repositorio de paquetes de Cloudflare](https://pkg.cloudflare.com/), 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`.

## Convertirte en el primer administrador

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](/docs/collaboration/server-access/#access-rules) explica cómo.

## Comprobar el servidor

- 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](/docs/collaboration/server-access/#admin-console) ejecuta las mismas comprobaciones.
