Kept installieren

Wähle, wie du Kept betreibst, und folge dann den Schritten. Jeder Weg hat eine ausführliche Anleitung in diesem Abschnitt; der Link steht am Ende seiner Schritte.

Docker Compose

Was du brauchst

Docker mit dem Compose-Plugin und ein Terminal. Getestet mit 1 GB RAM und einem CPU-Kern; Kept und seine Datenbank nutzen davon etwa 200–400 MB (was getestet wurde).

Lade compose.yaml herunter, in einen eigenen Ordner: Kept und seine Datenbank in einer Datei, ohne Kopie des Repositorys und ohne Passwörter, die du anlegen musst.
Terminal-Fenster
```
mkdir kept && cd kept
curl -fsSLO https://raw.githubusercontent.com/keptinventory/kept/v1.14.7/compose.yaml
```
Schreibe .env. init fragt nach der Adresse, unter der du Kept öffnen wirst, etwa http://kept.home.arpa:8080. Nimm einen Namen statt einer IP-Adresse: Gedruckte Labels tragen sie.
Terminal-Fenster
```
docker compose run --rm init
```
Du solltest sehen
```
Wrote .env.

KEPT SETUP CODE: XXX-XXX

Next: docker compose up -d, then open http://kept.home.arpa:8080 and enter the setup code.
```
Starte es. Die Datenbank startet, zwei einmalige Dienste legen ihre Logins an und wenden die Migrationen an, dann startet Kept auf Port 8080.
Terminal-Fenster
```
docker compose up -d
```
Du solltest sehen
Unter der Adresse die Seite Einrichtungscode eingeben von Kept.
Richte es ein. Gib den Code ein, den init gezeigt hat, und erstelle das erste Konto: Es wird zum Instanz-Admin.
Behalte die Schlüssel. Gib das Wiederherstellungskit aus und bewahre es woanders als auf diesem Server auf, etwa in einem Passwortmanager. Ein Backup bringt geheime Werte nur mit diesen Schlüsseln zurück.
Terminal-Fenster
```
docker compose exec kept kept admin recovery-kit
```
Du solltest sehen
Text, der mit KEPT RECOVERY KIT beginnt.

Jeder Schritt ausführlich, mit Caddy für HTTPS und Ollama für lokale KI: Installation mit Docker Compose.

Kubernetes

Was du brauchst

Ein Kubernetes-Cluster wie k3s, kubectl und helm, und ein Terminal. Das Chart fordert 384 MiB Speicher für Kept an (höchstens 1 GiB) und 256 MiB für sein gebündeltes Postgres (höchstens 512 MiB).

Erstelle die Secrets. Das Chart schreibt nie ein Secret: Die Datenbank-Logins und der Superuser des gebündelten Postgres bekommen ihre Passwörter aus Secrets, die du vorher anlegst.

kubectl create namespace kept
pw() { openssl rand -hex 32; }
# The four database logins (always).
kubectl -n kept create secret generic kept-db \
  --from-literal=KEPT_DB_OWNER_PASSWORD="$(pw)" --from-literal=KEPT_DB_APP_PASSWORD="$(pw)" \
  --from-literal=KEPT_DB_AUTH_PASSWORD="$(pw)" --from-literal=KEPT_DB_SYSTEM_PASSWORD="$(pw)"
# The bundled Postgres's superuser (or, for external Postgres with roles.create, the server admin's password).
kubectl -n kept create secret generic kept-postgres --from-literal=POSTGRES_PASSWORD="$(pw)"

Installiere das Chart, mit publicUrl auf der Adresse, die die Leute öffnen werden. Füge dieser ersten Installation kein --wait hinzu: Die Migrationen laufen danach.

helm install kept oci://ghcr.io/keptinventory/charts/kept --version 1.14.7 -n kept \
  --set publicUrl=https://kept.example.org \
  --set roles.existingSecret=kept-db --set postgres.superuserSecret=kept-postgres

Du solltest sehen

Die erste Zeile der Hinweise, die Helm ausgibt:

Kept 1.14.7 is installed as "kept" in namespace "kept".

