Bereitstellen

Ottoch in Minuten zum Laufen bringen

Docker Compose für beide Editionen — Redis ist im Stack enthalten. Die Community-Edition ist kostenlos, keine Lizenz nötig.

Community-Edition

Docker Compose — kostenlose Stufe

Zwei Dienste: die App und Redis für Ratenbegrenzung. SQLite ist eingebaut — keine externe Datenbank nötig.

Want to try it with sample data first?

Skip writing your own compose file — ottoch-demo bundles the app, Redis, and one of every supported database (PostgreSQL, MySQL, MariaDB, SQL Server, ClickHouse, SQLite), pre-seeded with a shared sample dataset so you can try real queries across engines before connecting anything of your own. 

git clone https://github.com/ottochapp/ottoch-demo
cd ottoch-demo
cp .env.example .env
docker compose up -d

1. Erstelle deine Compose-Datei

services:
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --save "" --appendonly no --maxmemory 128mb --maxmemory-policy allkeys-lru

  app:
    image: registry.ottoch.com/ottoch:latest-ce
    restart: unless-stopped
    depends_on:
      - redis
    ports:
      - "80:80"
      - "443:443"
    env_file: .env
    volumes:
      - ottoch_data:/data

volumes:
  ottoch_data:

2. Erstelle deine .env-Datei

DJANGO_SECRET_KEY=replace-with-a-long-random-string
ENCRYPTION_KEY=replace-with-a-fernet-key
REDIS_URL=redis://redis:6379/0
DJANGO_ALLOWED_HOSTS=localhost,127.0.0.1
ADMIN_URL=admin/

Generiere DJANGO_SECRET_KEY: 

python -c "import secrets; print(secrets.token_urlsafe(50))"

Generiere ENCRYPTION_KEY: 

python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

3. Starte den Stack

docker compose up -d
docker compose logs app

Sieh in den Logs nach deinen automatisch generierten Admin-Zugangsdaten beim ersten Start.

4
Öffne http://localhost und melde dich an

Nutze die Zugangsdaten aus den Logs. Du wirst gebeten, dein Passwort bei der ersten Anmeldung zu ändern.

5
Füge deinen KI-Schlüssel hinzu

Einstellungen → LLM-Konfiguration. Unterstützt OpenAI, Anthropic, Gemini und jeden OpenAI-kompatiblen Endpunkt.

6
Verbinde deine Datenbank & stelle Fragen

Füge eine Verbindung hinzu, aktiviere die gewünschten Tabellen, öffne dann das Dashboard und beginne zu chatten.

Konfiguration

Umgebungsvariablen

Lege diese in deiner .env-Datei neben der Compose-Datei fest.

VariableBeschreibungStandard
DJANGO_SECRET_KEY Django secret key — long random string, never reuse across instances Erforderlich
ENCRYPTION_KEY Fernet key — encrypts stored credentials and AI keys at rest Erforderlich
REDIS_URL Redis connection URL for query rate limiting redis://redis:6379/0
DATABASE_URL Database URL — CE uses SQLite by default, EE typically uses PostgreSQL SQLite
DJANGO_ALLOWED_HOSTS Comma-separated list of allowed host headers — add your domain in production localhost,127.0.0.1
ADMIN_URL Path to the Django admin — change to something non-obvious (must end with /) admin/
OTTOCH_SITE_URL Public URL of your instance https://ottoch.com
OTTOCH_OUTBOUND_IPS Comma-separated server outbound IPs, shown to users for firewall setup leer
LICENSE_KEY_SALT License validation salt — Enterprise Edition only Nur EE
SENTRY_DSN Sentry DSN for error tracking optional
EMAIL_HOST / EMAIL_HOST_USER / EMAIL_HOST_PASSWORD SMTP settings for system emails optional

Enterprise-Edition

Docker Compose mit PostgreSQL

Drei Dienste: Redis, PostgreSQL und die App. Beinhaltet LDAP/Active Directory, Multi-User-RBAC, Erkennung von Folgefragen und lizenzbasierte Aktivierung.

1. Bei der Enterprise-Registry anmelden

Das EE-Image ist nicht öffentlich — du benötigst den Registry-Benutzernamen und das Passwort, die wir dir beim Kauf deiner Lizenz gesendet haben. 

docker login ee-registry.ottoch.com

2. docker-compose.yml

services:
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --save "" --appendonly no --maxmemory 128mb --maxmemory-policy allkeys-lru

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: ottoch
      POSTGRES_USER: ottoch
      POSTGRES_PASSWORD: changeme
    volumes:
      - pgdata:/var/lib/postgresql/data

  app:
    image: ee-registry.ottoch.com/ottoch:latest-ee
    restart: unless-stopped
    depends_on:
      - redis
      - db
    ports:
      - "80:80"
      - "443:443"
    env_file: .env
    volumes:
      - ottoch_data:/data

volumes:
  pgdata:
  ottoch_data:

3. .env

DJANGO_SECRET_KEY=replace-with-a-long-random-string
ENCRYPTION_KEY=replace-with-a-fernet-key
LICENSE_KEY_SALT=replace-with-your-license-salt
DATABASE_URL=postgres://ottoch:changeme@db:5432/ottoch
REDIS_URL=redis://redis:6379/0
DJANGO_ALLOWED_HOSTS=yourdomain.com
ADMIN_URL=your-secret-admin-path/

4. Starte den Stack

docker compose up -d

docker compose pull benötigt auf jeder Maschine, auf der es noch nicht ausgeführt wurde, erneut die Anmeldung aus Schritt 1.

✓ Ersetze changeme sowohl im db-Dienst als auch in DATABASE_URL durch ein echtes Postgres-Passwort.
✓ LICENSE_KEY_SALT muss mit dem im Ottoch-Portal konfigurierten Salt übereinstimmen. Jeder Kunde aktiviert seinen eigenen Lizenzschlüssel.
✓ Ein Enterprise-Lizenzschlüssel ist erforderlich, um den Multi-User-Zugriff freizuschalten. Hier anfragen.

Eigene Domain

HTTPS mit deiner eigenen Domain

Ottoch wird mit Caddy ausgeliefert, das HTTPS automatisch über Let's Encrypt abwickelt.

1
Verweise deine Domain auf den Server

Erstelle einen A-Eintrag, der deinedomain.com auf die IP deines Servers verweist. Eine TTL von 300s ist für die erste Einrichtung in Ordnung.

2
Aktualisiere deine .env und starte neu

Setze DJANGO_ALLOWED_HOSTS=deinedomain.com und OTTOCH_SITE_URL=https://deinedomain.com, führe dann docker compose up -d aus. Caddy erhält beim ersten Aufruf automatisch ein HTTPS-Zertifikat.

✓ Die Ports 80 und 443 müssen in deiner Firewall geöffnet sein, damit Let's Encrypt Zertifikate ausstellen kann.
✓ Caddy erneuert Zertifikate automatisch vor Ablauf — keine manuelle Zertifikatsverwaltung nötig.

Backup & Wiederherstellung

Deine Daten sicher aufbewahren

Community-Edition (SQLite-Volume)

docker run --rm \
  -v ottoch_data:/data \
  -v $(pwd):/backup \
  alpine \
  tar czf /backup/ottoch-backup.tar.gz /data

Erstellt ottoch-backup.tar.gz im aktuellen Verzeichnis. Mit cron oder einem beliebigen Backup-Tool planen.

Enterprise-Edition (PostgreSQL)

docker compose exec db \
  pg_dump -U ottoch ottoch \
  | gzip > ottoch-$(date +%Y%m%d).sql.gz

Standard-pg_dump. Wiederherstellung mit gunzip | psql.

Updates

Auf dem neuesten Stand bleiben

Daten bleiben in benannten Volumes erhalten. Ziehe das neue Image und erstelle den Container neu — das Volume bleibt erhalten.

Community-Edition

docker compose pull
docker compose up -d

Enterprise-Edition

docker compose pull
docker compose up -d
✓ Alle Verbindungen, Sitzungen, LLM-Konfiguration und Benutzereinstellungen werden im Volume gespeichert und überstehen das Update.
✓ Datenbankmigrationen laufen automatisch beim Containerstart. Keine manuellen Schritte nötig.

Fragen? Brauchst du eine Enterprise-Lizenz?

Wir helfen dir gerne bei der Einrichtung.

Lizenz anfragen → Kontaktiere uns