Immich ist eine quelloffene, selbstgehostete Foto- und Video-Verwaltung, die du auf deinem eigenen Server betreibst – die ernstzunehmende Google-Photos-Alternative ohne fremde Cloud. Die Mobile-App sichert deine Aufnahmen automatisch im Hintergrund, die Web-Oberfläche zeigt deine Mediathek in einer flüssigen Zeitleiste, und im Hintergrund laufen KI-Funktionen wie Gesichtserkennung und eine semantische CLIP-Smartsuche, mit der du nach Bildinhalten suchst statt nach Dateinamen. Diese Anleitung zeigt dir Schritt für Schritt, wie du Immich mit Docker per Docker Compose auf einem Linux-Server aufsetzt, die App fürs automatische Backup verbindest, optional GPU-Beschleunigung aktivierst und den Stack sauber aktualisierst und sicherst. Gedacht ist das für Admins im Mittelstand und für ambitionierte Heimserver-Nutzer, die ihre Fotos zurück unter eigene Kontrolle holen wollen.

Voraussetzungen

Immich ist deutlich anspruchsvoller als ein simpler Web-Dienst, weil Datenbank und KI-Modelle mitlaufen. Plane folgende Hardware und Software ein:

Linux-Server (64-bit) mit Debian 12 oder Ubuntu 24.04, Architektur amd64 oder arm64.
Docker und Docker Compose (Plugin docker compose, nicht das alte docker-compose).
CPU: mindestens 2 Kerne, empfohlen 4. Seit Version 2.6 braucht die Machine-Learning-Komponente auf amd64 eine CPU mit mindestens x86-64-v2-Befehlssatz.
RAM: mindestens 6 GB, empfohlen 8 GB. Mit nur 4 GB läuft Immich lediglich ohne Machine Learning stabil – Gesichtserkennung und CLIP-Suche solltest du dann deaktivieren.
Speicher: Die Datenbank (DB_DATA_LOCATION) muss zwingend auf einem lokalen Unix-Dateisystem (EXT4, ZFS, APFS) auf SSD liegen. Netzwerk-Shares (NFS, SMB/CIFS), NTFS, exFAT oder WSL-Mounts führen zu Datenbank-Korruption. Die Fotos selbst (UPLOAD_LOCATION) dürfen großzügiger dimensioniert sein.
Optional GPU: Eine NVIDIA-, Intel- oder AMD-GPU beschleunigt die KI-Modelle und das Video-Transcoding spürbar (siehe Schritt 7).
Optional: eine Domain und ein Reverse-Proxy für HTTPS-Zugriff von außen.

Wie du Docker und Docker Compose grundsätzlich aufsetzt und einen Stack strukturierst, findest du in unserer Anleitung zu den Docker-Compose-Grundlagen und Stacks.

Schritt 1: Projektverzeichnis anlegen

Lege zuerst ein eigenes Verzeichnis für den Stack an. Hier landen die Compose-Datei, die .env sowie die persistenten Datenverzeichnisse für Fotos und Datenbank.

mkdir -p ~/immich
cd ~/immich

In diesem Verzeichnis werden Docker Compose später die Unterordner library (deine Fotos und Videos) und postgres (die Datenbank) automatisch anlegen, sobald der Stack startet.

Schritt 2: Offizielle Compose-Vorlage und .env laden

Immich pflegt eine offizielle, getestete Compose-Vorlage und eine passende Umgebungsdatei. Lade beide direkt aus dem letzten Release herunter, statt sie von Hand abzutippen:

# Offizielle Compose-Vorlage
wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml

# Passende .env-Vorlage
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env

Die folgende docker-compose.yml zeigt den kompletten, lauffähigen Stack so, wie ihn die offizielle Vorlage aufbaut. Du kannst sie copy-paste-fertig verwenden – sie referenziert ausschließlich die Werte aus deiner .env:

name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:${IMMICH_VERSION:-release}
    volumes:
      - ${UPLOAD_LOCATION}:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    ports:
      - "2283:2283"
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false

  immich-machine-learning:
    container_name: immich_machine_learning
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9@sha256:bb186d083732f669da90be8b0f975a37812b15e913465bb14d845db72a4e3e08
    healthcheck:
      test: redis-cli ping || exit 1
    restart: always

  database:
    container_name: immich_postgres
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0@sha256:0fc4dbac3a4ed14d2c0fdd6d18df9831ea6f0b0b9b67e23c19c1c0a3a6f8b8f1
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: '--data-checksums'
    volumes:
      - ${DB_DATA_LOCATION}:/var/lib/postgresql/data
    shm_size: 128mb
    restart: always

volumes:
  model-cache:

Wichtig: Die beiden @sha256:-Digests bei valkey und postgres sind in der echten Vorlage exakt gepinnt. Verändere sie nicht von Hand – nutze immer die heruntergeladene Originaldatei, damit Datenbank und Cache auf den getesteten Image-Stand zeigen.

