# Gérer un serveur de collaboration

Ce que Oleafly Server conserve, ce dont il a besoin, comment l'installer avec une seule commande ou l'exécuter avec Docker Compose, Coolify, Render, Railway ou un simple service Linux, puis devenir son premier administrateur.

Oleafly Server est le serveur de collaboration derrière la collaboration en direct. Votre laboratoire, votre département ou votre institution l'exécute sur ses propres machines ou dans son propre compte cloud. Les personnes l'ajoutent dans Oleafly et se connectent avec un compte qu'elles ont déjà, comme GitHub ou un compte universitaire. Quand quelqu'un partage un projet sur le serveur, les personnes qu'il ajoute en reçoivent une copie complète qui reste synchronisée pendant qu'elles modifient. Avec l'[accès par navigateur](/docs/collaboration/server-access/#browser-access) activé, elles peuvent aussi l'ouvrir dans un navigateur web.

Ce guide s'adresse à la personne qui exécute le serveur pour un laboratoire, un cours ou un groupe de co-auteurs. Vous devez être à l'aise avec un terminal. Certaines installations vous demandent aussi de modifier un fichier de configuration. Vous n'avez pas besoin d'écrire du code.

Pour votre revue de sécurité, lisez [Sécurité du serveur](/security/). Elle couvre l'auto-hébergement, la connexion, les clés d'appareils, les modifications signées, les journaux de sécurité et d'accès, ainsi que l'image conteneur et sa liste de composants logiciels.

## Ce que le serveur conserve

Le serveur conserve tout dans un seul dossier de données, défini par `OLEAFLY_DATA_DIR` :

- **Comptes** : le nom affiché de chaque membre, l'adresse de son avatar, ses adresses courriel vérifiées, ainsi que son identifiant d'utilisateur et son identifiant de connexion chez le fournisseur de connexion. Le serveur ne voit ni ne stocke jamais de mot de passe.
- **Appareils** : chaque ordinateur qui s'est connecté, avec son nom, son système d'exploitation, sa clé publique et sa date de dernière vue. Les jetons de connexion ne sont stockés que sous forme d'empreintes.
- **Le journal de sécurité** : les connexions et les connexions refusées, les appareils ajoutés et déconnectés, les changements de membres, de rôles et de paramètres, les projets partagés, archivés et restaurés, les changements portant sur qui peut ouvrir un projet, et les invitations d'invités. Chaque entrée contient l'heure et l'adresse IP.
- **Les paramètres du serveur**, que les administrateurs changent dans Oleafly.
- **Les journaux d'accès aux projets**, pour les projets dont le propriétaire en active un : qui a ouvert le projet, l'a rejoint ou en a téléchargé une copie, avec le nom de l'appareil et l'heure. Seul le propriétaire du projet peut le lire.
- **Les invitations d'invités** : l'adresse courriel invitée, le projet, le rôle et la personne qui l'a envoyée.
- **Les projets partagés** : tous les fichiers et l'historique complet des modifications, avec les commentaires, les suggestions, le chat et les noms de version qui leur appartiennent.
- **Les PDF compilés** : pour chaque projet partagé, le PDF le plus récent, avec son fichier SyncTeX, que l'application d'un propriétaire ou d'un éditeur a envoyé après une compilation réussie, avec qui l'a compilé et quand.

Les entrées des journaux de sécurité et d'accès, et les invitations d'invités répondues ou expirées, sont supprimées après `OLEAFLY_SECURITY_LOG_DAYS` jours, 365 par défaut. Les fichiers qu'un projet n'utilise plus, comme l'ancienne copie d'une figure remplacée, sont supprimés 30 jours après leur dernière utilisation par le projet. Chaque PDF compilé remplace le précédent. Quand un propriétaire arrête de partager un projet, le serveur le conserve en lecture seule pendant `OLEAFLY_ARCHIVE_DAYS` jours, 30 par défaut, puis le supprime. Pendant ce temps, seuls le propriétaire et les éventuels administrateurs du projet peuvent le télécharger.

### Qui peut lire les projets

Les projets ne sont pas chiffrés sur le serveur. Toute personne qui peut lire le dossier de données, le disque de la machine ou vos sauvegardes peut lire chaque projet qui y est stocké. Cela inclut celui qui administre la machine et l'entreprise qui l'héberge.

