---
title: "Appwrite mit Docker installieren: Vollständige Open-Source-BaaS-Plattform"
date: 2026-08-20T10:29:16+02:00
modified: 2026-11-08T22:37:23+01:00
category: datenbanken
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/appwrite-docker-baas-plattform
reading_time: 16
personalize_url: "https://s-edv.com/anleitungen/appwrite-docker-baas-plattform#server_ip={server_ip}&domain={domain}"
variables:
  - name: server_ip
    label: "Server ip"
    default: "SERVER-IP"
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
---

# Appwrite mit Docker installieren: Vollständige Open-Source-BaaS-Plattform

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{server_ip}}` | Server ip | `SERVER-IP` |
| `{{domain}}` | Ihre Domain | `example.com` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/appwrite-docker-baas-plattform#server_ip=SERVER-IP&domain=cloud.example.com

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Wer ein vollständiges Backend für Web- und Mobile-Apps benötigt, greift heute oft zu Firebase oder Supabase und ist damit sofort im Cloud-Vendor-Lock-in. **Appwrite** ist die quelloffene Alternative: rund 57.000 GitHub-Stars, aktiv gepflegt und mit einem offiziellen Installer auf jedem Linux-Host oder jeder VM in Betrieb. Der Stack liefert Authentifizierung (OAuth, JWT, MFA), Datenbanken (seit Version 2.0 standardmäßig auf PostgreSQL), File Storage, Realtime-WebSockets, Serverless Functions und Sites sowie Messaging, alles hinter einem Traefik-Reverse-Proxy. Diese Anleitung zeigt Appwrite 2.6 und richtet sich an Entwicklerteams und Admins, die ein Backend ohne Cloud-Abhängigkeit selbst betreiben wollen. Wer noch Appwrite 1.9 betreibt, findet in Schritt 7 den Weg auf 2.6.1.

**Kurzfassung:** Mit dem offiziellen Installer `docker-compose.yml` und `.env` für Appwrite 2.6.1 erzeugen, Secrets setzen (vor allem `_APP_OPENSSL_KEY_V1`, der niemals verloren gehen darf) und mit `docker compose up -d` starten. Nach rund zehn Minuten meldet `/v1/health/version` die Version und die Console ist unter `http://localhost` erreichbar. Für Produktion eigene Domain in `_APP_DOMAIN` eintragen, Traefik holt dann das Let's-Encrypt-Zertifikat. Mindestens 2 CPU-Kerne, 4 GB RAM und 2 GB Swap einplanen. Bestehende 1.9-Installationen heben Sie mit dem `upgrade`-Befehl und anschließendem `migrate` an.

## Voraussetzungen

- [ ] **Docker Engine 24.0+** und **Docker Compose Plugin v2+**. Docker Desktop reicht für lokale Tests; für Produktion einen Linux-Host (Ubuntu 22.04/24.04 LTS oder Debian 12) verwenden. Wie Sie Docker auf Linux installieren, erklärt die Anleitung [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] **Mindestressourcen laut Hersteller:** 2 CPU-Kerne, 4 GB RAM, 2 GB Swap, dazu mindestens 20 GB freier Speicher. Für Produktion mit Functions und Sites sind 4 Kerne und 8 GB RAM sinnvoll. x86-64 und ARM64 werden unterstützt.
- [ ] **Öffentliche IP und Domain mit DNS-A-Record** (nur für automatisches HTTPS per Let's Encrypt). Für lokale Tests reicht `localhost`.
- [ ] **Freie Ports 80 und 443**, seit 2.3 zusätzlich 8883 und 8084 für MQTT (umstellbar). Für den Web-Assistenten wird während der Installation Port 20080 benötigt.
- [ ] `openssl` für die Schlüsselerzeugung (auf fast allen Linux-Systemen vorinstalliert).
- [ ] Optional: SMTP-Zugangsdaten für E-Mail-Funktionen (Passwort-Reset, Einladungen).

## Schritt 1: Projektordner anlegen und Secrets generieren

Seit Version 2.0 ist der Stack deutlich gewachsen (Console als eigener Container, ClickHouse für Nutzungsdaten und Ausführungslogs, MQTT, Orchestrator, Geo- und Bilddienste). Eine von Hand gepflegte `compose.yaml` veraltet damit bei jedem Release. Diese Anleitung nutzt deshalb den offiziellen Installer: Er erzeugt `docker-compose.yml` und `.env` passend zur gewählten Version und generiert dabei die Secrets. Legen Sie einen übergeordneten Ordner an; der Installer legt darin den Unterordner `appwrite` an, der später auch den Docker-Projektnamen bestimmt. Ändern Sie diesen Namen danach nicht mehr, sonst legt Docker neue, leere Volumes an.

```bash
sudo mkdir -p /opt/appwrite-install
cd /opt/appwrite-install

# Variante A: Web-Assistent (Browser unter http://{{server_ip}}:20080)
docker run -it --rm \
  --publish 20080:20080 \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
  --entrypoint="install" \
  appwrite/appwrite:2.6.1

# Variante B: ohne Rückfragen, nur Dateien erzeugen
docker run --rm \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
  --entrypoint="install" \
  appwrite/appwrite:2.6.1 \
  --interactive=N --no-start=true --database=postgresql \
  --http-port=80 --https-port=443 --domain=localhost
```

Der Web-Assistent fragt Hostname, Datenbank (PostgreSQL ist Standard, MariaDB und MongoDB sind wählbar), HTTPS und das erste Konto ab und zeigt den Verschlüsselungsschlüssel einmalig an. Für einen Server ohne Browserzugang auf Port 20080 eignet sich Variante B. Für `--domain` tragen Sie später Ihre echte Domain ein; zum Ausprobieren reicht `localhost`.

> **Prüfen:** ```bash
> $ ls -A /opt/appwrite-install/appwrite
> ```
>
> ```bash
> # Erwartete Ausgabe: .env  clickhouse-config.xml  clickhouse-init.sh  docker-compose.yml
> ```
>
> ```bash
> $ grep -E "^_APP_(VERSION|DB_ADAPTER)=" /opt/appwrite-install/appwrite/.env
> ```
>
> ```bash
> # Erwartete Ausgabe: _APP_DB_ADAPTER="postgresql" und _APP_VERSION="2.6.1"
> ```

Variante B meldet am Ende `Installation files created. Run "docker compose up -d" to start Appwrite`.

## Schritt 2: .env-Datei anlegen

Die `.env` legt der Installer an, Sie passen sie nur noch an. Im Web-Assistenten (Variante A) erzeugt er den Verschlüsselungsschlüssel selbst. Bei Variante B erzeugt er ebenfalls einen eigenen Schlüssel, lässt aber die übrigen Beispielwerte stehen: Die `.env` enthält danach `_APP_EXECUTOR_SECRET="your-secret-key"`, `_APP_DB_PASS="password"`, `_APP_DB_ROOT_PASS="rootsecretpassword"` und `_APP_USAGE_PASS="appwrite"`. Ersetzen Sie diese Werte **vor dem ersten Start**, denn PostgreSQL übernimmt Passwörter nur beim Anlegen des Volumes, und ein später geänderter Schlüssel macht verschlüsselte Daten unlesbar.

```bash
cd /opt/appwrite-install/appwrite
for k in _APP_OPENSSL_KEY_V1 _APP_EXECUTOR_SECRET _APP_DB_PASS _APP_DB_ROOT_PASS _APP_USAGE_PASS; do
  sed -i "s|^$k=.*|$k=\"$(openssl rand -hex 32)\"|" .env
done
chmod 600 .env
cp .env /sicherer/ort/appwrite.env.$(date +%Y%m%d)
```

Vier weitere Werte sollten Sie ansehen:

- `_APP_OPENSSL_KEY_V1`: verschlüsselt Sessions, Webhook-Secrets, Provider-Zugangsdaten und Dateien. Geht er verloren, sind diese Daten nicht wiederherstellbar. Legen Sie ihn zusätzlich im Passwortmanager ab.
- `_APP_DOMAIN` und `_APP_DOMAIN_TARGET`: der Hostname, unter dem Console und API erreichbar sind.
- `_APP_SYSTEM_EMAIL_ADDRESS`, `_APP_EMAIL_CERTIFICATES` und die `_APP_SMTP_*`-Werte: Absender, Kontaktadresse für Zertifikate und Mailserver für Passwort-Reset und Einladungen. Ohne SMTP läuft Appwrite, verschickt aber keine Mails.
- `_APP_EXIFTOOL_HOST` (neu in 2.6): Adresse des Dienstes `appwrite-exiftool`, der aus neuen Bild-Uploads Ort, Gerät und Aufnahmezeit entfernt, wenn im Bucket die Option „Image metadata“ (API: `stripMetadata`) aktiv ist. Der Installer lässt den Wert leer, ein Bild behält deshalb trotz aktiver Option seine Geräte- und GPS-Angaben (Log: `Exiftool needs to be configured with _APP_EXIFTOOL_HOST to strip metadata`). Mit `_APP_EXIFTOOL_HOST="http://appwrite-exiftool:8080"` und `docker compose up -d` entfernt Appwrite die Angaben. Vorhandene Dateien bleiben laut Release Notes unverändert.

> **Prüfen:** ```bash
> $ ls -l .env
> ```
>
> ```bash
> # Erwartete Ausgabe: -rw------- ... .env
> ```
>
> ```bash
> $ grep -E "^_APP_(OPENSSL_KEY_V1|EXECUTOR_SECRET|DB_PASS|DB_ROOT_PASS|USAGE_PASS)=" .env | grep -cE "your-secret-key|=\"?(password|rootsecretpassword|appwrite)\"?$"
> ```
>
> ```bash
> # Erwartete Ausgabe: 0
> ```

## Schritt 3: compose.yaml einspielen

Eine eigene `compose.yaml` müssen Sie nicht mehr einspielen: Der Installer hat sie als `docker-compose.yml` erzeugt und alle Images darin festgeschrieben. In der Standardinstallation (Topologie „combined“, PostgreSQL) laufen mit Appwrite 2.6.1 insgesamt 18 Container:

| Dienst | Image | Zweck |
| --- | --- | --- |
| appwrite, appwrite-realtime, appwrite-worker, appwrite-task-* | `appwrite/appwrite:2.6.1` | API, WebSocket, Worker und Zeitsteuerung |
| appwrite-console | `appwrite/new:1.2.97-self-hosted` | Web-Oberfläche |
| appwrite-mqtt | `appwrite/appwrite:2.6.1` | MQTT-Endpunkt (neu in 2.3) |
| postgresql | `appwrite/postgres:0.1.0` | Datenbank (Standard seit 2.0) |
| clickhouse | `clickhouse/clickhouse-server:26.4.3-alpine` | Nutzungsstatistik und Ausführungslogs |
| redis | `redis:7.4.7-alpine` | Cache und Warteschlangen |
| exc1, orchestrator | `openruntimes/executor:1.1.2`, Orchestrator 2.2.4 | Functions und Sites bauen und ausführen |
| traefik | `traefik:3.6` | Reverse Proxy, TLS |
| appwrite-geo, appwrite-browser, appwrite-autogravity, appwrite-exiftool | eigene Images | Geo-Daten, Screenshots, Bildzuschnitt, Bild-Metadaten entfernen (neu in 2.6) |

| Port (Host) | Zweck |
| --- | --- |
| 80, 443 | Console und API über Traefik |
| 8883, 8084 | MQTT über TLS und MQTT über WebSocket (anpassbar mit `_APP_MQTT_PORT`, `_APP_MQTT_WSS_PORT`) |

Wichtige Volumes: `appwrite-postgresql` (Datenbank), `appwrite-uploads` (Dateien), `appwrite-functions`, `appwrite-sites`, `appwrite-builds`, `appwrite-certificates` und `appwrite-clickhouse`. Der Embedding-Dienst für Vektorsuche ist ressourcenhungrig und standardmäßig aus; er startet nur mit `COMPOSE_PROFILES=embedding`. Bearbeiten Sie die Datei möglichst nicht von Hand: Beim nächsten `upgrade` schreibt der Installer sie neu und legt eine Sicherungskopie daneben.

> **Prüfen:** ```bash
> $ cd /opt/appwrite-install/appwrite
> $ docker compose config --quiet && echo "YAML valide"
> $ grep -E "^\s+image:" docker-compose.yml | sort | uniq -c
> ```

## Schritt 4: Stack starten

Beim ersten Start zieht Docker alle Images, das sind mehrere Gigabyte. Der erste Start mit Image-Download dauert bis zum Status `healthy` des API-Containers rund zehn Minuten, ein Start mit bereits geladenen Images rund eine Minute.

```bash
$ cd /opt/appwrite-install/appwrite
$ docker compose up -d
```

```bash
# Logs verfolgen (Strg+C beendet nur die Anzeige)
```

```bash
$ docker compose logs -f appwrite
```

> **Prüfen:** ```bash
> $ docker compose ps --format "{{.Name}}\t{{.Status}}"
> ```
>
> ```bash
> # Erwartet: appwrite, appwrite-autogravity, appwrite-clickhouse-1, appwrite-console,
> # appwrite-exiftool, appwrite-geo, appwrite-mqtt, appwrite-postgresql,
> # appwrite-redis und exc1 mit (healthy), die übrigen mit Up
> ```
>
> ```bash
> $ curl -s http://localhost/v1/health/version
> ```
>
> ```bash
> # Erwartete Ausgabe: {"version":"2.6.1"}
> ```

Der Stack belegt nach dem Start rund 1,8 GB RAM, davon ClickHouse knapp 400 MB. Die Vorgabe von 4 GB RAM plus Swap ist also kein Puffer, sondern die Untergrenze.

## Schritt 5: Erstes Admin-Konto anlegen

Öffnen Sie `http://localhost` im Browser (bei eigener Domain: `https://ihre-domain.de`). Haben Sie im Web-Assistenten bereits ein Konto angelegt, melden Sie sich damit an. Sonst zeigt die Console das Registrierungsformular; das erste Konto erhält die Rechte für die Instanz. Seit 2.0 erscheint die neue Console mit überarbeiteter Navigation, eingebautem Terminal (Appwrite CLI) und API-Explorer.

Nach dem Login legen Sie über „Create project“ Ihr erstes Projekt an. Darin finden Sie Auth, Databases, Storage, Functions, Sites, Messaging und Realtime, jeweils mit API-Keys und SDK-Beispielen für Web, Flutter, React Native, Python, Node.js, Go, PHP und weitere Plattformen.

Möchten Sie den Zugang zur Console auf bestimmte E-Mail-Adressen oder IP-Adressen beschränken, nutzen Sie `_APP_CONSOLE_WHITELIST_EMAILS` bzw. `_APP_CONSOLE_WHITELIST_IPS` in der `.env` und starten den Stack danach mit `docker compose up -d` neu.

> **Prüfen:** ```bash
> # HTTP-Antwort der Console prüfen
> ```
>
> ```bash
> $ curl -s -o /dev/null -w "%{http_code}\n" http://localhost/
> ```
>
> ```bash
> # Erwartete Ausgabe: 200
>
> # Im Browser: http://localhost zeigt Login bzw. Registrierung der Console
> ```

## Schritt 6: HTTPS mit eigener Domain (Produktion)

Für den produktiven Betrieb mit Let's-Encrypt-Zertifikat tragen Sie Ihre Domain in die `.env` ein und erstellen den Stack neu:

Datei: `.env`

```ini
cd /opt/appwrite-install/appwrite

# .env anpassen:
# _APP_DOMAIN=appwrite.{{domain}}
# _APP_DOMAIN_TARGET=appwrite.{{domain}}
# _APP_EMAIL_CERTIFICATES=admin@{{domain}}
# _APP_OPTIONS_FORCE_HTTPS=enabled

docker compose up -d --force-recreate
```

Appwrite stellt die Zertifikate selbst über die HTTP-01-Challenge aus und legt sie im Volume `appwrite-certificates` ab; Traefik liest sie von dort. Der DNS-A-Record muss vorher auf die öffentliche IP zeigen und Port 80 muss von außen erreichbar sein. Läuft die Console auf einem anderen Hostnamen als die API, setzen Sie seit 2.3 zusätzlich `_APP_CONSOLE_URL` (zum Beispiel `https://console.{{domain}}`); daraus baut Appwrite alle Links in Mails, OAuth-Rückleitungen und VCS-Kommentaren. Für Reverse-Proxy-Grundlagen hilft die Anleitung [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).

> **Prüfen:** Die Abfrage über HTTPS liefert die Version, das Worker-Log zeigt die Zertifikatsausstellung.
>
> ```bash
> $ curl -s https://appwrite.{{domain}}/v1/health/version
> ```
>
> ```bash
> # Erwartete Ausgabe: {"version":"2.6.1"}
> ```
>
> ```bash
> $ docker compose logs appwrite-worker | grep -i certificate
> ```

## Schritt 7: Updates und Backup

Appwrite wird nicht per `docker compose pull` aktualisiert, sondern mit dem `upgrade`-Befehl des Installers. Er liest Ihre bestehende `docker-compose.yml` und `.env`, übernimmt die Werte, legt Sicherungskopien an (`docker-compose.yml.ZEITSTEMPEL.backup`, `.env.ZEITSTEMPEL.backup`) und schreibt die Dateien der neuen Version. Anschließend startet er den Stack mit `docker compose up -d --remove-orphans --renew-anon-volumes` selbst neu, danach führen Sie die Datenmigration aus. Führen Sie den Befehl im **übergeordneten** Ordner aus, in dem der Ordner `appwrite` liegt.

```bash
cd /opt/appwrite-install

# 1. Backup anlegen (siehe unten)
# 2. Upgrade auf die gewünschte Version
docker run -it --rm \
  --publish 20080:20080 \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
  --entrypoint="upgrade" \
  appwrite/appwrite:2.6.1

# 3. Datenmigration ausführen und auf das Ende warten
cd appwrite
docker compose exec appwrite migrate
```

**Update von 2.5 auf 2.6**

Der Weg von 2.5.0 auf 2.6.1 sieht so aus: Ausgangspunkt ist eine Installation 2.5.0 mit Variante B, mit Konto, Team, Projekt samt API-Key und einer Datenbankzeile als Marker. Nach einem Backup wie unten beschrieben führen Sie `upgrade` mit `appwrite/appwrite:2.6.1` und `--interactive=N` aus. Der Installer legt die Sicherungskopien an, lässt `_APP_OPENSSL_KEY_V1` unverändert und startet den Stack selbst, direkt danach meldet `docker compose exec appwrite migrate` `Migration completed`. `/v1/health/version` meldet `2.6.1`, `php -v` im Container PHP 8.5.12. Alte Sitzung, alter API-Key und Datenbankzeile funktionieren weiter, eine neue Anmeldung gelingt (HTTP 201), ein falsches Passwort ergibt HTTP 401, die Console antwortet mit HTTP 200, und alle 18 Container laufen. Der Weg von 2.3.0 auf 2.5.0 funktioniert ebenso.

Laut Release Notes zu 2.6.0 ist `migrate` auch von 2.5.0 aus Pflicht, weil neue Felder für Beschreibungen und die Bucket-Option für Bild-Metadaten hinzukommen. Ausgehende TLS-Verbindungen lehnen die kompromittierten eMudhra-Zertifikatsketten ab; HTTPS-Ziele wie Webhooks mit so einer Kette müssen ihr Zertifikat tauschen. Für eigene S3-kompatible Speicher gibt es `_APP_STORAGE_S3_PATH_STYLE`. Die mit PHP 8.5.12 in 2.6.1 geschlossenen Lücken betreffen Appwrite laut Release Notes nicht.

Vor dem Update prüfen laut Release Notes zu 2.4: Hinter einem öffentlichen Load Balancer wie Cloudflare tragen Sie dessen Adressbereiche in `_APP_TRUSTED_PROXIES` ein (sonst teilen sich alle Clients dessen Rate-Limits). OAuth2-, Webhook- und Messaging-Ziele mit privater Adresse müssen in `_APP_ALLOWED_INTERNAL_ADDRESSES` stehen. Die GitHub-Integration braucht ein Webhook-Secret in `_APP_VCS_GITHUB_WEBHOOK_SECRET`, und `_APP_ASSISTANT_OPENAI_API_KEY` entfällt, weil der Assistant entfernt wurde. Wer mit `--use-existing-config` aktualisiert, übernimmt die zwei neuen ClickHouse-Mounts aus 2.4 und das Executor-Image `openruntimes/executor:1.1.2` aus 2.5 und, wer Bild-Metadaten entfernen lassen will, den Dienst `appwrite-exiftool` (`ghcr.io/appwrite/exiftool:0.1.0`) aus 2.6 selbst in die eigene Compose-Datei. Laufende Funktionscontainer werden beim Start entfernt und starten bei der nächsten Ausführung kalt.

**Migration von Appwrite 1.9 auf 2.6**

Appwrite 2.0 ist eine neue Hauptversion mit neuer Console und erweitertem Stack. Laut offiziellem Upgrade-Leitfaden gelangt eine Installation ab **1.9.6** in einem Schritt auf 2.6.1. Für eine Installation auf 1.9.0 aus der früheren Fassung dieser Anleitung heißt das:

1. **Vollständiges Backup** von `.env`, Datenbank und Volumes anlegen (siehe unten). Ein Rückweg ist nur über dieses Backup möglich.
2. **Zuerst auf 1.9.6:** `upgrade` mit dem Image `appwrite/appwrite:1.9.6` ausführen, danach `docker compose exec appwrite migrate`.
3. **Dann auf 2.6.1:** `upgrade` mit `appwrite/appwrite:2.6.1`, danach erneut `migrate`. Die Laufzeit wächst mit der Zahl der Projekte.
4. **Datenbank bleibt:** PostgreSQL ist nur für Neuinstallationen Standard. Eine MongoDB- oder MariaDB-Installation bleibt beim Upgrade auf ihrem Datenbanksystem; einen Wechsel des Datenbanksystems führt der Installer nicht durch. Dafür ist eine Neuinstallation nötig, in die Sie die Projekte über die Migrations-Funktion der Console (Quelle „Self hosted“) übertragen.
5. **Hand gepflegte Compose-Dateien:** Haben Sie die `compose.yaml` aus der früheren Fassung dieser Anleitung von Hand angelegt, erkennt der Installer sie nicht, denn er erwartet `appwrite/docker-compose.yml` und `appwrite/.env`. Erzeugen Sie dann mit dem Installer neue Dateien in einem Ordner namens `appwrite`, übernehmen Sie `_APP_OPENSSL_KEY_V1`, `_APP_DB_ADAPTER=mongodb` sowie Datenbank-Benutzer und -Passwörter aus Ihrer alten `.env` und gleichen Sie Volume-Namen und Projektnamen mit dem Bestand ab, bevor Sie `upgrade` und `migrate` ausführen. Prüfen Sie dabei mit `docker inspect appwrite-mongo`, wo die Daten wirklich liegen: Die frühere Fassung band das Volume unter `/var/lib/mongodb/data` ein, das MongoDB-Image speichert standardmäßig unter `/data/db`.
6. **Geänderte Variablen:** `_APP_CONSOLE_URL_SCHEME` entfällt (stattdessen `_APP_CONSOLE_URL`), ebenso `_APP_LOGGING_PROVIDER`, `_APP_LOGGING_CONFIG_REALTIME` und `_APP_EXECUTIONS_DUAL_WRITE`. Fehlerberichte gehen nur noch an Sentry über `_APP_LOGGING_CONFIG`. Neu sind die MQTT-Ports 8883 und 8084.
7. **Geändertes Verhalten:** Dev Keys sind seit 2.3 vollständig entfernt, `migrate` löscht sie. Ausführungslogs von Functions und Sites liegen seit 2.2 nur noch in ClickHouse; Ausführungen, die nur in der Projektdatenbank existierten, werden nicht mehr angezeigt. Die Ausführungsdauer enthält seit 2.3 den Kaltstart.

Auf einer frischen Installation von Appwrite 2.6.1 mit Variante B und den Secrets aus Schritt 2 (PostgreSQL, Topologie „combined“) läuft `migrate` auch nach dem Anlegen von Konto, Team, Projekt, API-Key und einer Datenbankzeile über die API sauber durch (`Migration completed`). Testen Sie den Upgrade-Weg von 1.9.0 über 1.9.6 auf 2.6.1 mit Bestandsdaten vor dem Produktivsystem auf einer Kopie, wie es auch der Hersteller empfiehlt.

**Backup**

Sichern Sie mindestens die `.env` (vor allem `_APP_OPENSSL_KEY_V1`), die Datenbank und die Volumes mit Benutzerdaten:

```bash
$ cd /opt/appwrite-install/appwrite
$ cp .env /sicherer/ort/appwrite.env.$(date +%Y%m%d)
```

```bash
# PostgreSQL (Standard seit 2.0)
```

```bash
$ docker compose exec -T postgresql sh -c 'pg_dumpall -U "$POSTGRES_USER"' > appwrite-$(date +%Y%m%d).sql
```

```bash
# MongoDB-Installation (z. B. von 1.9 übernommen)
```

```bash
$ docker compose exec -T mongodb sh -c 'exec mongodump --username=root --password="$MONGO_INITDB_ROOT_PASSWORD" --authenticationDatabase=admin --archive' > appwrite-$(date +%Y%m%d).archive
```

```bash
# Uploads-Volume bei gestopptem Stack als Archiv sichern
```

```bash
$ docker compose stop
$ docker run --rm -v appwrite_appwrite-uploads:/data -v "$(pwd)":/backup alpine tar czf /backup/uploads-$(date +%Y%m%d).tar.gz -C /data .
$ docker compose start
```

Weitere Volumes wie `appwrite-functions`, `appwrite-sites` und `appwrite-builds` sichern Sie auf dieselbe Weise. Benachrichtigungen über neue Images liefern [Diun oder WUD](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud); das Update selbst führen Sie bei Appwrite immer manuell mit `upgrade` und `migrate` aus.

> **Prüfen:** ```bash
> $ cd /opt/appwrite-install/appwrite
> $ docker compose ps --format "{{.Name}}\t{{.Status}}"
> $ curl -s http://localhost/v1/health/version
> ```
>
> ```bash
> # Erwartete Ausgabe nach dem Upgrade: {"version":"2.6.1"}
> ```
>
> ```bash
> $ ls -lh appwrite-*.sql
> ```
>
> ```bash
> # Dump vorhanden und nicht leer
> ```

## Troubleshooting / Typische Fehler

**Installer meldet „Appwrite installation not found“ beim Upgrade**

Der Befehl lief im falschen Ordner. Er muss im übergeordneten Ordner laufen, in dem `appwrite/docker-compose.yml` liegt.

**Container `appwrite` bleibt lange „starting“**

Der Healthcheck hat eine Startphase von 120 Sekunden, beim ersten Start kommen Image-Download und Datenbank-Initialisierung dazu. Mit `docker compose logs appwrite postgresql clickhouse` prüfen; der Stack ist nach rund zehn Minuten bereit.

**Speicher reicht nicht (OOM, Container starten neu)**

Der Stack belegt rund 1,8 GB RAM ohne Last. Unter 4 GB RAM ohne Swap wird es eng, sobald Functions bauen. Swap einrichten oder den Host vergrößern; den Embedding-Dienst nur bei Bedarf über `COMPOSE_PROFILES=embedding` zuschalten.

**Ports 80, 443, 8883 oder 8084 belegt**

Prüfen mit `ss -tlnp | grep -E ':(80|443|8883|8084) '`. Für MQTT lassen sich `_APP_MQTT_PORT` und `_APP_MQTT_WSS_PORT` in der `.env` ändern, für HTTP und HTTPS `_APP_HTTP_PORT` und `_APP_HTTPS_PORT`.

**„Executor not reachable“ bei Functions**

Der Executor-Container (`exc1`) braucht Zugriff auf `/var/run/docker.sock`. Prüfen mit `docker inspect exc1 | grep docker.sock`. Beim ersten Aufruf einer Runtime lädt er das Runtime-Image nach; das dauert und ist kein Fehler.

**SSL-Zertifikat wird nicht ausgestellt**

Let's Encrypt braucht eine öffentlich erreichbare Domain und Port 80 von außen. `_APP_DOMAIN=localhost` oder eine private IP funktioniert nicht. Für lokale Tests HTTP verwenden.

**Nach dem Upgrade fehlen Ausführungslogs**

Seit 2.2 liegen sie nur in ClickHouse. Ausführungen, die vorher nur in der Projektdatenbank gespeichert waren, zeigt die Console nicht mehr an.

**Daten nach Umbenennung des Ordners verschwunden**

Docker benennt Projekt und Volumes nach dem Ordner `appwrite`. Prüfen mit `docker volume ls | grep appwrite` und den Ordnernamen zurücksetzen.

**Statuscodes in eigenen Skripten passen nicht**

Seit 1.9 liefert die API bei gesperrten Ressourcen HTTP 403 statt 401. Dev Keys und der Header `X-Appwrite-Dev-Key` funktionieren seit 2.3 nicht mehr, verwenden Sie API-Keys.

## Häufige Fragen

### Wie installiere ich Appwrite am schnellsten?

Mit dem offiziellen Installer. Er startet einen Web-Assistenten auf Port 20080, fragt Domain, Datenbank und erstes Konto ab und startet den Stack:

```bash
docker run -it --rm \
  --publish 20080:20080 \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --volume "$(pwd)/appwrite:/usr/src/code/appwrite:rw" \
  --entrypoint=install \
  appwrite/appwrite:2.6.1
```

Wer keinen Browserzugang zum Server hat, nutzt die Variante ohne Rückfragen aus Schritt 1 und setzt die Secrets danach selbst (Schritt 2).

### Kann ich Appwrite auf einem Raspberry Pi (ARM64) betreiben?

Ja. Die Images von Appwrite 2.6.1 und der mitgelieferten Dienste (PostgreSQL, ClickHouse, Executor, Console, ExifTool) gibt es laut Docker Hub und GitHub Container Registry für `linux/amd64` und `linux/arm64`. Ein Raspberry Pi 5 mit 8 GB RAM und 64-Bit-OS ist für Tests denkbar; bei 4 GB RAM bleibt neben dem gewachsenen 2.x-Stack wenig Reserve.

### Welche Programmiersprachen werden für Serverless Functions unterstützt?

Appwrite bietet Runtimes unter anderem für Node.js, Python, PHP, Ruby, Dart und Flutter, Swift, .NET, Go, Bun, Deno, Kotlin, Java und Rust. Welche auf Ihrer Instanz aktiv sind, legt `_APP_FUNCTIONS_RUNTIMES` in der `.env` fest; die vom Installer erzeugte Datei aktiviert mit 2.6.1 `node-16.0`, `node-22`, `php-8.0`, `python-3.9` und `ruby-3.0`. Jede Runtime läuft als eigener Container, den der Executor bei Bedarf startet.

### Ich habe keine eigene Domain, kann ich Appwrite trotzdem nutzen?

Für lokale Entwicklung belassen Sie `_APP_DOMAIN=localhost` und greifen über `http://localhost` zu. Für öffentlichen Zugriff ohne eigene Domain eignen sich Dienste wie `nip.io` (z. B. `192.168.1.100.nip.io`) oder ein Tunnel-Dienst wie Cloudflare Tunnel.

### Welche Daten muss ich für ein vollständiges Backup sichern?

Drei Elemente sind kritisch: die `.env`-Datei mit `_APP_OPENSSL_KEY_V1` (ohne diesen Schlüssel sind verschlüsselte Daten wertlos), ein regelmäßiger Datenbank-Dump (PostgreSQL per `pg_dumpall`, bei übernommenen Installationen MongoDB per `mongodump`) und das Uploads-Volume `appwrite_appwrite-uploads`. Laut Hersteller sollten Sie einen Dump nur in eine frische Installation zurückspielen.

### Wie unterscheidet sich Appwrite von PocketBase oder Supabase?

Appwrite ist der umfangreichste der drei BaaS-Kandidaten: Ein vollständiger Stack mit 18 Containern in der Standardinstallation, PostgreSQL, MariaDB oder MongoDB als Datenbank, Serverless Functions, Sites, Messaging und einer fertigen Web-Console. [PocketBase](https://s-edv.com/anleitungen/pocketbase-docker-backend-framework) hingegen ist ein einzelnes Go-Binary, ideal für kleine Projekte mit minimaler Infrastruktur. Supabase setzt ebenfalls auf PostgreSQL und bringt einen eigenen Selfhosting-Stack mit. Appwrite eignet sich am besten für Teams, die ein produktionstaugliches Backend mit breitem Feature-Set selbst betreiben wollen.

## Fazit

Appwrite 2.6 liefert mit dem offiziellen Installer ein vollständiges Backend-as-a-Service-Setup, das Firebase und Supabase in der Breite kaum nachsteht. Der Preis dafür ist ein deutlich größerer Stack als bei 1.x: Rechnen Sie mit 4 GB RAM als Untergrenze. Der wichtigste Schritt vor dem Start ist das sichere Generieren und dauerhafte Speichern von `_APP_OPENSSL_KEY_V1`, dieser Schlüssel ist die Achillesferse des gesamten Stacks. Updates laufen immer über `upgrade` und `migrate`, nie über einen einfachen Image-Tausch; wer von 1.9 kommt, geht den Umweg über 1.9.6. Wer neben einem vollständigen BaaS auch ein schlankes Einzel-Backend für kleine Projekte sucht, sollte einen Blick auf [PocketBase mit Docker](https://s-edv.com/anleitungen/pocketbase-docker-backend-framework) werfen.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren, die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
3. [PocketBase mit Docker: schlankes Go-Backend als Alternative](https://s-edv.com/anleitungen/pocketbase-docker-backend-framework)
4. [Docker Compose absichern: Secrets, Healthchecks und Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)

Offizielle Quellen: [Appwrite Self-Hosting Installation](https://appwrite.io/docs/advanced/self-hosting/installation), [Appwrite Environment Variables](https://appwrite.io/docs/advanced/self-hosting/configuration/environment-variables), [Appwrite Updates und Migrationen](https://appwrite.io/docs/advanced/self-hosting/production/updates), [Appwrite Backups](https://appwrite.io/docs/advanced/self-hosting/production/backups), [Appwrite 2.0.0 Release Notes](https://github.com/appwrite/appwrite/releases/tag/2.0.0), [Appwrite 2.6.0 Release Notes](https://github.com/appwrite/appwrite/releases/tag/2.6.0), [Appwrite 2.6.1 Release Notes](https://github.com/appwrite/appwrite/releases/tag/2.6.1).