Schritt 3: .env konfigurieren

Öffne die .env und passe die zentralen Werte an. Das ist der wichtigste Schritt – vor allem das Datenbank-Passwort musst du ändern.

# Speicherort fuer Fotos und Videos (kann auch ein grosses Laufwerk sein)
UPLOAD_LOCATION=./library

# Datenbank-Verzeichnis: MUSS lokale SSD, Unix-FS sein (kein NFS/SMB/NTFS!)
DB_DATA_LOCATION=./postgres

# Zeitzone
TZ=Etc/UTC

# Version: 'release' (latest) oder ein Major-Tag wie 'v2'
IMMICH_VERSION=release

# Datenbank-Zugangsdaten - DB_PASSWORD UNBEDINGT aendern!
DB_PASSWORD=DEIN-SICHERES-PASSWORT
DB_USERNAME=postgres
DB_DATABASE_NAME=immich

Ein paar Erläuterungen zu den Werten:

DB_PASSWORD steht in der Vorlage auf postgres. Ersetze das unbedingt durch ein eigenes, sicheres Passwort – sonst ist deine Datenbank trivial angreifbar.
UPLOAD_LOCATION ist der Ort deiner eigentlichen Fotos. Hier darf es auch ein großes Daten-Laufwerk sein.
DB_DATA_LOCATION gehört zwingend auf lokale SSD mit Unix-Rechten. Diese Regel ist kein Komfort-Tipp, sondern verhindert Datenbank-Korruption.
IMMICH_VERSION: release zieht immer die neueste stabile Version. Wer mehr Kontrolle will, pinnt einen Major-Tag wie v2, um nicht versehentlich über eine Major-Grenze zu springen.
TZ setzt du auf deine Zeitzone, etwa Europe/Berlin, damit Zeitstempel stimmen.

Schritt 4: Immich starten

Jetzt ziehst du die Images und startest den kompletten Stack im Hintergrund:

cd ~/immich
docker compose up -d

# Status der vier Container pruefen
docker compose ps

# Logs verfolgen (zum Debuggen beim ersten Start)
docker compose logs -f immich-server

Beim ersten Start lädt Immich die Images für Server, Machine Learning, Valkey (Cache) und die VectorChord-Postgres-Datenbank. Das dauert je nach Verbindung einige Minuten. Die Healthchecks sorgen dafür, dass der Server erst dann als bereit gilt, wenn Datenbank und Cache laufen. Anschließend rufst du die Oberfläche im Browser auf:

http://SERVER-IP:2283

Ersetze SERVER-IP durch die Adresse deines Servers. Läuft alles auf demselben Rechner, funktioniert auch http://localhost:2283.

Schritt 5: Ersteinrichtung und Admin-Konto anlegen

Immich hat keinen voreingestellten Login. Der erste Benutzer, der sich registriert, wird automatisch zum Administrator. So gehst du vor:

Im Browser unter http://SERVER-IP:2283 erscheint der Getting Started-Dialog.
Lege das Admin-Konto mit E-Mail, Namen und einem starken Passwort an. Dieses Konto hat volle Rechte.
Im Admin-Bereich legst du anschließend bei Bedarf weitere Benutzer für Familie oder Team an.
Prüfe in den Admin-Einstellungen die Jobs für Machine Learning – Gesichtserkennung und Smartsuche laufen als Hintergrund-Jobs über deine Mediathek.

Damit ist die Server-Seite fertig. Jetzt verbinden wir das Smartphone.

Schritt 6: Mobile-App und automatisches Foto-Backup

Das Herzstück als Google-Photos-Alternative ist das automatische Backup vom Handy. Die Immich-App gibt es für Android und iOS sowie über F-Droid.

Installiere die Immich-App aus dem App Store, Play Store oder von F-Droid.
Beim ersten Start gibst du die Server-URL inklusive Port ein: http://SERVER-IP:2283 (von außen später deine HTTPS-Domain, siehe Schritt 8).
Melde dich mit deinem in Schritt 5 angelegten Konto an.
Aktiviere das automatische Backup und wähle die Alben aus, die gesichert werden sollen (z.B. die Kamerarolle).

Ab jetzt lädt die App neue Aufnahmen automatisch im Hintergrund auf deinen Server. Auf dem Server arbeiten die KI-Jobs die neuen Bilder ab: Die Gesichtserkennung gruppiert Personen, und die CLIP-Smartsuche macht Bildinhalte durchsuchbar – du kannst dann zum Beispiel nach Strand, Hund oder Geburtstagskuchen suchen, ohne dass ein einziges Foto je beschriftet wurde.

Schritt 7: Optional – GPU für KI und Transcoding

