254 lines
8.3 KiB
Plaintext
254 lines
8.3 KiB
Plaintext
---
|
|
title: 1-Klick mit Docker Compose
|
|
---
|
|
|
|
<Warning>
|
|
Docker-Container sind für die Produktion oder das Selbsthosten bestimmt. Für Beiträge siehe bitte das [Lokale Setup](/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. **Erstellen Sie geheime Tokens**
|
|
|
|
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.
|
|
|
|
3. **Aktualisieren Sie die `.env`**
|
|
|
|
Ersetzen Sie den Platzhalterwert in Ihrer .env-Datei durch das generierte Token:
|
|
|
|
```ini
|
|
APP_SECRET=erster_zufälliger_string
|
|
```
|
|
|
|
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=mein_starkes_passwort
|
|
```
|
|
|
|
### 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`. Um über eine externe Domain oder IP-Adresse darauf zuzugreifen, müssen Sie die `SERVER_URL` in Ihrer `.env`-Datei konfigurieren.
|
|
|
|
#### 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 twenty-server twenty-front
|
|
```
|
|
|
|
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.
|