Dans Oleafly, les règles sont plus strictes. Aucun rôle du serveur, administrateur compris, ne peut ouvrir un projet à moins que le propriétaire du projet ne l'ait ajouté. Si un projet doit rester hors de portée des personnes qui exécutent le serveur, exécutez un serveur séparé pour ce projet.

L'ordinateur de chaque membre conserve aussi une copie complète de chaque projet partagé avec lui. Demandez aux membres d'activer le chiffrement de disque, comme FileVault sur macOS, BitLocker sur Windows ou LUKS sur Linux.

## Ce qu'il vous faut

- **Une machine qui reste allumée.** N'importe quelle machine Linux convient, ou un compte chez un service d'hébergement comme Render ou Railway. Une petite machine virtuelle suffit pour commencer. Surveillez sa mémoire et son disque à mesure que les projets grandissent. Le serveur fonctionne sur x86-64 et ARM.
- **Un nom de domaine** pour le serveur, comme `collab.example.org`, avec un enregistrement DNS qui pointe vers la machine. Render et Railway vous donnent une adresse si vous n'en avez pas. Si la machine n'a pas d'adresse publique, lisez [Sans adresse publique](#without-a-public-address).
- **Un moyen pour les personnes de se connecter** : au moins un fournisseur de connexion, comme une application OAuth GitHub ou le compte de votre institution. Le serveur ne démarre pas sans lui. Un compte courriel depuis lequel le serveur peut envoyer des messages est facultatif. Avec lui, un administrateur peut aussi permettre aux personnes de se connecter par un lien envoyé par courriel. Lisez [Connexion et accès](/docs/collaboration/server-access/).

Chaque version est publiée comme image conteneur, `ghcr.io/oleafly/oleafly-server`. L'installateur et ses fichiers Compose sont sur la [page des versions d'Oleafly Server](https://github.com/Oleafly/oleafly-server/releases). Le serveur sous forme d'un programme Linux unique est sur la [page des versions d'Oleafly](https://github.com/Oleafly/Oleafly/releases).

## Choisir comment le lancer

| Option | Quand l'utiliser |
| --- | --- |
| [Une seule commande](#install-with-one-command) | Une machine Linux que vous gérez. L'installateur met en place Docker, Caddy et le HTTPS, et pose quelques questions. Commencez ici en cas de doute. |
| [Docker Compose à la main](#docker-compose-by-hand) | Vous préférez placer et modifier chaque fichier vous-même. |
| [Coolify](#coolify) | Vous gérez déjà un serveur Coolify. |
| [Render](#render) ou [Railway](#railway) | Vous préférez payer un service d'hébergement plutôt que de gérer une machine. |
| [Linux sans Docker](#linux-without-docker) | Une machine virtuelle universitaire où vous ne pouvez pas utiliser Docker. |

Le serveur lit ses paramètres dans des variables d'environnement. [Stockage, sauvegardes et limites](/docs/collaboration/server-operations/#settings) les liste toutes.

## Installer avec une seule commande

Sur une machine Linux que vous gérez vous-même, l'installateur configure tout et ne demande que ce qu'il doit savoir.

Avant de l'exécuter, vérifiez que :

- La machine exécute Linux sur x86-64 ou ARM, comme Ubuntu 24.04 ou Debian 13, et vous pouvez y utiliser `sudo`.
- Rien d'autre sur la machine n'utilise les ports 80 et 443. Ouvrez les ports TCP 80 et 443 et le port UDP 443 dans tout pare-feu devant elle.
- L'enregistrement DNS de votre domaine pointe vers la machine. Si ce n'est pas encore le cas, l'installation se termine quand même, et Caddy continue d'essayer d'obtenir un certificat jusqu'à ce que l'enregistrement soit en place.
- Vous avez les détails d'au moins un [fournisseur de connexion](/docs/collaboration/server-access/#sign-in-providers), comme l'identifiant client et la clé secrète d'une application OAuth GitHub. Pour GitHub, l'adresse de rappel est `https://` suivi de votre domaine, puis `/auth/callback/github`.

:::note[Pendant la version bêta]
Installez la version candidate, Oleafly Server 0.1.1-rc, pour que le serveur corresponde à 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
```

La commande ci-dessous installe la 0.1.0, qui est plus ancienne. Si vous exécutez l'image autrement, par exemple avec Compose, Coolify, Render ou Railway, utilisez `ghcr.io/oleafly/oleafly-server:0.1.1-rc`.
:::

Ensuite, exécutez :

```sh
curl -fsSL https://oleafly.com/server/install.sh | sudo sh
```

L'installateur :

1. Vérifie la machine, et que les ports 80 et 443 sont libres.
2. Vérifie la présence de Docker. S'il est absent, l'installateur demande avant de l'installer avec le script propre à Docker.
3. Télécharge les fichiers de la dernière version depuis les [versions d'Oleafly Server](https://github.com/Oleafly/oleafly-server/releases) et vérifie chacun contre le `SHA256SUMS` de la version. Si un fichier ne correspond pas, il s'arrête sans rien changer.
4. Demande votre domaine, le nom du serveur et la façon dont les personnes se connectent. Il propose aussi de configurer le courriel et de conserver les fichiers dans un bucket S3. Les deux sont facultatifs.
5. Affiche un résumé et demande avant de changer quoi que ce soit. Il écrit ensuite ses fichiers dans `/opt/oleafly-server`, avec vos paramètres dans `.env`, que seul root peut lire.
6. Démarre le serveur avec Caddy devant, attend que votre domaine réponde en HTTPS, et affiche l'adresse et le code de configuration.

Ensuite, [devenez le premier administrateur](#become-the-first-admin).

Vous pouvez relancer l'installateur à tout moment. Quand il trouve un serveur dans `/opt/oleafly-server`, il laisse `.env` tel quel, remet les autres fichiers en place et redémarre le serveur. Cela répare la plupart des installations cassées.

Vos données se trouvent dans le volume Docker `oleafly-server_oleafly-data`. Pour installer ailleurs que dans `/opt/oleafly-server`, définissez `OLEAFLY_DIR`, par exemple `curl -fsSL https://oleafly.com/server/install.sh | sudo OLEAFLY_DIR=/srv/oleafly sh`, et utilisez ce dossier dans les commandes ci-dessous.

### Lire l'installateur d'abord

Si votre institution n'autorise pas l'envoi d'un script dans un shell par un pipe, téléchargez `install.sh` et `SHA256SUMS` depuis la [dernière version](https://github.com/Oleafly/oleafly-server/releases/latest) dans un seul dossier. Vérifiez le script, lisez-le, puis exécutez-le :

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

### Installer sans questions

Pour un script ou un outil de provisioning, ajoutez `--yes` et passez les réponses en variables d'environnement. `OLEAFLY_INSTALL_DOCKER=yes` permet à l'installateur d'ajouter Docker s'il est absent.

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

L'installateur utilise tout paramètre qu'il trouve dans l'environnement sans le demander, avec ou sans `--yes`. `sudo sh /opt/oleafly-server/install.sh --help` les liste tous, y compris OpenID Connect, le courriel et S3. Les valeurs saisies sur une ligne de commande peuvent se retrouver dans l'historique de votre shell, donc un outil de provisioning doit passer les secrets depuis son propre coffre de secrets.

### État, mises à jour et suppression

- **État** : `sudo sh /opt/oleafly-server/install.sh status` indique si le serveur fonctionne et si votre domaine répond en HTTPS avec un certificat valide.
- **Mise à jour** : sauvegardez d'abord, comme l'explique [Mise à jour](/docs/collaboration/server-operations/#updating). Exécutez ensuite la commande ci-dessous. Elle télécharge les fichiers et l'image de la dernière version, garde `.env`, redémarre le serveur et attend qu'il réponde. Les personnes connectées se reconnectent d'elles-mêmes. L'installateur ne fait jamais passer un serveur à une version plus ancienne.

  ```sh
  curl -fsSL https://oleafly.com/server/install.sh | sudo sh -s -- update
  ```

- **Désinstallation** : `sudo sh /opt/oleafly-server/install.sh uninstall` arrête et supprime les conteneurs. Vos données et `.env` restent, sauf si vous tapez `delete` quand il le demande. Les supprimer efface chaque projet partagé sur le serveur, chaque compte et le journal de sécurité. Les personnes conservent leurs propres copies des projets sur leurs ordinateurs.

Si l'installateur s'arrête sur un problème que vous ne pouvez pas résoudre, [signalez-le](https://github.com/Oleafly/oleafly-server/issues/new/choose) avec ce qu'il a affiché.

## Docker Compose à la main

Cette installation exécute deux conteneurs. `oleafly-server` est le serveur, et seuls les autres conteneurs peuvent l'atteindre. `caddy` obtient un certificat de Let's Encrypt, sert le HTTPS sur les ports 80 et 443, et transmet les requêtes au serveur, connexions en direct comprises.

1. Installez Docker Engine et le greffon Compose en suivant [les instructions de Docker](https://docs.docker.com/engine/install/).
2. Pointez l'enregistrement DNS de votre domaine vers la machine. Ouvrez les ports TCP 80 et 443 et le port UDP 443 dans tout pare-feu devant elle. Caddy a besoin du port 80 pour obtenir le certificat.
3. Créez un dossier pour le serveur, téléchargez-y les fichiers de la dernière version, vérifiez-les, et créez votre fichier de paramètres :

   ```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. Modifiez `.env` avec `sudoedit .env`. Définissez `OLEAFLY_DOMAIN` avec votre domaine sans `https://`, définissez `OLEAFLY_SERVER_NAME`, et renseignez au moins un [fournisseur de connexion](/docs/collaboration/server-access/#sign-in-providers). Laissez vides les lignes des fournisseurs que vous n'utilisez pas. Mettez une valeur entre guillemets simples si elle contient `$` ou `#`.
5. Démarrez-le. Le premier démarrage télécharge l'image du serveur, `ghcr.io/oleafly/oleafly-server`, à la version de la publication.

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

6. Vérifiez qu'il répond. Ceci affiche `200` :

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

7. [Devenez le premier administrateur](#become-the-first-admin). Le code de configuration est dans le journal :

   ```sh
   sudo docker compose logs oleafly-server | grep 'Setup code'
   ```

Vos données se trouvent dans le volume Docker `oleafly-server_oleafly-data`. Caddy conserve ses certificats dans `oleafly-server_caddy-data`.

Docker ouvre lui-même les ports 80 et 443, même quand un pare-feu hôte comme `ufw` est actif. C'est ce dont Caddy a besoin. N'ajoutez pas d'entrée `ports:` au service `oleafly-server`. Pour atteindre le serveur depuis la machine elle-même, publiez-le comme `127.0.0.1:8080:8080` pour qu'il reste hors du réseau.

Si vous modifiez le `Caddyfile`, exécutez `sudo docker compose up -d --force-recreate caddy`. Pour mettre à jour plus tard, téléchargez les fichiers de la nouvelle version de la même façon et exécutez de nouveau `sudo docker compose up -d`.

### Garder les secrets hors de .env

Sept paramètres peuvent contenir des secrets : `OLEAFLY_SETUP_CODE`, `OLEAFLY_GITHUB_CLIENT_SECRET`, `OLEAFLY_OIDC_<NAME>_CLIENT_SECRET`, `OLEAFLY_SMTP_URL`, `OLEAFLY_BLOB_STORE`, `OLEAFLY_S3_ACCESS_KEY_ID` et `OLEAFLY_S3_SECRET_ACCESS_KEY`. Chacun a aussi une version `_FILE` qui désigne un fichier contenant la valeur. Définissez l'un des deux, pas les deux.

Par exemple, pour passer la clé secrète client GitHub comme secret Docker, enregistrez-la dans `secrets/github_client_secret` à côté de `docker-compose.yml`, laissez l'utilisateur du serveur (ID 10001) la lire, et supprimez la ligne `OLEAFLY_GITHUB_CLIENT_SECRET` de `.env` :

```sh
sudo chown 10001:10001 secrets/github_client_secret
sudo chmod 400 secrets/github_client_secret
```

Créez ensuite `docker-compose.override.yml` à côté de `docker-compose.yml`. Compose le lit automatiquement, et l'installateur n'y touche pas quand il met à jour les autres fichiers.

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

Exécutez de nouveau `sudo docker compose up -d`.

## Coolify

Coolify place son propre proxy devant le serveur et obtient le certificat, donc cette installation n'a pas de Caddy. Coolify peut construire le serveur depuis le dépôt Oleafly, ou exécuter l'[image publiée](#deploy-the-published-image), ce qui évite la construction.

Avant de commencer, pointez l'enregistrement DNS de votre domaine, comme `collab.example.org`, vers le serveur Coolify. Créez ensuite l'application OAuth GitHub comme décrit sous [GitHub](/docs/collaboration/server-access/#github), avec l'adresse de rappel `https://collab.example.org/auth/callback/github`. Gardez son identifiant client et sa clé secrète à portée de main.

### Construire depuis le dépôt

1. Dans votre projet Coolify, sélectionnez **+ New**, puis **Public Repository**, et saisissez `https://github.com/Oleafly/Oleafly`. Gardez la branche `main`.
2. Définissez **Build Pack** sur **Docker Compose**, **Base Directory** sur `/` et **Docker Compose Location** sur `/deploy/server/docker-compose.coolify.yml`, puis sélectionnez **Continue**.
3. Sous **Advanced › Build**, définissez **Build arguments** sur **Managed manually in Dockerfile**. L'image du serveur n'a besoin d'aucun argument de construction. Laissée sur automatique, Coolify écrit chaque variable, secrets compris, dans l'historique de construction de l'image.
4. Sous **General**, définissez le domaine de `oleafly-server` sur `https://collab.example.org:8080` et enregistrez. Le `:8080` indique au proxy de Coolify le port sur lequel le serveur écoute. Les personnes se connectent toujours sur le port HTTPS habituel, et Coolify définit `OLEAFLY_PUBLIC_URL` sur `https://collab.example.org` pour vous.
5. Sous **Environment Variables**, renseignez `OLEAFLY_SERVER_NAME`, que Coolify marque comme obligatoire, puis `OLEAFLY_GITHUB_CLIENT_ID` et `OLEAFLY_GITHUB_CLIENT_SECRET`. Laissez vides les variables que vous n'utilisez pas.
6. Sélectionnez **Deploy**. La première construction compile le serveur et prend quelques minutes. Une fois terminée, Coolify affiche la ressource comme en cours d'exécution et saine.
7. Ouvrez `https://collab.example.org/healthz` dans un navigateur. Il affiche `{"status":"ok"}`.
8. Ouvrez **Logs**, choisissez le conteneur `oleafly-server`, et copiez le code de la ligne la plus récente qui commence par `Setup code:`.
9. [Devenez le premier administrateur](#become-the-first-admin) avec ce code.

Si le serveur ne démarre pas, son journal nomme le paramètre qu'il ne peut pas utiliser. Quand il dit que `OLEAFLY_PUBLIC_URL` n'est pas défini, l'étape 4 manque. Un domaine qui commence par `http://` est refusé, car le serveur a besoin du HTTPS.

Si Cloudflare se trouve devant Coolify, parce que votre enregistrement DNS passe par le proxy de Cloudflare ou qu'un tunnel mène au proxy de Coolify, définissez `OLEAFLY_PROXY_HOPS` sur `2`. Sans cela, le journal de sécurité affiche l'adresse du proxy pour tout le monde, et toutes les personnes partagent une même limite de connexion.

Le fichier Coolify a de la place pour GitHub et un fournisseur OpenID Connect nommé `UNIVERSITY`. Définissez `OLEAFLY_OIDC_UNIVERSITY_LABEL` sur le texte que les personnes doivent voir, comme `GitLab`. Son adresse de rappel se termine par `/auth/callback/university`. Pour plus de fournisseurs, déployez depuis un fork avec votre propre copie du fichier.

Les données se trouvent dans un volume Docker dont le nom se termine par `oleafly-data`. Trouvez-le avec `docker volume ls --filter name=oleafly-data`. L'image n'a pas de shell, donc le **Terminal** de Coolify ne peut pas en ouvrir un dans le conteneur du serveur. Les journaux et le test d'état fonctionnent comme d'habitude.

### Déployer l'image publiée

Exécuter l'image publiée évite la construction, ce qui convient à un petit serveur Coolify. Suivez les étapes ci-dessus avec deux changements. À l'étape 2, définissez **Docker Compose Location** sur `/deploy/server/docker-compose.coolify-image.yml`. Passez l'étape 3, car rien n'est construit. Le fichier suit une seule série de versions, donc chaque **Redeploy** récupère la plus récente d'entre elles.

## Render

[Déployer sur Render](https://render.com/deploy?repo=https://github.com/Oleafly/Oleafly) lit le Blueprint du dépôt Oleafly. Il crée un service web depuis l'image publiée, avec un disque de 1 Go pour le dossier de données. Render n'attache des disques qu'aux types d'instance payants, donc le service démarre sur le plus petit d'entre eux, dans la région Oregon de Render. Pour une autre région, déployez depuis un fork avec `region` défini dans `render.yaml`.

1. Ouvrez le lien et connectez-vous à Render.
2. Render demande `OLEAFLY_SERVER_NAME` ainsi que l'identifiant client et la clé secrète GitHub. Renseignez le nom et laissez les champs GitHub vides pour l'instant. Leur adresse de rappel dépend de l'adresse du service, que vous n'avez pas encore.
3. Sélectionnez **Deploy Blueprint**. Une fois le service en ligne, sa page affiche son adresse, comme `https://oleafly-server.onrender.com`. Le Blueprint définit `OLEAFLY_PUBLIC_URL` sur cette adresse.
4. Créez l'application OAuth GitHub comme décrit sous [GitHub](/docs/collaboration/server-access/#github), avec cette adresse suivie de `/auth/callback/github` comme adresse de rappel. Ajoutez l'identifiant client et la clé secrète sous **Environment** du service. Render redémarre le serveur avec eux.
5. Trouvez la ligne `Setup code:` la plus récente dans les **Logs** du service et [devenez le premier administrateur](#become-the-first-admin).

Si vous donnez au service votre propre domaine, définissez `OLEAFLY_PUBLIC_URL` dessus sous **Environment** et changez l'adresse de rappel sur GitHub pour qu'elle corresponde.

À cause du disque, Render arrête le serveur en cours d'exécution avant de démarrer le nouveau, donc chaque déploiement retire le serveur pendant quelques secondes. Oleafly se reconnecte tout seul.

## Railway

Railway exécute l'image publiée, avec un volume pour le dossier de données.

1. Dans un projet Railway, sélectionnez **+ New**, puis **Docker Image**, et saisissez `ghcr.io/oleafly/oleafly-server:latest`. Pour choisir quand vous mettez à niveau, utilisez plutôt la balise propre à une version depuis la [page des versions](https://github.com/Oleafly/Oleafly/releases). Railway peut lancer un premier déploiement immédiatement. Il s'arrête avec `OLEAFLY_PUBLIC_URL is not set`, ce qui est normal à ce stade.
2. Ouvrez le service. Sous **Settings › Networking**, sélectionnez **Generate Domain** et saisissez le port `8080`. Railway affiche l'adresse, comme `oleafly-server-production.up.railway.app`.
3. Sous **Settings › Deploy**, définissez **Healthcheck Path** sur `/readyz`.
4. Faites un clic droit sur le canevas du projet, ajoutez un volume, attachez-le au service du serveur et définissez son point de montage sur `/data`.
5. Sous **Variables**, ouvrez le **Raw Editor** et collez ces lignes avec votre propre nom de serveur. Pour les valeurs GitHub, suivez [GitHub](/docs/collaboration/server-access/#github). L'adresse de rappel est votre adresse de l'étape 2, précédée de `https://` et suivie de `/auth/callback/github`.

   ```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 monte les volumes en tant que root. `RAILWAY_RUN_UID=0` exécute le serveur en tant que root pour qu'il puisse écrire dans le volume.

6. Déployez les changements. Trouvez la ligne `Setup code:` la plus récente dans les **Deploy Logs** du service et [devenez le premier administrateur](#become-the-first-admin).

## Linux sans Docker

Sur une machine sans Docker, le serveur s'exécute comme un programme unique sous systemd, avec Caddy devant pour le HTTPS.

### Télécharger le serveur

Chaque version du serveur sur la [page des versions](https://github.com/Oleafly/Oleafly/releases) contient un programme déjà construit pour x86-64 et pour ARM, ainsi qu'un fichier `SHA256SUMS` pour le vérifier. Le programme ne nécessite rien d'autre à installer.

Téléchargez l'archive de votre machine, se terminant par `x86_64-unknown-linux-musl.tar.gz` ou `aarch64-unknown-linux-musl.tar.gz`, ainsi que `SHA256SUMS` dans un seul dossier. Vérifiez puis installez. Sur une machine ARM, utilisez `aarch64` à la place 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
```

Avec la GitHub CLI installée, `gh attestation verify oleafly-server-*-x86_64-unknown-linux-musl.tar.gz --repo Oleafly/Oleafly` vérifie aussi que GitHub a construit l'archive depuis le dépôt Oleafly. L'archive contient l'unité systemd, `oleafly-server.service`.

Pour plutôt construire le programme vous-même, exécutez ceci depuis un clone du dépôt Oleafly sur n'importe quel ordinateur avec Docker. Utilisez `--platform linux/arm64` pour un serveur ARM.

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

Cela écrit `dist/oleafly-server`. Copiez-le dans `/usr/local/bin/oleafly-server` sur le serveur et rendez-le exécutable.

### Le lancer avec systemd

1. Créez le fichier de paramètres. Seul root peut le lire :

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

   Mettez un paramètre par ligne. `OLEAFLY_BIND=127.0.0.1:8080` garde le serveur hors du réseau pour que seul Caddy puisse l'atteindre. Ne définissez pas `OLEAFLY_DATA_DIR`, car l'unité le définit.

   ```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. Installez et démarrez l'unité depuis l'archive décompressée, ou depuis `deploy/server` dans un clone du dépôt. Trouvez ensuite le code de configuration :

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

L'unité exécute le serveur sous un utilisateur que systemd crée pour lui, avec une vue en lecture seule du reste du système. Le seul endroit où il peut écrire est `/var/lib/oleafly-server`, où il garde ses données. Sur le disque, ce dossier est `/var/lib/private/oleafly-server`.

Pour garder la clé secrète client hors du fichier de paramètres, utilisez un credential systemd. Enregistrez la clé dans `/etc/oleafly-server/github-client-secret` avec le mode 600, supprimez la ligne `OLEAFLY_GITHUB_CLIENT_SECRET` du fichier de paramètres, exécutez `sudo systemctl edit oleafly-server`, et ajoutez :

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

Exécutez ensuite `sudo systemctl restart oleafly-server`.

### Mettre le HTTPS devant

Installez Caddy avec [ses instructions pour votre distribution](https://caddyserver.com/docs/install). Remplacez `/etc/caddy/Caddyfile` par ces lignes et exécutez `sudo systemctl reload caddy`. Caddy obtient le certificat et laisse passer les connexions en direct.

```
collab.example.org {
	reverse_proxy 127.0.0.1:8080
}
```

Pour nginx ou Apache, ou un serveur web que votre université fait déjà tourner, lisez [Derrière un proxy inverse](/docs/collaboration/server-operations/#behind-a-reverse-proxy).

## Sans adresse publique

Si la machine n'a pas d'adresse publique, par exemple un ordinateur de votre laboratoire derrière le pare-feu de l'université, Cloudflare Tunnel peut la rendre accessible. Il vous faut un compte Cloudflare sur lequel se trouve votre domaine. Cloudflare gère le HTTPS pour le nom d'hôte, donc les requêtes sont déchiffrées sur le réseau de Cloudflare avant d'atteindre votre machine. Comptez Cloudflare parmi les parties qui peuvent lire le trafic vers votre serveur.

1. Suivez les étapes de [Docker Compose à la main](#docker-compose-by-hand) jusqu'à la modification de `.env`. Définissez `OLEAFLY_DOMAIN` sur le nom d'hôte que vous utiliserez, comme `collab.example.org`. L'installateur en une commande ne convient pas ici, car il démarre Caddy.
2. Démarrez uniquement le serveur. Caddy n'est pas nécessaire ici :

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

3. Dans le tableau de bord Cloudflare, allez dans **Networking › Tunnels**, sélectionnez **Create Tunnel**, donnez-lui un nom, puis sélectionnez de nouveau **Create Tunnel**. Copiez le jeton de la commande d'installation affichée.
4. Démarrez le tunnel à côté du serveur. La commande `read` attend que vous colliez le jeton et ne l'affiche pas :

   ```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 retour dans le tableau de bord, ouvrez le tunnel. Sous **Routes**, sélectionnez **Add route**, puis **Published application**. Sous **Hostname**, saisissez le sous-domaine et choisissez votre domaine. Définissez **Service URL** sur `http://oleafly-server:8080` et sélectionnez **Add route**.
6. Vérifiez qu'il répond sur `https://collab.example.org/healthz`, puis [devenez le premier administrateur](#become-the-first-admin).

Sur une machine sans Docker, installez `cloudflared` depuis le [dépôt de paquets de Cloudflare](https://pkg.cloudflare.com/), exécutez `sudo cloudflared service install` suivi du jeton, et définissez **Service URL** sur `http://127.0.0.1:8080`.

Cloudflare laisse passer les connexions en direct et place l'adresse du visiteur en dernier dans `X-Forwarded-For`, donc gardez `OLEAFLY_BEHIND_PROXY=true`. Quand le tunnel mène à un autre proxy, comme celui de Coolify, et pas directement au serveur, définissez aussi `OLEAFLY_PROXY_HOPS=2`. Cloudflare refuse les requêtes de plus de 100 Mo sur ses offres Free et Pro, donc définissez `OLEAFLY_MAX_PROJECT_MB` sur 100 ou moins, sinon les gros projets échouent au téléversement. Ne placez pas Cloudflare Access devant le serveur, car Oleafly ne peut pas passer sa page de connexion.

Quand vous mettez le serveur à jour plus tard, téléchargez les fichiers de la nouvelle version et nommez le service pour que Caddy reste éteint : `sudo docker compose up -d oleafly-server`.

## Devenir le premier administrateur

Un nouveau serveur n'a pas d'administrateur. Tant que personne n'a terminé la configuration, le serveur crée un nouveau code de configuration à usage unique à chaque démarrage et l'écrit dans son journal.

1. Trouvez la ligne la plus récente qui commence par `Setup code:` dans le journal :
   - Installation en une commande : l'installateur l'affiche à la fin. Pour le revoir, exécutez `cd /opt/oleafly-server && sudo docker compose logs oleafly-server | grep 'Setup code'`
   - Docker Compose à la main : `sudo docker compose logs oleafly-server | grep 'Setup code'` dans le dossier du serveur
   - Coolify : les journaux du service `oleafly-server`
   - systemd : `sudo journalctl -u oleafly-server | grep 'Setup code'`
2. Dans Oleafly, ouvrez **Paramètres → Collaboration**, sélectionnez **Ajouter un serveur**, et saisissez l'adresse de votre serveur. Oleafly voit que le serveur a besoin d'être configuré et demande le **code de configuration**.
3. Saisissez le code et connectez-vous avec n'importe quel fournisseur que vous avez configuré. Vous devenez l'administrateur du serveur, et le code cesse de fonctionner.

Quiconque a le code avant que vous l'utilisiez peut devenir administrateur, donc ne le collez que dans Oleafly.

Vous pouvez aussi choisir le code vous-même avec `OLEAFLY_SETUP_CODE` : au moins 12 lettres ou chiffres, avec des tirets ou des espaces si vous voulez. Le serveur ne l'affiche alors jamais. Le journal dit seulement `Setup code: set by OLEAFLY_SETUP_CODE`, et vous saisissez la valeur que vous avez définie. Retirez-le de vos paramètres une fois la configuration terminée.

Ensuite, laissez entrer les personnes. [Connexion et accès](/docs/collaboration/server-access/#access-rules) explique comment.

## Vérifier le serveur

- Avec l'installation en une commande, `sudo sh /opt/oleafly-server/install.sh status` vérifie les conteneurs et le HTTPS en une seule fois.
- `https://collab.example.org/healthz` répond `200` tant que le processus du serveur tourne.
- `/readyz` répond `200` seulement tant que le serveur peut écrire dans sa base de données et son dossier de données. Quand il ne le peut pas, par exemple sur un disque plein, il répond `503` et nomme ce qui a échoué, `database` ou `storage`.
- L'image Docker vérifie `/readyz` elle-même, donc `docker ps` et Coolify montrent un serveur défaillant plutôt qu'un serveur en cours d'exécution qui ne peut rien enregistrer.
- Dans Oleafly, **Tester la connexion** sous **Paramètres → Collaboration** vérifie l'adresse, le HTTPS, la version, les connexions en direct, les options de connexion et l'horloge du serveur. **Tests de connexion** dans la [console d'administration](/docs/collaboration/server-access/#admin-console) exécute les mêmes vérifications.