Finde den Einrichtungscode. Kept gibt ihn einmal aus, beim ersten Start.
Terminal-Fenster
```
kubectl -n kept logs deploy/kept | grep 'KEPT SETUP CODE'
```
Du solltest sehen
```
KEPT SETUP CODE: XXX-XXX
```
Öffne die Adresse, gib den Code ein und erstelle das erste Konto: Es wird zum Instanz-Admin.
Behalte die Schlüssel. Speichere das Wiederherstellungskit und bewahre es außerhalb des Clusters auf.
Terminal-Fenster
```
kubectl -n kept exec deploy/kept -- kept admin recovery-kit > kept-recovery-kit.txt
```
Du solltest sehen
kept-recovery-kit.txt, beginnend mit KEPT RECOVERY KIT.
Prüfe es. helm test fragt das laufende Kept nach /readyz und /version.
Terminal-Fenster
```
helm test kept -n kept
```

Unter Windows führe diese Befehle in WSL aus. Die Werte, die optionalen Secrets und was das Chart ausführt: Installation auf Kubernetes mit Helm.

Aus dem Quellcode

Was du brauchst

Git, Docker mit dem Compose-Plugin und ein Terminal. Kept läuft wie mit Docker Compose, mit deinem eigenen Image.

Hol dir den Code.

git clone https://github.com/keptinventory/kept.git && cd kept

Baue das Image, mit dem Tag kept:local.
Terminal-Fenster
```
docker build -t kept:local .
```
Schreibe .env. Richte compose.yaml auf dein Image aus und führe dann init aus. Es findet die .env, fragt, ob es sie aktualisieren soll (antworte Y), und dann nach der Adresse, unter der du Kept öffnen wirst.
Terminal-Fenster
```
echo KEPT_IMAGE=kept:local >> .env
docker compose run --rm init
```
Du solltest sehen
```
Updated .env.

KEPT SETUP CODE: XXX-XXX
```
Starte es und öffne die Adresse.
Terminal-Fenster
```
docker compose up -d
```
Du solltest sehen
Die Seite Einrichtungscode eingeben von Kept. Gib den Code ein, den init gezeigt hat, und erstelle das erste Konto: Es wird zum Instanz-Admin.
Behalte die Schlüssel. Gib das Wiederherstellungskit aus und bewahre es woanders als auf diesem Server auf.
Terminal-Fenster
```
docker compose exec kept kept admin recovery-kit
```
Du solltest sehen
Text, der mit KEPT RECOVERY KIT beginnt.

Unter Windows führe diese Befehle in WSL aus. Dieselbe compose.yaml wie bei einer Release, ausführlich erklärt: Installation mit Docker Compose.

Home Assistant

Was du brauchst

Home Assistant OS mit Supervisor 2026.10.4 oder später: Apps brauchen den Supervisor, also nicht Home Assistant Container oder Core. Ein Gerät mit aarch64 oder amd64, etwa ein Raspberry Pi 4 oder 5 mit 64-Bit oder ein Mini-PC. 4 GB Speicher; mit wenigen anderen Apps reichen 2 GB. Kein Terminal.

Füge das Repository von Kept hinzu. Der Button öffnet dein Home Assistant mit dem ausgefüllten Repository. Oder gehe zu Einstellungen → Apps → App installieren → ⋮ → Repositories und füge https://github.com/keptinventory/kept hinzu.
Kept zu Home Assistant hinzufügen
Installieren, dann Starten. Finde Kept im App Store, dann Installieren, dann Starten.
Du solltest sehen
Im Tab Log der App die eigene Adresse von Kept und der Einrichtungscode:
```
Kept is at http://homeassistant.local:8080 (change it in Configuration: "Kept's address")
```
```
KEPT SETUP CODE: XXX-XXX
```
Web-UI öffnen. Kept öffnet sich in Home Assistant, auch in der Seitenleiste.

Du solltest sehen
Für einen Administrator von Home Assistant Erstes Konto erstellen, ohne Code. Alle anderen sehen Einrichtungscode eingeben und tippen den Code aus dem Tab Log.

