Appwrite mit Docker installieren: Vollständige Open-Source-BaaS-Plattform
Appwrite 2.6 liefert mit dem offiziellen Installer ein komplettes Backend-as-a-Service-Setup: Authentifizierung, Datenbanken, File Storage, Functions, Sites und Messaging, komplett selbst gehostet. Mit Update von 2.5 und Migrationsweg von Appwrite 1.9.
Werbung Mit * markierte Links sind Werbelinks: Bei einem Kauf erhalten wir eine Provision, der Preis bleibt gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

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.
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.
- 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.
opensslfü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.
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=localhostDer 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.
$ ls -A /opt/appwrite-install/appwrite# Erwartete Ausgabe: .env clickhouse-config.xml clickhouse-init.sh docker-compose.yml$ grep -E "^_APP_(VERSION|DB_ADAPTER)=" /opt/appwrite-install/appwrite/.env# 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.
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_DOMAINund_APP_DOMAIN_TARGET: der Hostname, unter dem Console und API erreichbar sind._APP_SYSTEM_EMAIL_ADDRESS,_APP_EMAIL_CERTIFICATESund 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 Dienstesappwrite-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"unddocker compose up -dentfernt Appwrite die Angaben. Vorhandene Dateien bleiben laut Release Notes unverändert.
$ ls -l .env# Erwartete Ausgabe: -rw------- ... .env$ grep -E "^_APP_(OPENSSL_KEY_V1|EXECUTOR_SECRET|DB_PASS|DB_ROOT_PASS|USAGE_PASS)=" .env | grep -cE "your-secret-key|=\"?(password|rootsecretpassword|appwrite)\"?$"# Erwartete Ausgabe: 0Schritt 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.
$ cd /opt/appwrite-install/appwrite
$ docker compose config --quiet && echo "YAML valide"
$ grep -E "^\s+image:" docker-compose.yml | sort | uniq -cSchritt 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.
$ cd /opt/appwrite-install/appwrite
$ docker compose up -d
# Logs verfolgen (Strg+C beendet nur die Anzeige)$ docker compose logs -f appwrite$ docker compose ps --format "{{.Name}}\t{{.Status}}"# 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
$ curl -s http://localhost/v1/health/version# 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.
# HTTP-Antwort der Console prüfen$ curl -s -o /dev/null -w "%{http_code}\n" http://localhost/# Erwartete Ausgabe: 200
# Im Browser: http://localhost zeigt Login bzw. Registrierung der ConsoleSchritt 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:
cd /opt/appwrite-install/appwrite
# .env anpassen:
# _APP_DOMAIN=appwrite.example.com
# _APP_DOMAIN_TARGET=appwrite.example.com
# _APP_EMAIL_CERTIFICATES=admin@example.com
# _APP_OPTIONS_FORCE_HTTPS=enabled
docker compose up -d --force-recreateAppwrite 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.example.com); 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.
Die Abfrage über HTTPS liefert die Version, das Worker-Log zeigt die Zertifikatsausstellung.
$ curl -s https://appwrite.example.com/v1/health/version# Erwartete Ausgabe: {"version":"2.6.1"}
$ docker compose logs appwrite-worker | grep -i certificateSchritt 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.
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 migrateUpdate 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:
- Vollständiges Backup von
.env, Datenbank und Volumes anlegen (siehe unten). Ein Rückweg ist nur über dieses Backup möglich. - Zuerst auf 1.9.6:
upgrademit dem Imageappwrite/appwrite:1.9.6ausführen, danachdocker compose exec appwrite migrate. - Dann auf 2.6.1:
upgrademitappwrite/appwrite:2.6.1, danach erneutmigrate. Die Laufzeit wächst mit der Zahl der Projekte. - 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.
- Hand gepflegte Compose-Dateien: Haben Sie die
compose.yamlaus der früheren Fassung dieser Anleitung von Hand angelegt, erkennt der Installer sie nicht, denn er erwartetappwrite/docker-compose.ymlundappwrite/.env. Erzeugen Sie dann mit dem Installer neue Dateien in einem Ordner namensappwrite, übernehmen Sie_APP_OPENSSL_KEY_V1,_APP_DB_ADAPTER=mongodbsowie Datenbank-Benutzer und -Passwörter aus Ihrer alten.envund gleichen Sie Volume-Namen und Projektnamen mit dem Bestand ab, bevor Sieupgradeundmigrateausführen. Prüfen Sie dabei mitdocker inspect appwrite-mongo, wo die Daten wirklich liegen: Die frühere Fassung band das Volume unter/var/lib/mongodb/dataein, das MongoDB-Image speichert standardmäßig unter/data/db. - Geänderte Variablen:
_APP_CONSOLE_URL_SCHEMEentfällt (stattdessen_APP_CONSOLE_URL), ebenso_APP_LOGGING_PROVIDER,_APP_LOGGING_CONFIG_REALTIMEund_APP_EXECUTIONS_DUAL_WRITE. Fehlerberichte gehen nur noch an Sentry über_APP_LOGGING_CONFIG. Neu sind die MQTT-Ports 8883 und 8084. - Geändertes Verhalten: Dev Keys sind seit 2.3 vollständig entfernt,
migratelö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:
$ cd /opt/appwrite-install/appwrite
$ cp .env /sicherer/ort/appwrite.env.$(date +%Y%m%d)
# PostgreSQL (Standard seit 2.0)$ docker compose exec -T postgresql sh -c 'pg_dumpall -U "$POSTGRES_USER"' > appwrite-$(date +%Y%m%d).sql
# MongoDB-Installation (z. B. von 1.9 übernommen)$ 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
# Uploads-Volume bei gestopptem Stack als Archiv sichern$ 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 startWeitere Volumes wie appwrite-functions, appwrite-sites und appwrite-builds sichern Sie auf dieselbe Weise. Benachrichtigungen über neue Images liefern Diun oder WUD; das Update selbst führen Sie bei Appwrite immer manuell mit upgrade und migrate aus.
$ cd /opt/appwrite-install/appwrite
$ docker compose ps --format "{{.Name}}\t{{.Status}}"
$ curl -s http://localhost/v1/health/version# Erwartete Ausgabe nach dem Upgrade: {"version":"2.6.1"}$ ls -lh appwrite-*.sql# Dump vorhanden und nicht leerTroubleshooting / 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.ymlliegt.- Container
appwritebleibt 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 clickhouseprü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=embeddingzuschalten.- 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_PORTund_APP_MQTT_WSS_PORTin der.envändern, für HTTP und HTTPS_APP_HTTP_PORTund_APP_HTTPS_PORT.- „Executor not reachable“ bei Functions
Der Executor-Container (
exc1) braucht Zugriff auf/var/run/docker.sock. Prüfen mitdocker 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=localhostoder 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 mitdocker volume ls | grep appwriteund 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-Keyfunktionieren 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:
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.1Wer 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 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 werfen.
Weiterführende Anleitungen und Quellen
- Docker und Docker Compose auf Linux installieren, die Self-Hosting-Grundlage
- Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten
- PocketBase mit Docker: schlankes Go-Backend als Alternative
- Docker Compose absichern: Secrets, Healthchecks und Non-Root
Offizielle Quellen: Appwrite Self-Hosting Installation, Appwrite Environment Variables, Appwrite Updates und Migrationen, Appwrite Backups, Appwrite 2.0.0 Release Notes, Appwrite 2.6.0 Release Notes, Appwrite 2.6.1 Release Notes.


