---
title: "Twenty CRM mit Docker installieren: Modernes Open-Source-CRM als Salesforce-Alternative"
date: 2026-08-20T09:34:13+02:00
modified: 2026-11-08T22:05:02+01:00
category: branche
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/twenty-crm-docker-crm
reading_time: 11
personalize_url: "https://s-edv.com/anleitungen/twenty-crm-docker-crm#ihr_benutzer={ihr_benutzer}"
variables:
  - name: encryption_key
    label: "Schlüssel (encryption key)"
    generated_in_browser: true
  - name: pg_database_password
    label: "Passwort (pg database password)"
    generated_in_browser: true
  - name: ihr_benutzer
    label: "Ihr benutzer"
    default: "IHR_BENUTZER"
---

# Twenty CRM mit Docker installieren: Modernes Open-Source-CRM als Salesforce-Alternative

## 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 |
| --- | --- | --- |
| `{{encryption_key}}` | Schlüssel (encryption key) | wird im Browser des Lesers zufällig erzeugt |
| `{{pg_database_password}}` | Passwort (pg database password) | wird im Browser des Lesers zufällig erzeugt |
| `{{ihr_benutzer}}` | Ihr benutzer | `IHR_BENUTZER` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/twenty-crm-docker-crm#ihr_benutzer=IHR_BENUTZER

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. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*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.

Bei Salesforce oder HubSpot liegen die Kundendaten in fremden Rechenzentren und die Kosten steigen mit jedem Nutzer. **Twenty CRM** ist eine Open-Source-Alternative mit Kontakt- und Deal-Verwaltung, anpassbaren Objekten, Workflows und GraphQL-API. Technisch setzt Twenty auf NestJS, React, PostgreSQL und Redis. Diese Anleitung zeigt die Installation von Twenty CRM v2.51.0 per Docker Compose auf einem Linux-Host samt Backup.

**Kurzfassung:** Sie legen einen Projektordner an, erzeugen per OpenSSL einen Verschlüsselungsschlüssel und tragen ihn mit dem Datenbankpasswort in eine `.env` ein. Die `compose.yaml` definiert vier Services: Twenty-Server (inklusive Frontend), Worker, PostgreSQL 16 und Redis. Nach `docker compose up -d` ist die Weboberfläche auf Port 3000 erreichbar. Den `ENCRYPTION_KEY` dürfen Sie nicht verlieren und nur über die offizielle Schlüsselrotation wechseln, sonst sind verschlüsselte Secrets unlesbar. Produktiv gehören ein Reverse Proxy mit HTTPS und ein regelmäßiges `pg_dump` dazu.

## Voraussetzungen