Die Adresse von Kept, HTTPS und die Sicherungen: Als Home Assistant App installieren.

Klappt etwas nicht?

Der Container startet immer wieder neu. Lies sein Log: docker compose logs kept. Kept prüft seine Einstellungen vor dem Start und hält mit einer Zeile an, die das erste Problem nennt, etwa kept: invalid environment: KEPT_PUBLIC_URL (führe docker compose run --rm init aus). Bleibt docker compose up -d bei bootstrap stehen, sagt docker compose logs bootstrap warum. Mit weniger als 1 GB Speicher kann einem Backup der Speicher ausgehen, und Docker startet Kept neu (was es braucht). Mehr
Der Port ist belegt. Kept belegt Port 8080 auf dem Host. Führe docker compose run --rm init noch einmal aus, mit einer http://-Adresse auf einem freien Port: Es schreibt die Adresse und den Port (KEPT_HTTP_PORT) in .env. Dann docker compose up -d. In der Home Assistant App änderst du den Port unter Konfiguration → Netzwerk und setzt Adresse von Kept passend. Mehr
Zugriff verweigert. Kept läuft als Benutzer 10001 mit einem schreibgeschützten Dateisystem, also muss ein Ordner, den du einbindest, etwa ein Backup-Verzeichnis, uid 10001 gehören. init schreibt .env in den Ordner, aus dem du es startest: Starte es in einem Ordner, der dir gehört. Mehr
Andere Geräte erreichen es nicht. localhost öffnet sich nur auf diesem Rechner. Nimm einen Namen, den die anderen Geräte finden, eingetragen im DNS deines Routers oder in der Hosts-Datei jedes Geräts, und führe init noch einmal damit aus. Sagt Kept „Dieses Kept ist für Adresse eingerichtet. Öffne es dort.“, öffne es genau unter dieser Adresse oder trage die andere in KEPT_EXTRA_ADDRESSES ein (mehr als eine Adresse). Mehr
Ein 502 vom Reverse-Proxy. Kept spricht einfaches HTTP auf Port 8080: Richte den Proxy auf http://, nicht https://, auf diesem Port aus (hinter einem Reverse-Proxy). Kept startet erst, wenn migrate fertig ist; ist es fehlgeschlagen, sagt docker compose logs migrate warum. Mehr

Alles andere: Fehlerbehebung.

Weiter gehen

HTTPS: Die Kamera, das Installieren der App, Push und der Standort brauchen es. Kept auf HTTPS setzen, oder Kept im Heimnetz für das, was ohne geht.
Der Assistent: Frag in einfachen Worten, mit deinem eigenen KI-Anbieter; Kept funktioniert auch ohne. KI-Anbieter und Einen KI-Client verbinden (MCP).
Sicherungen: nächtlich und verschlüsselt, in ein Verzeichnis, nach S3 oder per SFTP. Sicherungen.
E-Mail: Passwort-Zurücksetzungen, Einladungen und Erinnerungen per E-Mail, mit KEPT_SMTP_URL und KEPT_SMTP_FROM. E-Mail, Push und der Kalender-Feed.
Home Assistant: Die Integration bringt, was fällig ist, in Dashboards und Automationen. Home Assistant.

Updates

Docker Compose: Setze KEPT_IMAGE in .env auf die neue Release, dann:
Terminal-Fenster
```
docker compose pull
docker compose up -d
```
Eine Release, die compose.yaml ändert, sagt das in ihren Hinweisen: Lade ihre Datei über deine.

Aus dem Quellcode:

git pull
docker build -t kept:local .
docker compose up -d

Kubernetes: Jede Release veröffentlicht ein Chart mit derselben Version, und seine Migrationen laufen in einem Job, bevor die neue Version ausliefert.
Home Assistant: Home Assistant bietet das Update an. Aktiviere Sicherung der letzten Version behalten im Update-Dialog.

Ist ein Backup-Ziel gesetzt, macht Kept vor dem Migrieren einen Snapshot. Upgrades und Rollback.