# Einen Kollaborationsserver betreiben

Was Oleafly Server speichert, was er braucht und wie Sie ihn mit einem Befehl installieren oder mit Docker Compose, Coolify, Render, Railway oder als einfachen Linux-Dienst betreiben, und wie Sie dann der erste Admin werden.

Oleafly Server ist der Kollaborationsserver hinter der Live-Zusammenarbeit. Ihr Labor, Ihre Abteilung oder Ihre Institution betreibt ihn auf eigenen Maschinen oder in einem eigenen Cloud-Konto. Personen fügen ihn in Oleafly hinzu und melden sich mit einem Konto an, das sie bereits haben, etwa GitHub oder einem Universitätslogin. Wenn jemand ein Projekt auf dem Server teilt, erhalten die hinzugefügten Personen eine vollständige Kopie, die während der Bearbeitung synchronisiert bleibt. Ist [Browserzugriff](/docs/collaboration/server-access/#browser-access) eingeschaltet, können sie es auch in einem Webbrowser öffnen.

Diese Anleitung richtet sich an die Person, die den Server für ein Labor, eine Lehrveranstaltung oder eine Gruppe von Mitautoren betreibt. Sie sollten mit einem Terminal vertraut sein. Bei manchen Setups bearbeiten Sie zusätzlich eine Konfigurationsdatei. Code müssen Sie nicht schreiben.

Für Ihre Sicherheitsprüfung lesen Sie [Serversicherheit](/security/). Sie behandelt Self-Hosting, Anmeldung, Geräteschlüssel, signierte Änderungen, die Sicherheits- und Zugriffsprotokolle sowie das Container-Image mit seiner Software-Stückliste.

## Was der Server speichert

Der Server speichert alles in einem Datenordner, festgelegt durch `OLEAFLY_DATA_DIR`:

- **Konten**: der Anzeigename jedes Mitglieds, seine Avatar-Adresse, verifizierte E-Mail-Adressen sowie seine Benutzer-ID und sein Login beim Anbieter der Anmeldung. Der Server sieht oder speichert nie ein Passwort.
- **Geräte**: jeder Computer, der sich angemeldet hat, mit Name, Betriebssystem, öffentlichem Schlüssel und dem Zeitpunkt, an dem er zuletzt gesehen wurde. Anmelde-Tokens werden nur als Hashes gespeichert.
- **Das Sicherheitsprotokoll**: Anmeldungen und abgelehnte Anmeldungen, hinzugefügte und abgemeldete Geräte, Änderungen an Mitgliedern, Rollen und Einstellungen, geteilte, archivierte und wiederhergestellte Projekte, Änderungen daran, wer ein Projekt öffnen kann, sowie Gasteinladungen. Jeder Eintrag enthält Zeitpunkt und IP-Adresse.
- **Servereinstellungen**, die Admins in Oleafly ändern.
- **Projekt-Zugriffsprotokolle**, für Projekte, deren Inhaber eines einschaltet: wer das Projekt geöffnet oder beigetreten hat oder eine Kopie heruntergeladen hat, mit Gerätename und Zeitpunkt. Nur der Inhaber des Projekts kann es lesen.
- **Gasteinladungen**: die eingeladene E-Mail-Adresse, das Projekt, die Rolle und wer sie gesendet hat.
- **Geteilte Projekte**: jede Datei und die vollständige Änderungshistorie, mit den Kommentaren, Vorschlägen, dem Chat und den Versionsnamen, die dazugehören.
- **Kompilierte PDFs**: für jedes geteilte Projekt das neueste PDF samt SyncTeX-Datei, das die App eines Inhabers oder Bearbeiters nach einer erfolgreichen Kompilierung gesendet hat, mit der Angabe, wer es wann kompiliert hat.

Einträge im Sicherheitsprotokoll und in den Zugriffsprotokollen sowie beantwortete oder abgelaufene Gasteinladungen werden nach `OLEAFLY_SECURITY_LOG_DAYS` Tagen gelöscht, standardmäßig nach 365. Dateien, die ein Projekt nicht mehr verwendet, etwa die alte Kopie einer ersetzten Abbildung, werden 30 Tage nachdem das Projekt sie zuletzt verwendet hat gelöscht. Jedes kompilierte PDF ersetzt das vorherige. Wenn ein Inhaber ein Projekt nicht mehr teilt, hält der Server es für `OLEAFLY_ARCHIVE_DAYS` Tage schreibgeschützt, standardmäßig 30, und löscht es dann. In dieser Zeit können nur der Inhaber und Admins im Projekt es herunterladen.

### Wer Projekte lesen kann

Projekte sind auf dem Server nicht verschlüsselt. Jeder, der den Datenordner, die Festplatte der Maschine oder Ihre Backups lesen kann, kann jedes dort gespeicherte Projekt lesen. Das schließt ein, wer die Maschine betreibt, und das Unternehmen, das sie hostet.

In Oleafly sind die Regeln strenger. Keine Serverrolle, Admins eingeschlossen, kann ein Projekt öffnen, es sei denn, der Inhaber des Projekts hat sie hinzugefügt. Muss ein Projekt von den Personen fernbleiben, die einen Server betreiben, betreiben Sie dafür einen eigenen Server.

Außerdem hält der Computer jedes Mitglieds eine vollständige Kopie jedes Projekts, das mit ihm geteilt wurde. Bitten Sie Mitglieder, Festplattenverschlüsselung einzuschalten, etwa FileVault auf macOS, BitLocker auf Windows oder LUKS auf Linux.

## Was Sie brauchen

- **Eine Maschine, die durchläuft.** Jede Linux-Maschine funktioniert, oder ein Konto bei einem Hostingdienst wie Render oder Railway. Zum Anfang genügt eine kleine virtuelle Maschine. Beobachten Sie Speicher und Festplatte, wenn die Projekte wachsen. Der Server läuft auf x86-64 und ARM.
- **Einen Domänennamen** für den Server, etwa `collab.example.org`, mit einem DNS-Eintrag, der auf die Maschine zeigt. Render und Railway geben Ihnen eine Adresse, wenn Sie keine haben. Hat die Maschine keine öffentliche Adresse, lesen Sie [Ohne öffentliche Adresse](#without-a-public-address).
- **Einen Weg für Personen, sich anzumelden**: mindestens einen Anbieter für die Anmeldung, etwa eine GitHub-OAuth-App oder den Login Ihrer Institution. Ohne einen startet der Server nicht. Ein E-Mail-Konto, von dem der Server senden kann, ist optional. Damit kann ein Admin Personen auch die Anmeldung per Link per E-Mail erlauben. Lesen Sie [Anmeldung und Zugriff](/docs/collaboration/server-access/).

Jedes Release wird als Container-Image veröffentlicht, `ghcr.io/oleafly/oleafly-server`. Das Installationsprogramm und seine Compose-Dateien liegen auf der [Oleafly-Server-Release-Seite](https://github.com/Oleafly/oleafly-server/releases). Der Server als einzelnes Linux-Programm liegt auf der [Oleafly-Release-Seite](https://github.com/Oleafly/Oleafly/releases).

## Wählen Sie, wie Sie ihn betreiben

| Option | Wann Sie sie nutzen |
| --- | --- |
| [Ein Befehl](#install-with-one-command) | Eine Linux-Maschine, die Sie selbst betreuen. Das Installationsprogramm richtet Docker, Caddy und HTTPS ein und stellt ein paar Fragen. Beginnen Sie hier, wenn Sie unsicher sind. |
| [Docker Compose von Hand](#docker-compose-by-hand) | Sie legen und bearbeiten jede Datei lieber selbst. |
| [Coolify](#coolify) | Sie betreiben bereits einen Coolify-Server. |
| [Render](#render) oder [Railway](#railway) | Sie zahlen lieber für einen Hostingdienst, als eine Maschine zu betreuen. |
| [Linux ohne Docker](#linux-without-docker) | Eine virtuelle Maschine einer Universität, auf der Sie Docker nicht nutzen können. |

Der Server liest seine Einstellungen aus Umgebungsvariablen. [Speicherung, Backups & Limits](/docs/collaboration/server-operations/#settings) listet alle auf.

## Installation mit einem Befehl

Auf einer Linux-Maschine, die Sie selbst betreuen, richtet das Installationsprogramm alles ein und fragt nur ab, was es wissen muss.

Bevor Sie es ausführen, prüfen Sie, dass:

- Die Maschine läuft mit Linux auf x86-64 oder ARM, etwa Ubuntu 24.04 oder Debian 13, und Sie können darauf `sudo` verwenden.
- Nichts anderes auf der Maschine verwendet die Ports 80 und 443. Öffnen Sie die TCP-Ports 80 und 443 und den UDP-Port 443 in jeder davorliegenden Firewall.
- Der DNS-Eintrag Ihrer Domain zeigt auf die Maschine. Tut er es noch nicht, endet die Installation dennoch, und Caddy versucht weiter, ein Zertifikat zu holen, bis der Eintrag vorhanden ist.
- Sie haben die Angaben für mindestens einen [Anbieter der Anmeldung](/docs/collaboration/server-access/#sign-in-providers), etwa Client-ID und Secret einer GitHub-OAuth-App. Bei GitHub ist die Callback-Adresse `https://` und Ihre Domain, gefolgt von `/auth/callback/github`.

:::note[In der Beta]
Installieren Sie den Release Candidate, Oleafly Server 0.1.1-rc, damit der Server zu Oleafly 0.4.7-rc passt:

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

Der Befehl unten installiert 0.1.0, das älter ist. Führen Sie das Image auf andere Weise aus, etwa mit Compose, Coolify, Render oder Railway, verwenden Sie `ghcr.io/oleafly/oleafly-server:0.1.1-rc`.
:::

Dann führen Sie aus:

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

Das Installationsprogramm:

1. Prüft die Maschine und, dass die Ports 80 und 443 frei sind.
2. Prüft auf Docker. Fehlt es, fragt das Installationsprogramm nach, bevor es es mit Dockers eigenem Skript installiert.
3. Lädt die Dateien des neuesten Releases von den [Oleafly-Server-Releases](https://github.com/Oleafly/oleafly-server/releases) herunter und gleicht jede mit der `SHA256SUMS` des Releases ab. Passt eine Datei nicht, stoppt es, ohne etwas zu ändern.
4. Fragt nach Ihrer Domain, dem Namen des Servers und wie sich Personen anmelden. Es bietet außerdem an, E-Mail einzurichten und Dateien in einem S3-Bucket zu halten. Beides ist optional.
5. Zeigt eine Zusammenfassung und fragt nach, bevor es etwas ändert. Dann schreibt es seine Dateien nach `/opt/oleafly-server`, mit Ihren Einstellungen in `.env`, die nur root lesen kann.
6. Startet den Server mit Caddy davor, wartet, bis Ihre Domain über HTTPS antwortet, und gibt die Adresse und den Einrichtungscode aus.

Dann [werden Sie der erste Admin](#become-the-first-admin).

Sie können das Installationsprogramm jederzeit erneut ausführen. Findet es einen Server in `/opt/oleafly-server`, lässt es `.env` unverändert, setzt die anderen Dateien zurück und startet den Server neu. Das repariert die meisten kaputten Setups.

Ihre Daten liegen im Docker-Volume `oleafly-server_oleafly-data`. Um woanders als `/opt/oleafly-server` zu installieren, setzen Sie `OLEAFLY_DIR`, zum Beispiel `curl -fsSL https://oleafly.com/server/install.sh | sudo OLEAFLY_DIR=/srv/oleafly sh`, und verwenden Sie diesen Ordner in den Befehlen unten.

### Lesen Sie das Installationsprogramm zuerst

Erlaubt Ihre Institution nicht, ein Skript in eine Shell zu leiten, laden Sie `install.sh` und `SHA256SUMS` vom [neuesten Release](https://github.com/Oleafly/oleafly-server/releases/latest) in einen Ordner herunter. Prüfen Sie das Skript, lesen Sie es und führen Sie es dann aus:

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

### Installation ohne Fragen

Für ein Skript oder ein Provisionierungswerkzeug hängen Sie `--yes` an und übergeben die Antworten als Umgebungsvariablen. `OLEAFLY_INSTALL_DOCKER=yes` erlaubt dem Installationsprogramm, Docker hinzuzufügen, wenn es fehlt.

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

Das Installationsprogramm verwendet jede Einstellung, die es in der Umgebung findet, ohne nachzufragen, mit oder ohne `--yes`. `sudo sh /opt/oleafly-server/install.sh --help` listet alle auf, einschließlich OpenID Connect, E-Mail und S3. Werte, die Sie auf einer Befehlszeile eingeben, können in Ihrer Shell-Historie landen. Ein Provisionierungswerkzeug sollte Secrets darum aus seinem eigenen Secret-Speicher übergeben.

### Status, Updates und Entfernen

- **Status**: `sudo sh /opt/oleafly-server/install.sh status` zeigt, ob der Server läuft und ob Ihre Domain über HTTPS mit einem gültigen Zertifikat antwortet.
- **Update**: Sichern Sie zuerst, wie unter [Aktualisieren](/docs/collaboration/server-operations/#updating) beschrieben. Führen Sie dann den Befehl unten aus. Er lädt die Dateien und das Image des neuesten Releases herunter, behält `.env`, startet den Server neu und wartet, bis er antwortet. Verbundene Personen verbinden sich von selbst wieder. Das Installationsprogramm setzt einen Server nie auf ein älteres Release zurück.

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

- **Deinstallieren**: `sudo sh /opt/oleafly-server/install.sh uninstall` stoppt und entfernt die Container. Ihre Daten und `.env` bleiben, außer Sie geben `delete` ein, wenn es nachfragt. Sie zu löschen entfernt jedes geteilte Projekt auf dem Server, jedes Konto und das Sicherheitsprotokoll. Personen behalten ihre eigenen Kopien der Projekte auf ihren Computern.

Stoppt das Installationsprogramm mit einem Problem, das Sie nicht beheben können, [melden Sie es](https://github.com/Oleafly/oleafly-server/issues/new/choose) mit dem, was es ausgegeben hat.

## Docker Compose von Hand

Dieses Setup betreibt zwei Container. `oleafly-server` ist der Server, und nur andere Container können ihn erreichen. `caddy` holt ein Zertifikat von Let's Encrypt, bedient HTTPS auf den Ports 80 und 443 und leitet Anfragen an den Server weiter, Live-Verbindungen eingeschlossen.

1. Installieren Sie Docker Engine und das Compose-Plugin nach [Dockers Anleitung](https://docs.docker.com/engine/install/).
2. Lassen Sie den DNS-Eintrag Ihrer Domain auf die Maschine zeigen. Öffnen Sie die TCP-Ports 80 und 443 und den UDP-Port 443 in jeder davorliegenden Firewall. Caddy braucht Port 80, um das Zertifikat zu holen.
3. Legen Sie einen Ordner für den Server an, laden Sie die Dateien des neuesten Releases hinein, prüfen Sie sie und erstellen Sie Ihre Einstellungsdatei:

   ```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. Bearbeiten Sie `.env` mit `sudoedit .env`. Setzen Sie `OLEAFLY_DOMAIN` auf Ihre Domain ohne `https://`, setzen Sie `OLEAFLY_SERVER_NAME` und tragen Sie mindestens einen [Anbieter der Anmeldung](/docs/collaboration/server-access/#sign-in-providers) ein. Lassen Sie die Anbieterzeilen, die Sie nicht nutzen, leer. Setzen Sie einen Wert in einfache Anführungszeichen, wenn er `$` oder `#` enthält.
5. Starten Sie es. Der erste Start lädt das Server-Image, `ghcr.io/oleafly/oleafly-server`, in der Version des Releases herunter.

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

6. Prüfen Sie, dass es antwortet. Dies gibt `200` aus:

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

7. [Werden Sie der erste Admin](#become-the-first-admin). Der Einrichtungscode steht im Log:

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

Ihre Daten liegen im Docker-Volume `oleafly-server_oleafly-data`. Caddy hält seine Zertifikate in `oleafly-server_caddy-data`.

Docker öffnet die Ports 80 und 443 selbst, auch wenn eine Host-Firewall wie `ufw` aktiviert ist. Genau das braucht Caddy. Fügen Sie beim Dienst `oleafly-server` keinen `ports:`-Eintrag hinzu. Um den Server von der Maschine selbst zu erreichen, veröffentlichen Sie ihn als `127.0.0.1:8080:8080`, damit er nicht im Netzwerk liegt.

Ändern Sie die `Caddyfile`, führen Sie `sudo docker compose up -d --force-recreate caddy` aus. Um später zu aktualisieren, laden Sie die Dateien des neuen Releases auf dieselbe Weise herunter und führen Sie `sudo docker compose up -d` erneut aus.

### Secrets aus .env heraushalten

Sieben Einstellungen können Secrets enthalten: `OLEAFLY_SETUP_CODE`, `OLEAFLY_GITHUB_CLIENT_SECRET`, `OLEAFLY_OIDC_<NAME>_CLIENT_SECRET`, `OLEAFLY_SMTP_URL`, `OLEAFLY_BLOB_STORE`, `OLEAFLY_S3_ACCESS_KEY_ID` und `OLEAFLY_S3_SECRET_ACCESS_KEY`. Jede hat außerdem eine `_FILE`-Version, die eine Datei mit dem Wert benennt. Setzen Sie eines von beiden, nicht beide.

Um zum Beispiel das GitHub-Client-Secret als Docker-Secret zu übergeben, speichern Sie es in `secrets/github_client_secret` neben `docker-compose.yml`, lassen Sie den Benutzer des Servers (ID 10001) es lesen und löschen Sie die Zeile `OLEAFLY_GITHUB_CLIENT_SECRET` aus `.env`:

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

Erstellen Sie dann `docker-compose.override.yml` neben `docker-compose.yml`. Compose liest sie automatisch, und das Installationsprogramm lässt sie in Ruhe, wenn es die anderen Dateien aktualisiert.

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

Führen Sie `sudo docker compose up -d` erneut aus.

## Coolify

Coolify setzt seinen eigenen Proxy vor den Server und holt das Zertifikat, darum hat dieses Setup kein Caddy. Coolify kann den Server aus dem Oleafly-Repository bauen oder das [veröffentlichte Image](#deploy-the-published-image) betreiben, was den Bau überspringt.

Bevor Sie beginnen, lassen Sie den DNS-Eintrag Ihrer Domain, etwa `collab.example.org`, auf den Coolify-Server zeigen. Erstellen Sie dann die GitHub-OAuth-App wie unter [GitHub](/docs/collaboration/server-access/#github) beschrieben, mit der Callback-Adresse `https://collab.example.org/auth/callback/github`. Halten Sie Client-ID und Secret bereit.

### Aus dem Repository bauen

1. Wählen Sie in Ihrem Coolify-Projekt **+ New** und dann **Public Repository** und geben Sie `https://github.com/Oleafly/Oleafly` ein. Behalten Sie den Branch `main`.
2. Setzen Sie **Build Pack** auf **Docker Compose**, **Base Directory** auf `/` und **Docker Compose Location** auf `/deploy/server/docker-compose.coolify.yml` und wählen Sie dann **Continue**.
3. Setzen Sie unter **Advanced › Build** **Build arguments** auf **Managed manually in Dockerfile**. Das Image des Servers braucht keine Build-Argumente. Bleibt die Einstellung auf automatisch, schreibt Coolify jede Variable, Secrets eingeschlossen, in die Build-Historie des Images.
4. Setzen Sie unter **General** die Domain von `oleafly-server` auf `https://collab.example.org:8080` und speichern Sie. Das `:8080` sagt Coolifys Proxy, auf welchem Port der Server lauscht. Personen verbinden sich weiterhin über den üblichen HTTPS-Port, und Coolify setzt `OLEAFLY_PUBLIC_URL` für Sie auf `https://collab.example.org`.
5. Füllen Sie unter **Environment Variables** `OLEAFLY_SERVER_NAME` aus, das Coolify als erforderlich markiert, dann `OLEAFLY_GITHUB_CLIENT_ID` und `OLEAFLY_GITHUB_CLIENT_SECRET`. Lassen Sie Variablen, die Sie nicht nutzen, leer.
6. Wählen Sie **Deploy**. Der erste Build kompiliert den Server und dauert ein paar Minuten. Ist er fertig, zeigt Coolify die Ressource als laufend und gesund.
7. Öffnen Sie `https://collab.example.org/healthz` in einem Browser. Er zeigt `{"status":"ok"}`.
8. Öffnen Sie **Logs**, wählen Sie den Container `oleafly-server` und kopieren Sie den Code aus der neuesten Zeile, die mit `Setup code:` beginnt.
9. [Werden Sie mit diesem Code der erste Admin](#become-the-first-admin).

Startet der Server nicht, nennt sein Log die Einstellung, die er nicht verwenden kann. Sagt es, dass `OLEAFLY_PUBLIC_URL` nicht gesetzt ist, fehlt Schritt 4. Eine Domain, die mit `http://` beginnt, wird abgelehnt, weil der Server HTTPS braucht.

Steht Cloudflare vor Coolify, weil Ihr DNS-Eintrag durch Cloudflares Proxy geht oder ein Tunnel zu Coolifys Proxy führt, setzen Sie `OLEAFLY_PROXY_HOPS` auf `2`. Ohne das zeigt das Sicherheitsprotokoll für alle die Adresse des Proxys, und alle teilen sich ein Anmelde-Limit.

Die Coolify-Datei hat Platz für GitHub und einen OpenID-Connect-Anbieter namens `UNIVERSITY`. Setzen Sie `OLEAFLY_OIDC_UNIVERSITY_LABEL` auf den Text, den Personen sehen sollen, etwa `GitLab`. Seine Callback-Adresse endet auf `/auth/callback/university`. Für weitere Anbieter stellen Sie aus einem Fork mit Ihrer eigenen Kopie der Datei bereit.

Die Daten liegen in einem Docker-Volume, dessen Name auf `oleafly-data` endet. Finden Sie es mit `docker volume ls --filter name=oleafly-data`. Das Image hat keine Shell, darum kann Coolifys **Terminal** keine im Container des Servers öffnen. Logs und der Health-Check funktionieren wie gewohnt.

### Das veröffentlichte Image bereitstellen

Das Betreiben des veröffentlichten Images überspringt den Bau, was zu einem kleinen Coolify-Server passt. Folgen Sie den Schritten oben mit zwei Änderungen. Setzen Sie in Schritt 2 **Docker Compose Location** auf `/deploy/server/docker-compose.coolify-image.yml`. Überspringen Sie Schritt 3, weil nichts gebaut wird. Die Datei folgt einer Release-Serie, darum zieht jedes **Redeploy** das neueste Release darin.

## Render

[Deploy to Render](https://render.com/deploy?repo=https://github.com/Oleafly/Oleafly) liest den Blueprint im Oleafly-Repository. Er erstellt einen Webdienst aus dem veröffentlichten Image, mit einer 1-GB-Festplatte für den Datenordner. Render hängt Festplatten nur an bezahlte Instanztypen, darum startet der Dienst auf dem kleinsten bezahlten, in Renders Region Oregon. Für eine andere Region stellen Sie aus einem Fork bereit, mit in `render.yaml` gesetztem `region`.

1. Öffnen Sie den Link und melden Sie sich bei Render an.
2. Render fragt nach `OLEAFLY_SERVER_NAME` und der GitHub-Client-ID samt Secret. Füllen Sie den Namen aus und lassen Sie die GitHub-Felder vorerst leer. Ihre Callback-Adresse hängt von der Adresse des Dienstes ab, die Sie noch nicht haben.
3. Wählen Sie **Deploy Blueprint**. Sobald der Dienst läuft, zeigt seine Seite seine Adresse, etwa `https://oleafly-server.onrender.com`. Der Blueprint setzt `OLEAFLY_PUBLIC_URL` auf diese Adresse.
4. Erstellen Sie die GitHub-OAuth-App wie unter [GitHub](/docs/collaboration/server-access/#github) beschrieben, mit dieser Adresse, gefolgt von `/auth/callback/github`, als Callback-Adresse. Fügen Sie Client-ID und Secret unter **Environment** des Dienstes hinzu. Render startet den Server damit neu.
5. Finden Sie die neueste Zeile `Setup code:` in den **Logs** des Dienstes und [werden Sie der erste Admin](#become-the-first-admin).

Geben Sie dem Dienst Ihre eigene Domain, setzen Sie `OLEAFLY_PUBLIC_URL` unter **Environment** darauf und ändern Sie die Callback-Adresse bei GitHub entsprechend.

Wegen der Festplatte stoppt Render den laufenden Server, bevor er den neuen startet, darum nimmt jede Bereitstellung den Server für ein paar Sekunden weg. Oleafly verbindet sich von selbst wieder.

## Railway

Railway betreibt das veröffentlichte Image, mit einem Volume für den Datenordner.

1. Wählen Sie in einem Railway-Projekt **+ New** und dann **Docker Image** und geben Sie `ghcr.io/oleafly/oleafly-server:latest` ein. Um selbst zu wählen, wann Sie aktualisieren, verwenden Sie stattdessen den eigenen Tag eines Releases von der [Release-Seite](https://github.com/Oleafly/Oleafly/releases). Railway kann sofort eine erste Bereitstellung starten. Sie stoppt mit `OLEAFLY_PUBLIC_URL is not set`, was an diesem Punkt erwartet wird.
2. Öffnen Sie den Dienst. Wählen Sie unter **Settings › Networking** **Generate Domain** und geben Sie den Port `8080` ein. Railway zeigt die Adresse, etwa `oleafly-server-production.up.railway.app`.
3. Setzen Sie unter **Settings › Deploy** **Healthcheck Path** auf `/readyz`.
4. Klicken Sie mit der rechten Maustaste auf die Projektfläche, fügen Sie ein Volume hinzu, hängen Sie es an den Dienst des Servers und setzen Sie seinen Mount-Pfad auf `/data`.
5. Öffnen Sie unter **Variables** den **Raw Editor** und fügen Sie diese Zeilen mit Ihrem eigenen Servernamen ein. Für die GitHub-Werte folgen Sie [GitHub](/docs/collaboration/server-access/#github). Die Callback-Adresse ist Ihre Adresse aus Schritt 2, mit `https://` davor und `/auth/callback/github` dahinter.

   ```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 hängt Volumes als root ein. `RAILWAY_RUN_UID=0` betreibt den Server als root, damit er auf das Volume schreiben kann.

6. Stellen Sie die Änderungen bereit. Finden Sie die neueste Zeile `Setup code:` in den **Deploy Logs** des Dienstes und [werden Sie der erste Admin](#become-the-first-admin).

## Linux ohne Docker

Auf einer Maschine ohne Docker läuft der Server als einzelnes Programm unter systemd, mit Caddy davor für HTTPS.

### Den Server herunterladen

Jedes Server-Release auf der [Release-Seite](https://github.com/Oleafly/Oleafly/releases) enthält ein fertig gebautes Programm für x86-64 und für ARM sowie eine `SHA256SUMS`-Datei zum Abgleichen. Das Programm braucht nichts weiter installiert.

Laden Sie das Archiv für Ihre Maschine, endend auf `x86_64-unknown-linux-musl.tar.gz` oder `aarch64-unknown-linux-musl.tar.gz`, und `SHA256SUMS` in einen Ordner herunter. Prüfen und installieren Sie es dann. Auf einer ARM-Maschine verwenden Sie `aarch64` anstelle von `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
```

Mit installierter GitHub-CLI prüft `gh attestation verify oleafly-server-*-x86_64-unknown-linux-musl.tar.gz --repo Oleafly/Oleafly` außerdem, dass GitHub das Archiv aus dem Oleafly-Repository gebaut hat. Das Archiv enthält die systemd-Unit, `oleafly-server.service`.

Um das Programm stattdessen selbst zu bauen, führen Sie dies aus einem Klon des Oleafly-Repositories auf einem beliebigen Computer mit Docker aus. Verwenden Sie für einen ARM-Server `--platform linux/arm64`.

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

Das schreibt `dist/oleafly-server`. Kopieren Sie es auf dem Server nach `/usr/local/bin/oleafly-server` und machen Sie es ausführbar.

### Betrieb mit systemd

1. Erstellen Sie die Einstellungsdatei. Nur root kann sie lesen:

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

   Schreiben Sie eine Einstellung pro Zeile. `OLEAFLY_BIND=127.0.0.1:8080` hält den Server aus dem Netzwerk heraus, sodass nur Caddy ihn erreichen kann. Setzen Sie `OLEAFLY_DATA_DIR` nicht, weil die Unit ihn setzt.

   ```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. Installieren und starten Sie die Unit aus dem entpackten Archiv oder aus `deploy/server` in einem Klon des Repositories. Finden Sie dann den Einrichtungscode:

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

Die Unit betreibt den Server als Benutzer, den systemd dafür anlegt, mit einer nur lesenden Sicht auf den Rest des Systems. Der einzige Ort, auf den er schreiben kann, ist `/var/lib/oleafly-server`, wo er seine Daten hält. Auf der Festplatte ist dieser Ordner `/var/lib/private/oleafly-server`.

Um das Client-Secret aus der Einstellungsdatei herauszuhalten, verwenden Sie eine systemd-Credential. Speichern Sie das Secret in `/etc/oleafly-server/github-client-secret` mit den Rechten 600, löschen Sie die Zeile `OLEAFLY_GITHUB_CLIENT_SECRET` aus der Einstellungsdatei, führen Sie `sudo systemctl edit oleafly-server` aus und fügen Sie hinzu:

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

Führen Sie dann `sudo systemctl restart oleafly-server` aus.

### HTTPS vorschalten

Installieren Sie Caddy nach [seiner Anleitung für Ihre Distribution](https://caddyserver.com/docs/install). Ersetzen Sie `/etc/caddy/Caddyfile` durch diese Zeilen und führen Sie `sudo systemctl reload caddy` aus. Caddy holt das Zertifikat und leitet Live-Verbindungen durch.

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

Für nginx oder Apache oder einen Webserver, den Ihre Universität bereits betreibt, lesen Sie [Hinter einem Reverse-Proxy](/docs/collaboration/server-operations/#behind-a-reverse-proxy).

## Ohne öffentliche Adresse

Hat die Maschine keine öffentliche Adresse, zum Beispiel ein Computer in Ihrem Labor hinter der Firewall der Universität, kann Cloudflare Tunnel sie erreichbar machen. Sie brauchen ein Cloudflare-Konto mit Ihrer Domain darauf. Cloudflare übernimmt HTTPS für den Hostnamen, darum werden Anfragen auf Cloudflares Netzwerk entschlüsselt, bevor sie Ihre Maschine erreichen. Zählen Sie Cloudflare zu den Parteien, die den Verkehr zu Ihrem Server lesen können.

1. Folgen Sie den Schritten von [Docker Compose von Hand](#docker-compose-by-hand) bis zur Bearbeitung von `.env`. Setzen Sie `OLEAFLY_DOMAIN` auf den Hostnamen, den Sie verwenden, etwa `collab.example.org`. Das Installationsprogramm mit einem Befehl passt hier nicht, weil es Caddy startet.
2. Starten Sie nur den Server. Caddy wird hier nicht gebraucht:

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

3. Gehen Sie im Cloudflare-Dashboard zu **Networking › Tunnels**, wählen Sie **Create Tunnel**, geben Sie ihm einen Namen und wählen Sie erneut **Create Tunnel**. Kopieren Sie das Token aus dem Installationsbefehl, den es zeigt.
4. Starten Sie den Tunnel neben dem Server. Der Befehl `read` wartet darauf, dass Sie das Token einfügen, und zeigt es nicht an:

   ```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. Zurück im Dashboard öffnen Sie den Tunnel. Wählen Sie unter **Routes** **Add route** und dann **Published application**. Geben Sie unter **Hostname** die Subdomain ein und wählen Sie Ihre Domain. Setzen Sie **Service URL** auf `http://oleafly-server:8080` und wählen Sie **Add route**.
6. Prüfen Sie, dass es unter `https://collab.example.org/healthz` antwortet, und [werden Sie dann der erste Admin](#become-the-first-admin).

Installieren Sie auf einer Maschine ohne Docker `cloudflared` aus [Cloudflares Paketrepository](https://pkg.cloudflare.com/), führen Sie `sudo cloudflared service install` gefolgt vom Token aus und setzen Sie **Service URL** auf `http://127.0.0.1:8080`.

Cloudflare leitet Live-Verbindungen durch und setzt die Adresse des Besuchers an letzte Stelle in `X-Forwarded-For`, darum lassen Sie `OLEAFLY_BEHIND_PROXY=true` gesetzt. Führt der Tunnel zu einem anderen Proxy, etwa dem von Coolify, und nicht direkt zum Server, setzen Sie außerdem `OLEAFLY_PROXY_HOPS=2`. Cloudflare lehnt Anfragen über 100 MB in seinen Free- und Pro-Tarifen ab. Setzen Sie darum `OLEAFLY_MAX_PROJECT_MB` auf 100 oder weniger, sonst scheitert das Hochladen großer Projekte. Setzen Sie kein Cloudflare Access vor den Server, weil Oleafly nicht über seine Anmeldeseite hinwegkommt.

Wenn Sie den Server später aktualisieren, laden Sie die Dateien des neuen Releases herunter und benennen Sie den Dienst, damit Caddy ausbleibt: `sudo docker compose up -d oleafly-server`.

## Werden Sie der erste Admin

Ein neuer Server hat keinen Admin. Bis jemand die Einrichtung abschließt, erzeugt der Server bei jedem Start einen neuen einmaligen Einrichtungscode und schreibt ihn in sein Log.

1. Finden Sie die neueste Zeile im Log, die mit `Setup code:` beginnt:
   - Installation mit einem Befehl: Das Installationsprogramm gibt ihn aus, wenn es fertig ist. Um ihn erneut zu sehen, führen Sie `cd /opt/oleafly-server && sudo docker compose logs oleafly-server | grep 'Setup code'` aus
   - Docker Compose von Hand: `sudo docker compose logs oleafly-server | grep 'Setup code'` im Ordner des Servers
   - Coolify: die Logs des Dienstes `oleafly-server`
   - systemd: `sudo journalctl -u oleafly-server | grep 'Setup code'`
2. Öffnen Sie in Oleafly **Einstellungen → Zusammenarbeit**, wählen Sie **Server hinzufügen** und geben Sie die Adresse Ihres Servers ein. Oleafly erkennt, dass der Server eingerichtet werden muss, und fragt nach dem **Einrichtungscode**.
3. Geben Sie den Code ein und melden Sie sich mit einem beliebigen Anbieter an, den Sie eingerichtet haben. Sie werden zum Admin des Servers, und der Code funktioniert nicht mehr.

Jeder, der den Code hat, bevor Sie ihn verwenden, kann sich zum Admin machen. Fügen Sie ihn darum nur in Oleafly ein.

Sie können den Code auch selbst mit `OLEAFLY_SETUP_CODE` wählen: mindestens 12 Buchstaben oder Ziffern, bei Bedarf mit Bindestrichen oder Leerzeichen. Der Server gibt ihn dann nie aus. Das Log sagt nur `Setup code: set by OLEAFLY_SETUP_CODE`, und Sie geben den Wert ein, den Sie gesetzt haben. Entfernen Sie ihn nach der Einrichtung aus Ihren Einstellungen.

Als Nächstes lassen Sie Personen hinein. [Anmeldung und Zugriff](/docs/collaboration/server-access/#access-rules) erklärt wie.

## Den Server prüfen

- Bei der Installation mit einem Befehl prüft `sudo sh /opt/oleafly-server/install.sh status` Container und HTTPS in einem Rutsch.
- `https://collab.example.org/healthz` antwortet mit `200`, solange der Serverprozess läuft.
- `/readyz` antwortet nur mit `200`, solange der Server auf seine Datenbank und seinen Datenordner schreiben kann. Kann er es nicht, etwa bei einer vollen Festplatte, antwortet er mit `503` und nennt, was fehlschlug, `database` oder `storage`.
- Das Docker-Image prüft `/readyz` von selbst, darum zeigen `docker ps` und Coolify einen ungesunden Server statt eines laufenden, der nichts speichern kann.
- In Oleafly prüft **Verbindung testen** unter **Einstellungen → Zusammenarbeit** die Adresse, HTTPS, die Version, Live-Verbindungen, Anmeldeoptionen und die Uhr des Servers. **Verbindungstests** in der [Admin-Konsole](/docs/collaboration/server-access/#admin-console) führt dieselben Prüfungen aus.