- [ ] **Docker Engine** (Version >= 20.10) und **Docker Compose Plugin v2**, Installation siehe [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian)](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Linux-Host, VM oder NAS mit Docker
- [ ] **Mindestens 2 GB RAM** laut Herstellerdoku, empfohlen 4 GB: Im Test belegten Server und Worker nach dem Start zusammen rund 2 GB, die Datenbank weitere 50 bis 80 MB. x86_64 oder ARM64
- [ ] Mindestens 10 GB freier Festplattenspeicher (Images, Datenbankdaten, Uploads)
- [ ] `openssl` zur Schlüsselerzeugung
- [ ] Internetzugang für den Image-Pull
- [ ] Optional: eigene Domain mit DNS-Eintrag und Reverse Proxy (nginx, Traefik oder Caddy) für HTTPS (siehe Schritt 6)

## Schritt 1: Projektordner anlegen

Unter `/opt` brauchen Sie `sudo` und übergeben den Ordner danach Ihrem Benutzer:

```bash
$ sudo mkdir -p /opt/twenty-crm
$ sudo chown "$USER": /opt/twenty-crm
$ cd /opt/twenty-crm
```

Ohne Root-Zugriff nutzen Sie `~/twenty-crm`. Verwenden Sie den gewählten Pfad durchgehend.

> **Prüfen:** Der Ordner existiert und ist das aktuelle Arbeitsverzeichnis.
>
> ```bash
> $ pwd
> ```
>
> ```bash
> # Erwartete Ausgabe: /opt/twenty-crm
> ```

## Schritt 2: .env-Datei mit Secrets anlegen

Der `ENCRYPTION_KEY` ist der wichtigste Wert des Stacks. Er verschlüsselt die Secrets in der Datenbank: OAuth-Tokens, TOTP-Secrets und App-Variablen. Geht er verloren, sind diese Daten laut Herstellerdoku nicht mehr lesbar. Bewahren Sie ihn zusätzlich im Passwortmanager auf.

Erzeugen Sie zwei Zufallswerte:

```bash
# Verschlüsselungsschlüssel (Pflicht, sicher aufbewahren)
```

```bash
$ openssl rand -base64 32
```

```bash
# Datenbankpasswort (nur Buchstaben und Ziffern, keine Sonderzeichen)
```

```bash
$ openssl rand -hex 16
```

Legen Sie anschließend die `.env` an:

Datei: `.env`

```ini
# Twenty CRM, Umgebungsvariablen
# ACHTUNG: ENCRYPTION_KEY nicht verlieren, Wechsel nur per Schlüsselrotation

TAG=v2.51.0

ENCRYPTION_KEY={{encryption_key}}

PG_DATABASE_USER=twenty
PG_DATABASE_PASSWORD={{pg_database_password}}

# Für lokalen Betrieb:
SERVER_URL=http://localhost:3000

# Für externen Betrieb (Domain anpassen):
# SERVER_URL=https://crm.meinedomain.de

STORAGE_TYPE=local
```

Ersetzen Sie beide Platzhalter durch die erzeugten Werte und beschränken Sie die Rechte:

```bash
$ chmod 600 /opt/twenty-crm/.env
```

> **Prüfen:** Die Datei enthält keine Platzhalter mehr und ist nur für den Eigentümer lesbar.
>
> ```bash
> $ ls -la .env
> ```
>
> ```bash
> # Erwartete Ausgabe: -rw------- 1 {{ihr_benutzer}} ... .env
> ```
>
> ```bash
> $ grep -c "IHR_" .env
> ```
>
> ```bash
> # Erwartete Ausgabe: 0 (keine Platzhalter mehr)
> ```

## Schritt 3: compose.yaml erstellen

Der Stack besteht aus vier Services. Das offizielle Image `twentycrm/twenty` enthält Server und Frontend. Das ältere `twentycrm/twenty-server` ist archiviert (letztes Update März 2024).

Der Worker nutzt dasselbe Image mit `yarn worker:prod` und deaktiviert Migrationen und Cron-Registrierung, damit nichts doppelt läuft. Er bindet dasselbe Volume `server-local-data` ein, damit Hintergrundjobs auf hochgeladene Dateien zugreifen können. Redis startet mit `--maxmemory-policy noeviction`, damit die Job-Queue bei Speicherdruck keine Keys verliert.

```yaml
services:
  server:
    image: twentycrm/twenty:${TAG:-latest}
    ports:
      - "3000:3000"
    volumes:
      - server-local-data:/app/packages/twenty-server/.local-storage
    environment:
      NODE_PORT: 3000
      SERVER_URL: ${SERVER_URL:-http://localhost:3000}
      REDIS_URL: redis://redis:6379
      PG_DATABASE_URL: postgres://${PG_DATABASE_USER:-twenty}:${PG_DATABASE_PASSWORD}@db:5432/default
      STORAGE_TYPE: ${STORAGE_TYPE:-local}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/healthz"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s
    restart: always

  worker:
    image: twentycrm/twenty:${TAG:-latest}
    volumes:
      - server-local-data:/app/packages/twenty-server/.local-storage
    command: ["yarn", "worker:prod"]
    environment:
      SERVER_URL: ${SERVER_URL:-http://localhost:3000}
      REDIS_URL: redis://redis:6379
      PG_DATABASE_URL: postgres://${PG_DATABASE_USER:-twenty}:${PG_DATABASE_PASSWORD}@db:5432/default
      STORAGE_TYPE: ${STORAGE_TYPE:-local}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      DISABLE_DB_MIGRATIONS: "true"
      DISABLE_CRON_JOBS_REGISTRATION: "true"
    depends_on:
      db:
        condition: service_healthy
      server:
        condition: service_healthy
    restart: always

  db:
    image: postgres:16
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: default
      POSTGRES_USER: ${PG_DATABASE_USER:-twenty}
      POSTGRES_PASSWORD: ${PG_DATABASE_PASSWORD}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${PG_DATABASE_USER:-twenty} -d default"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: always

  redis:
    image: redis
    command: ["--maxmemory-policy", "noeviction"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: always

volumes:
  db-data:
  server-local-data:
```

PostgreSQL und Redis haben bewusst kein Port-Mapping, nur Port 3000 ist erreichbar.

Wie Healthchecks, Secrets und der Betrieb ohne Root in Compose-Stacks funktionieren, zeigt die Anleitung [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root).

> **Prüfen:** Die YAML-Syntax ist korrekt und docker compose erkennt die Datei.
>
> ```bash
> $ docker compose config --quiet
> ```
>
> ```bash
> # Keine Ausgabe = kein Syntaxfehler
> ```

## Schritt 4: Stack starten

Beim ersten Start lädt Docker die Images, danach führt der Server die Datenbankmigrationen aus. Im Test war der Server rund 100 Sekunden nach dem Start `healthy`, danach startete der Worker.

```bash
$ docker compose up -d
```

Startvorgang in den Logs verfolgen:

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

Steht dort `Nest application successfully started`, ist der Server bereit. Beenden Sie die Log-Ansicht mit Strg+C.

> **Prüfen:** Alle vier Services laufen, Server, Datenbank und Redis mit `healthy`:
>
> ```bash
> $ docker compose ps
> ```
>
> ```bash
> # Erwartete Ausgabe (gekürzt):
> # NAME               IMAGE                    STATUS
> # twenty-crm-server  twentycrm/twenty:v2.51.0 Up (healthy)
> # twenty-crm-worker  twentycrm/twenty:v2.51.0 Up
> # twenty-crm-db      postgres:16              Up (healthy)
> # twenty-crm-redis   redis                    Up (healthy)
> ```
>
> ```bash
> $ curl -I http://localhost:3000/healthz
> ```
>
> ```bash
> # Erwartete Ausgabe: HTTP/1.1 200 OK
> ```

## Schritt 5: Erst-Einrichtung im Browser

Öffnen Sie `http://localhost:3000` (bzw. IP oder Domain Ihres Servers) im Browser. Der Einrichtungsassistent legt das erste Konto an:

1. Konto mit E-Mail-Adresse und starkem Passwort anlegen.
2. Workspace einrichten (Name des Unternehmens oder Teams).
3. Danach öffnet sich die CRM-Oberfläche.
4. Weitere Teammitglieder laden Sie über **Settings → Members** ein. `SERVER_URL` muss dafür auf die erreichbare Adresse zeigen, weil Einladungs-E-Mails diese URL verwenden.

> **Prüfen:** Die Anmeldung funktioniert und die Oberfläche zeigt den leeren Workspace. Auf der Kommandozeile liefert der folgende Aufruf den Seitentitel. Ohne den Accept-Header antwortete v2.43.0 im Test mit 404 `Cannot GET /`, obwohl der Browser die Seite anzeigte.
>
> ```bash
> $ curl -s -H 'Accept: text/html' http://localhost:3000 | grep -o "<title>.*</title>"
> ```
>
> ```bash
> # Erwartete Ausgabe: <title>Twenty</title>
> ```

## Schritt 6: Reverse Proxy und HTTPS einrichten (Produktionsbetrieb)

Für den Zugriff über eine externe Domain ist HTTPS Pflicht. Ohne TLS funktionieren Browser-APIs wie die Clipboard-API nicht, und OAuth-Integrationen schlagen fehl.

Beschränken Sie zuerst in der `compose.yaml` den Port auf localhost:

Datei: `compose.yaml`

```yaml
ports:
  - "127.0.0.1:3000:3000"
```

Setzen Sie `SERVER_URL` in der `.env` auf Ihre HTTPS-Domain:

Datei: `.env`

```ini
SERVER_URL=https://crm.meinedomain.de
```

Schalten Sie dann einen Reverse Proxy davor, siehe [Caddy als Reverse Proxy einrichten: Anfänger-Anleitung mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung). Ohne Portfreigabe eignet sich auch ein [Cloudflare Tunnel](https://s-edv.com/anleitungen/cloudflare-tunnel-synology-docker).

Stack mit der geänderten Konfiguration neu erstellen:

```bash
$ docker compose up -d
```

> **Prüfen:** Die HTTPS-Adresse antwortet mit gültigem Zertifikat.
>
> ```bash
> $ curl -I https://crm.meinedomain.de/healthz
> ```
>
> ```bash
> # Erwartete Ausgabe: HTTP/2 200
> ```

## Schritt 7: Backup und Updates

### Datenbank-Backup

Twenty speichert alle CRM-Daten in PostgreSQL, Uploads im Volume `server-local-data`. Für die Datenbank genügt meist ein täglicher `pg_dump`:

```bash
# Einmaliges Backup
docker exec $(docker compose ps -q db) \
  pg_dump -U twenty default > backup_$(date +%Y%m%d).sql

# Backup prüfen
wc -l backup_$(date +%Y%m%d).sql
# Im Test: rund 8.000 Zeilen schon bei leerer Instanz
```

Ein 3-2-1-Konzept mit Rotation beschreibt [MySQL & PostgreSQL Backup automatisieren mit cron: mysqldump, pg_dump, Rotation und rclone-Cloud-Sync](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud).

### Version-Update

Legen Sie vor jedem Update ein Backup an, tragen Sie den neuen Tag in die `.env` ein und aktualisieren Sie den Stack:

Datei: `.env`

```ini
# 1. Backup anlegen (wie oben)
# 2. Neue Version in .env eintragen:
#    TAG=v2.51.0  (Beispiel)

# 3. Images pullen und Stack neu starten
docker compose pull && docker compose up -d
```

Der Server führt die Migrationen beim Start aus. Laut Upgrade-Guide sind ab v1.23 Sprünge über mehrere Versionen möglich, ab v2.34 ist PostgreSQL 15 Mindestvoraussetzung. Den Stand prüft `docker compose exec server yarn command:prod upgrade:status`, im Test mit v2.43.0 meldete er `Instance: Up to date`. Im Test lief der Sprung von v2.43.0 auf v2.45.0 durch: Der Server registrierte die Upgrade-Befehle für 2.44 und 2.45 (cross-upgrade) und war nach gut einer Minute wieder `healthy`. Auf dem Testhost mit 3 GB RAM lief `upgrade:status` neben Server und Worker nicht durch; planen Sie Speicherreserve ein. Die als Breaking Change markierte Änderung in v2.44 betrifft nur selbst entwickelte Twenty-Apps (Registrierungsvariablen nur noch über das Manifest), nicht den Betrieb per Compose.

**Update von v2.45 auf v2.46:** Ändern Sie in der `.env` nur `TAG=v2.46.0`, an Volumes und Pflichtvariablen ändert sich nichts. Die offizielle Compose-Vorlage reicht in v2.46 zusätzlich `REDIS_CACHE_PREFIX` sowie `STORAGE_S3_ACCESS_KEY_ID` und `STORAGE_S3_SECRET_ACCESS_KEY` an Server und Worker durch. Für den lokalen Speicher dieser Anleitung brauchen Sie keine davon. Wer S3 nutzt, ergänzt die beiden Schlüssel im `environment`-Block beider Dienste. Im Test von v2.45.0 auf v2.46.0 registrierte der Server die Upgrade-Befehle bis 2.46.0, war in unter zwei Minuten wieder `healthy`, `/healthz` antwortete mit `200`, und der Worker lief mit dem neuen Image weiter.

**Update von v2.46 auf v2.49:** Auch hier genügt der neue Tag, die offizielle Compose-Vorlage und die `.env`-Vorlage sind in v2.46.0 und v2.49.0 identisch. Ein Sprung über mehrere Versionen ist möglich. Für den Betrieb wichtig ist ein Breaking Change aus v2.48: Twenty prüft die Zertifikate von IMAP- und SMTP-Servern jetzt standardmäßig. Mailserver mit selbstsigniertem oder abgelaufenem Zertifikat lassen sich danach erst wieder verbinden, wenn das Zertifikat gültig ist. Die übrigen als Breaking Change markierten Punkte in v2.47 und v2.49 betreffen Chat-, Workflow- und KI-Funktionen der Oberfläche. Im Test von v2.46.0 auf v2.49.0 wendete der Server die Upgrade-Befehle bis 2.49.0 an, war nach rund zwei Minuten `healthy`, `upgrade:status` meldete `Instance: Up to date`, das vorher angelegte Konto blieb erhalten, die Anmeldung damit funktionierte, und ein falsches Passwort wurde mit `Wrong password` abgelehnt.

**Update von v2.49 auf v2.50:** Compose- und `.env`-Vorlage sind in v2.49.0 und v2.50.1 identisch, es genügt der neue Tag. Als Breaking Change nennen die Release Notes von v2.50.0, dass die App-Berechtigungen jetzt *Workspace Apps* und *User Apps* heißen und der Server User Apps durchsetzt: Wer installierte Apps nutzt, prüft nach dem Update die Rollenrechte. Außerdem verlangt das Hinzufügen oder erneute Verbinden einer persönlichen App-Verbindung jetzt die Berechtigung `CONNECTED_ACCOUNTS`. Im Test von v2.49.0 auf v2.50.1 wendete der Server die Upgrade-Befehle bis 2.50.0 an (`upgrade:status`: `Instance: Up to date`), Server und Worker liefen mit v2.50.1, der Server war nach rund zwei Minuten `healthy`, das vorher angelegte Konto blieb erhalten, die Anmeldung funktionierte, und ein falsches Passwort wurde mit `Wrong password` abgelehnt.

**Update von v2.50 auf v2.51:** Auch hier genügt der neue Tag. Im Test wendete der Server beim Update von v2.50.1 auf v2.51.0 die Upgrade-Befehle bis 2.51.0 an (`upgrade:status`: `Instance: Up to date`), Server und Worker liefen mit v2.51.0, das Konto blieb erhalten, die Anmeldung funktionierte, ein falsches Passwort wurde abgelehnt, und `pg_dump` lief durch. Laut Release Notes lädt v2.51.0 kleine CSV-Exporte bis 200 Datensätze direkt im Browser herunter, statt dafür einen Hintergrundauftrag anzulegen.

> **Prüfen:** Der neue Tag ist aktiv, alle Services laufen wieder.
>
> ```bash
> $ docker compose ps
> $ docker inspect $(docker compose ps -q server) | grep -i "image"
> ```
>
> ```bash
> # Zeigt den neuen Image-Tag
> ```

## Eckdaten auf einen Blick

| Eigenschaft | Wert |
| --- | --- |
| Aktuelles Image | `twentycrm/twenty:v2.50.1` (Docker Hub, ca. 260 MB komprimiert) |
| Veraltetes Image | `twentycrm/twenty-server`, archiviert, nicht verwenden |
| Externer Port | 3000 (Web-UI + API) |
| Interne Ports | 5432 (PostgreSQL), 6379 (Redis), kein Mapping nach außen |
| Pflicht-Volume 1 | `db-data` → PostgreSQL-Datenbankdateien |
| Pflicht-Volume 2 | `server-local-data` → Uploads/Attachments |
| Pflicht-Env 1 | `ENCRYPTION_KEY`, `openssl rand -base64 32`, nur per Rotation wechseln |
| Pflicht-Env 2 | `PG_DATABASE_PASSWORD`, ohne Sonderzeichen |
| Pflicht-Env 3 | `SERVER_URL`, vollständige URL mit Schema und ggf. Port |
| Mindest-RAM | 2 GB (empfohlen: 4 GB) |

## Troubleshooting / Typische Fehler

**Container stürzt beim Start ab (OOMKilled)**

Zu wenig RAM. Prüfen Sie mit `docker stats` oder `docker compose logs server`. Lösung: mindestens 2 GB, besser 4 GB RAM, notfalls eine Swap-Datei.

**Datenbankverbindung schlägt fehl**

Meist enthalten `PG_DATABASE_PASSWORD` Sonderzeichen wie `@`, `#` oder `/`, die in der Verbindungs-URL falsch ankommen. Verwenden Sie nur Buchstaben und Ziffern, etwa per `openssl rand -hex 16`.

**Worker startet nicht oder hängt in depends_on**

Er wartet auf den Server-Healthcheck, beim ersten Start laufen noch Migrationen. Warten Sie 2 bis 3 Minuten oder erhöhen Sie `start_period` im Server-Healthcheck auf 120s.

**OAuth-Callbacks schlagen fehl oder Einladungslinks sind falsch**

`SERVER_URL` passt nicht zur erreichbaren Adresse. Korrigieren (inklusive `https://`) und Stack neu starten.

**Browserfunktionen wie Zwischenablage fehlen**

Die Seite läuft ohne HTTPS. Reverse Proxy mit TLS vorschalten (Schritt 6).

**Altes Image**

`twentycrm/twenty-server`**verwendet:** Frontend fehlt oder ist veraltet. Wechseln Sie auf `twentycrm/twenty`.

**Daten nach**

`docker compose down`**verloren:** Vermutlich lief `docker compose down -v`, siehe Häufige Fragen.

**ENCRYPTION_KEY verloren**

Die verschlüsselten Secrets (Schritt 2) sind nicht wiederherstellbar. Einen Schlüsselwechsel führen Sie nur über die Schlüsselrotation laut Herstellerdoku durch (alter Schlüssel in `FALLBACK_ENCRYPTION_KEY`).

## Häufige Fragen

### Läuft Twenty CRM auf ARM64 (Apple Silicon, Raspberry Pi)?

Ja. Laut Docker Hub gibt es `twentycrm/twenty:v2.50.1` für amd64 und arm64. Der Test dieser Anleitung lief auf amd64.

### Wie update ich Twenty auf eine neue Version?

Siehe Schritt 7.

### Was passiert, wenn ich docker compose down ausführe?

`docker compose down` ohne Optionen entfernt nur die Container, die Volumes `db-data` und `server-local-data` bleiben. Erst `docker compose down -v` löscht sie mit allen Daten.

### Wie richte ich S3-Speicher statt lokalem Storage ein?

Setzen Sie in der `.env` `STORAGE_TYPE=s3` sowie `STORAGE_S3_REGION`, `STORAGE_S3_NAME`, `STORAGE_S3_ENDPOINT` und die Zugangsdaten. Zu S3-kompatiblen Speichern wie Garage siehe [S3-Speicher selbst hosten nach dem MinIO-Aus: Garage und RustFS im Vergleich](https://s-edv.com/anleitungen/s3-speicher-selbst-hosten-garage-rustfs-minio-alternative).

### Wie setze ich das Admin-Passwort zurück?

Die Login-Seite bietet „Passwort vergessen“ per E-Mail, das setzt einen konfigurierten Mailversand voraus. Ohne Mailserver bleibt der Weg über die Datenbank: `docker compose exec db psql -U twenty -d default`, die Konten liegen in der Tabelle `core."user"` (Spalte `"passwordHash"`, bcrypt). Legen Sie vor einem Eingriff ein Backup an.

### Wie integriere ich Google-Kalender und Gmail?

Setzen Sie `MESSAGING_PROVIDER_GMAIL_ENABLED=true` und `CALENDAR_PROVIDER_GOOGLE_ENABLED=true` und hinterlegen Sie Client-ID und Client-Secret einer Google-OAuth-App aus der Google Cloud Console. Aktivieren Sie die im offiziellen Beispiel auskommentierten Variablen in der `compose.yaml` bei Server und Worker. `SERVER_URL` muss auf eine öffentlich erreichbare HTTPS-Adresse zeigen.

## Fazit

Entscheidend für die Installation sind korrekte Werte für `ENCRYPTION_KEY`, `PG_DATABASE_PASSWORD` und `SERVER_URL`. Sichern Sie den Encryption Key extern, schalten Sie für den Produktivbetrieb einen Reverse Proxy mit HTTPS davor und automatisieren Sie das Datenbank-Backup.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Caddy als Reverse Proxy einrichten: Anfänger-Anleitung mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung)
3. [MySQL & PostgreSQL Backup automatisieren mit cron: pg_dump, Rotation und rclone-Cloud-Sync](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
4. [Plane mit Docker installieren: Self-Hosted-Projektmanagement](https://s-edv.com/anleitungen/plane-docker-projektmanagement)
5. [S3-Speicher selbst hosten nach dem MinIO-Aus: Garage und RustFS im Vergleich](https://s-edv.com/anleitungen/s3-speicher-selbst-hosten-garage-rustfs-minio-alternative)

**Offizielle Quellen:** [Twenty CRM: Docker-Compose-Dokumentation](https://docs.twenty.com/developers/self-host/capabilities/docker-compose) · [Upgrade-Guide](https://docs.twenty.com/developers/self-host/capabilities/upgrade-guide) · [GitHub-Repository twentyhq/twenty](https://github.com/twentyhq/twenty) · [Docker Hub: twentycrm/twenty](https://hub.docker.com/r/twentycrm/twenty)