Auf reiner CPU funktionieren Gesichtserkennung, Smartsuche und Video-Transcoding, sind bei großen Mediatheken aber langsam. Mit einer GPU beschleunigst du beides deutlich. Immich liefert dafür zwei zusätzliche, einkommentierbare Vorlagen.

Hardware-beschleunigtes Machine Learning

Lade die ML-Beschleunigungsvorlage und wähle deine Plattform. Unterstützt werden CUDA (NVIDIA, Compute Capability >= 5.2), OpenVINO (Intel), ROCm (AMD), ARM NN (Mali) und RKNN (Rockchip):

wget -O hwaccel.ml.yml https://github.com/immich-app/immich/releases/latest/download/hwaccel.ml.yml

Für eine NVIDIA-GPU brauchst du auf dem Host das NVIDIA Container Toolkit. Anschließend ergänzt du in der docker-compose.yml beim Dienst immich-machine-learning den extends-Block und setzt das Image-Tag um -cuda:

  immich-machine-learning:
    container_name: immich_machine_learning
    # Image-Tag um -cuda ergaenzen:
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-cuda
    extends:
      file: hwaccel.ml.yml
      service: cuda
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: always

Hardware-beschleunigtes Transcoding

Für das Video-Transcoding gibt es eine separate Vorlage mit NVENC (NVIDIA), QSV (Intel Quick Sync), VAAPI und RKMPP (Rockchip):

wget -O hwaccel.transcoding.yml https://github.com/immich-app/immich/releases/latest/download/hwaccel.transcoding.yml

Beim Dienst immich-server kommentierst du dann den passenden extends-Block ein und ersetzt cpu durch nvenc, qsv, vaapi oder rkmpp. In der Web-Oberfläche schaltest du das gewählte Verfahren zusätzlich unter den Transcoding-Einstellungen scharf. Nach jeder Änderung ziehst du den Stack neu hoch:

docker compose up -d

Schritt 8: Reverse-Proxy und HTTPS

Der Port 2283 ist nur fürs lokale Netz gedacht und sollte nie ungeschützt ins Internet zeigen. Für den Zugriff von außen setzt du Immich hinter einen Reverse-Proxy, der TLS terminiert. Hier ein schlankes Nginx-Beispiel:

server {
    listen 443 ssl;
    server_name fotos.DEINE-DOMAIN.de;

    ssl_certificate     /etc/letsencrypt/live/fotos.DEINE-DOMAIN.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/fotos.DEINE-DOMAIN.de/privkey.pem;

    # Grosszuegig fuer Video- und Foto-Uploads
    client_max_body_size 50000M;

    location / {
        proxy_pass http://127.0.0.1:2283;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Achte auf ein großzügiges client_max_body_size – sonst blocken große Videos. Die Header Upgrade und Connection sind nötig, weil Immich WebSockets für Live-Updates nutzt. In der Mobile-App trägst du danach die HTTPS-Domain statt der internen IP ein.

Schritt 9: Update-Workflow und Backup

Update

Updates sind ein Zweizeiler – aber bei Immich gilt: kein blindes Auto-Update. Lies vor jedem Pull die Release-Notes und das Breaking-Changes-Board, weil Immich noch in aktiver Entwicklung ist.

cd ~/immich

# 1. Backup machen (siehe unten), DANN:
docker compose pull
docker compose up -d

# Alte, ungenutzte Images aufraeumen
docker image prune

Downgrades werden nicht unterstützt – auch nicht innerhalb eines Minor-Tags. Deshalb gilt: erst Backup, dann Update. Wer von einer sehr alten Version kommt, beachtet zusätzlich die VectorChord-Migration (siehe Troubleshooting).

Backup

Ein vollständiges Backup besteht aus zwei Teilen: dem Datenbank-Dump und den Originaldateien. Den Datenbank-Dump erzeugst du direkt aus dem Postgres-Container:

# 1. Datenbank-Dump (komprimiert)
docker exec -t immich_postgres pg_dumpall --clean --if-exists --username=postgres | gzip > immich-db-backup.sql.gz

# 2. Zusaetzlich das UPLOAD_LOCATION (deine Fotos) sichern, z.B.:
tar czf immich-library-$(date +%F).tar.gz ./library

Lege beide Backups nach dem 3-2-1-Prinzip an einen sicheren Ort außerhalb des Servers (zweite Maschine, NAS, Offsite). Teste deine Backups regelmäßig durch eine Probe-Wiederherstellung – ein ungetestetes Backup ist nur eine Hoffnung.

Troubleshooting

Datenbank startet nicht oder korrumpiert: Fast immer liegt DB_DATA_LOCATION auf einem ungeeigneten Dateisystem. Es muss lokales Unix-FS (EXT4/ZFS) auf SSD sein – niemals NFS/SMB/CIFS, NTFS/exFAT oder ein WSL-Mount.
Machine Learning läuft nicht stabil: Mit nur 4 GB RAM reicht der Speicher für Gesichtserkennung und CLIP nicht. Entweder RAM erhöhen (mindestens 6, besser 8 GB) oder ML in den Admin-Einstellungen deaktivieren. Auf amd64 braucht ML seit v2.6 außerdem eine x86-64-v2-CPU.
Postgres-Fehler bei größeren Operationen: Entferne niemals shm_size: 128mb beim database-Dienst – ohne diesen Shared-Memory-Wert scheitern größere Datenbank-Operationen.
VectorChord-Migration nach langer Pause: Früher kam pgvecto.rs zum Einsatz, seit etwa v1.133 ist VectorChord Pflicht. Das direkte Upgrade geht nur ab v1.107.2; nach dem Wechsel darfst du nicht mehr unter die Migrationsversion downgraden.
Live-Updates / Upload aus dem Browser hängen: Hinter dem Reverse-Proxy fehlen die WebSocket-Header (Upgrade, Connection) oder client_max_body_size ist zu klein.
Container-Logs lesen: Mit docker compose logs -f immich-server bzw. ... immich_postgres siehst du, was beim Start passiert – das ist der erste Anlaufpunkt.

Häufige Fragen

Ist Immich eine vollwertige Google-Photos-Alternative?

Für den Kern – automatisches Mobil-Backup, Zeitleiste, Alben, Gesichtserkennung und KI-Suche – ja. Immich ist seit 2025 bei Version 2.x und produktiv nutzbar. Es wird aber weiter aktiv entwickelt, deshalb sind getestete Backups und das Lesen der Release-Notes vor Updates Pflicht.

Brauche ich zwingend eine GPU?

Nein. Gesichtserkennung, CLIP-Suche und Transcoding laufen auch rein auf der CPU. Eine GPU (NVIDIA/Intel/AMD) beschleunigt das nur – bei großen Mediatheken lohnt sie sich, ist aber kein Muss. Für CUDA brauchst du auf dem Host das NVIDIA Container Toolkit.

Wo speichert Immich meine Fotos?

Die Originaldateien liegen im Verzeichnis aus UPLOAD_LOCATION (Standard ./library), die Metadaten in der Postgres-Datenbank unter DB_DATA_LOCATION. Beides musst du sichern – der Datenbank-Dump allein reicht nicht, die Bilder gehören separat ins Backup.

Warum Valkey und VectorChord statt Redis und pgvecto.rs?

Immich nutzt inzwischen Valkey als Cache (Redis-kompatibler Nachfolger) und die VectorChord-Extension für die Vektorsuche (Nachfolger von pgvecto.rs). Du musst dich darum nicht kümmern – die offizielle Compose-Vorlage bringt die korrekt gepinnten Images mit.

Wie viele Benutzer kann ich anlegen?

Beliebig viele. Der erste registrierte Benutzer wird Admin und legt im Admin-Bereich weitere Konten für Familie oder Team an – jeder mit eigener Mediathek und eigenem App-Backup.

Kann ich die Version festpinnen?

Ja. Setze IMMICH_VERSION in der .env auf einen Major-Tag wie v2 statt auf release. Das verhindert, dass ein Pull versehentlich über eine Major-Grenze springt. Vor jedem Update gilt trotzdem: Release-Notes lesen, Backup machen.

Fazit

Mit Docker Compose hast du in rund einer halben Stunde eine vollwertige, private Foto-Cloud im eigenen Netz: offizielle Vorlage und .env laden, DB_PASSWORD ändern, docker compose up -d – fertig. Die Mobile-App übernimmt das automatische Backup, Gesichtserkennung und CLIP-Smartsuche machen die Mediathek so komfortabel wie bei Google Photos, nur ohne fremde Cloud. Wichtig bleibt die Disziplin bei Updates (Release-Notes lesen, vorher Backup) und beim Speicher (Datenbank zwingend auf lokale SSD). Wer den Dienst von außen nutzt, stellt einen Reverse-Proxy mit HTTPS davor. Damit holst du deine Fotos zurück unter eigene Kontrolle – datensouverän und ohne monatliche Gebühren.

Weiterführende Anleitungen und Quellen

Passende Anleitungen aus unserem Wissensbereich:

Docker Compose: Grundlagen und Stacks aufbauen – ideal, falls du den Umgang mit compose.yaml und .env vertiefen willst.
Nextcloud AIO als self-hosted Cloud mit Docker einrichten – die passende Datei- und Dokumentenablage zu deiner Foto-Cloud.
Paperless-ngx: Dokumentenverwaltung mit OCR per Docker – ein weiterer datenschutzfreundlicher Self-Hosting-Dienst fürs Büro.
Weitere Anleitungen der Kategorie Cloud

Offizielle Quellen: