upstream-twenty/packages/twenty-docs/l/de/developers/self-host/capabilities/docker-compose.mdx

---
title: Docker Compose
icon: docker
---

<Warning>
Docker-Container sind für produktives Hosting oder Selbsthosting vorgesehen. Zum Mitwirken siehe [Lokale Einrichtung](/l/de/developers/contribute/capabilities/local-setup).
</Warning>

## Überblick

Diese Anleitung enthält Schritt-für-Schritt-Anweisungen, um die Twenty-Anwendung mit Docker Compose zu installieren und zu konfigurieren. Das Ziel ist, den Prozess übersichtlich zu gestalten und häufige Fallstricke zu vermeiden, die Ihre Einrichtung unterbrechen könnten.

**Wichtig:** Ändern Sie nur die in dieser Anleitung explizit erwähnten Einstellungen. Andere Konfigurationen zu ändern, kann zu Problemen führen.

Siehe die Dokumentation [Umgebungsvariablen einrichten](/l/de/developers/self-host/capabilities/setup) zur erweiterten Konfiguration. Alle Umgebungsvariablen müssen in der Datei `docker-compose.yml` auf Server- und/oder Worker-Ebene deklariert werden, je nach Variable.

## Systemanforderungen

* RAM: Stellen Sie sicher, dass Ihre Umgebung mindestens 2 GB RAM hat. Unzureichender Speicher kann dazu führen, dass Prozesse abstürzen.
* Docker & Docker Compose: Stellen Sie sicher, dass beide installiert und aktuell sind.

## Option 1: Einzeiliges Skript

Installieren Sie die neueste stabile Version von Twenty mit einem einzigen Befehl:

```bash
bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)
```

Um eine spezifische Version oder Zweig zu installieren:

```bash
VERSION=vx.y.z BRANCH=branch-name bash <(curl -sL https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/scripts/install.sh)
```

* Ersetzen Sie x.y.z mit der gewünschten Versionsnummer.
* Ersetzen Sie branch-name durch den Namen des Zweigs, den Sie installieren möchten.

## Option 2: Manuelle Schritte

Befolgen Sie diese Schritte für eine manuelle Einrichtung.

### Schritt 1: Einrichten der Umgebungsdatei

1. **Erstellen Sie die .env Datei**

   Kopieren Sie die Beispielumgebungsdatei in eine neue .env-Datei in Ihrem Arbeitsverzeichnis:

   ```bash
   curl -o .env https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/.env.example
   ```

2. **Einen Verschlüsselungsschlüssel generieren**

   Führen Sie den folgenden Befehl aus, um eine eindeutige Zufallszeichenfolge zu generieren:

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

   **Wichtig:** Bewahren Sie diesen Wert geheim auf / teilen Sie ihn nicht. Der Verlust von `ENCRYPTION_KEY` bedeutet den Verlust des Zugriffs auf alle in der Datenbank gespeicherten Secrets (OAuth-Tokens, Anwendungsvariablen, TOTP-Secrets usw.).

3. **Aktualisieren Sie die `.env`**

   Ersetzen Sie den Platzhalterwert in Ihrer .env-Datei durch das generierte Token:

   ```ini
   ENCRYPTION_KEY=random_string
   ```

   Weitere Informationen findest du im [Leitfaden zur Schlüsselrotation](/l/de/developers/self-host/capabilities/key-rotation) mit Anweisungen zur Rotation ohne Ausfallzeit.

4. **Setzen Sie das Postgres-Passwort**

   Aktualisieren Sie den Wert `PG_DATABASE_PASSWORD` in der .env-Datei mit einem starken Passwort ohne Sonderzeichen.

   ```ini
   PG_DATABASE_PASSWORD=my_strong_password
   ```

### Schritt 2: Beschaffen Sie die Docker Compose-Datei

Laden Sie die `docker-compose.yml`-Datei in Ihr Arbeitsverzeichnis herunter:

```bash
curl -o docker-compose.yml https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/docker-compose.yml
```

### Schritt 3: Anwendung starten

Starten Sie die Docker-Container:

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

### Schritt 4: Auf die Anwendung zugreifen

Wenn Sie twentyCRM auf Ihrem eigenen Computer hosten, öffnen Sie Ihren Browser und navigieren Sie zu [http://localhost:3000](http://localhost:3000).

Wenn Sie es auf einem Server hosten, prüfen Sie, ob der Server läuft und ob alles in Ordnung ist mit

```bash
curl http://localhost:3000
```

## Konfiguration

### Twenty für externen Zugriff freigeben

Standardmäßig läuft Twenty auf `localhost` an Port `3000`. Die UI bestimmt den API-Endpunkt aus dem eigenen Origin des Browsers, sodass sie von jedem Hostnamen geladen wird, der den Container erreicht – setze dennoch `SERVER_URL` auf deine öffentliche URL: Der Server verwendet sie für generierte Links (E-Mails, OAuth-Callbacks) und um HTTPS für sichere Cookies zu erkennen.

#### Erläuterung von `SERVER_URL`

* **Protokoll:** Verwenden Sie `http` oder `https` je nach Konfiguration.
  * Verwenden Sie `http`, wenn Sie kein SSL eingerichtet haben.
  * Verwenden Sie `https`, wenn Sie SSL konfiguriert haben.
* **Domain/IP:** Dies ist der Domainname oder die IP-Adresse, unter der Ihre Anwendung zugänglich ist.
* **Port:** Geben Sie die Portnummer an, wenn Sie nicht die Standardports verwenden (`80` für `http`, `443` für `https`).

### SSL-Anforderungen

SSL (HTTPS) ist erforderlich, damit bestimmte Browserfunktionen ordnungsgemäß funktionieren. Obwohl diese Funktionen möglicherweise während der lokalen Entwicklung funktionieren (da Browser localhost anders behandeln), ist eine ordnungsgemäße SSL-Einrichtung erforderlich, wenn Twenty auf einer regulären Domain gehostet wird.

Zum Beispiel erfordert die Clipboard-API möglicherweise einen sicheren Kontext - einige Funktionen wie Kopierknöpfe in der gesamten Anwendung funktionieren möglicherweise nicht ohne aktiviertes HTTPS.

Wir empfehlen dringend, Twenty hinter einem Reverse-Proxy mit SSL-Beendigung für optimale Sicherheit und Funktionalität zu konfigurieren.

#### Konfiguration der `SERVER_URL`

1. **Bestimmen Sie Ihre Zugriffs-URL**
   * **Ohne Reverse-Proxy (Direkter Zugriff):**

     Wenn Sie direkt ohne Reverse-Proxy auf die Anwendung zugreifen:

     ```ini
     SERVER_URL=http://your-domain-or-ip:3000
     ```

   * **Mit Reverse-Proxy (Standard-Ports):**

     Wenn Sie einen Reverse-Proxy wie Nginx oder Traefik verwenden und SSL konfiguriert haben:

     ```ini
     SERVER_URL=https://your-domain-or-ip
     ```

   * **Mit Reverse-Proxy (Benutzerdefinierte Ports):**

     Wenn Sie nicht standardisierte Ports verwenden:

     ```ini
     SERVER_URL=https://your-domain-or-ip:custom-port
     ```

2. **Aktualisieren Sie die `.env` Datei**

   Öffnen Sie Ihre `.env`-Datei und aktualisieren Sie die `SERVER_URL`:

   ```ini
   SERVER_URL=http(s)://your-domain-or-ip:your-port
   ```

   **Beispiele:**

   * Direkter Zugriff ohne SSL:
     ```ini
     SERVER_URL=http://123.45.67.89:3000
     ```
   * Zugriff über Domain mit SSL:
     ```ini
     SERVER_URL=https://mytwentyapp.com
     ```

3. **Starten Sie die Anwendung neu**

   Damit die Änderungen wirksam werden, starten Sie die Docker-Container neu:

   ```bash
   docker compose down
   docker compose up -d
   ```

#### Überlegungen

* **Reverse Proxy-Konfiguration:**

  Stellen Sie sicher, dass Ihr Reverse-Proxy Anfragen an den richtigen internen Port weiterleitet (`3000` standardmäßig). Konfigurieren Sie die SSL-Terminierung und alle erforderlichen Header.

* **Firewall-Einstellungen:**

  Öffnen Sie die notwendigen Ports in Ihrer Firewall, um externen Zugriff zu ermöglichen.

* **Konsistenz:**

  Die `SERVER_URL` muss mit der Art und Weise übereinstimmen, wie Nutzer in ihren Browsern auf Ihre Anwendung zugreifen.

#### Persistenz

* **Daten-Volumes:**

  Die Docker-Compose-Konfiguration verwendet Volumes, um Daten für die Datenbank und den Serverspeicher persistent zu speichern.

* **Zustandslose Umgebungen:**

  Wenn Sie in einer zustandslosen Umgebung bereitstellen (z. B. bei bestimmten Cloud-Diensten), konfigurieren Sie externen Speicher, um Daten persistent zu speichern.

## Sicherung und Wiederherstellung

Regelmäßige Sicherungen schützen Ihre CRM-Daten vor Verlust.

### Datenbanksicherung erstellen

```bash
docker exec twenty-postgres pg_dump -U postgres twenty > backup_$(date +%Y%m%d).sql
```

### Tägliche Sicherungen automatisieren

Zu Ihrer Crontab hinzufügen (`crontab -e`):

```bash
0 2 * * * docker exec twenty-postgres pg_dump -U postgres twenty > /backups/twenty_$(date +\%Y\%m\%d).sql
```

### Aus Sicherung wiederherstellen

1. Anwendung stoppen:

```bash
docker compose stop server worker
```

2. Datenbank wiederherstellen:

```bash
docker exec -i twenty-postgres psql -U postgres twenty < backup_20240115.sql
```

3. Dienste neu starten:

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

### Best Practices für Sicherungen

* **Wiederherstellungen regelmäßig testen** — überprüfen Sie, dass die Sicherungen tatsächlich funktionieren
* **Sicherungen extern aufbewahren** — Cloud-Speicher verwenden (S3, GCS usw.)
* **Sensible Daten verschlüsseln** — Sicherungen mit Verschlüsselung schützen
* **Mehrere Kopien aufbewahren** — tägliche, wöchentliche und monatliche Sicherungen vorhalten

## Fehlerbehebung

Sollten Sie auf ein Problem stoßen, schauen Sie sich die [Fehlerbehebung](/l/de/developers/self-host/capabilities/troubleshooting) für Lösungen an.

## Managed Hosting

<Tip>
  Möchten Sie Twenty lieber nicht selbst betreiben und warten? [Finden Sie einen zertifizierten Twenty-Hosting-Partner](https://twenty.com/partners/list?categories=HOSTING\&ref=docs-docker-compose), der Ihre Instanz Ende-zu-Ende bereitstellt, hostet und verwaltet. *(Oder wenden Sie sich an unser Team: [contact@twenty.com](mailto:contact@twenty.com).)*
</Tip>