Immich: Selbstgehostete Google-Photos-Alternative mit KI

Veröffentlicht 02.02.2026 Aktualisiert 02.02.2026

Von Darth Vaper

27 Minuten Lesezeit

Über 90.000 GitHub-Stars, mehr als 500 Contributors und eines der am schnellsten wachsenden Self-Hosted-Projekte überhaupt: Immich hat in kürzester Zeit die Herzen der Privacy-Enthusiasten erobert. Während Google Photos seine kostenlosen unbegrenzten Uploads gestrichen hat und die Abo-Preise stetig steigen, suchen immer mehr Menschen nach Alternativen, die ihnen die volle Kontrolle über ihre Erinnerungen zurückgeben. Immich verspricht genau das: Eine vollwertige Google-Photos-Alternative mit KI-gestützter Gesichtserkennung, intelligenter Suche und automatischem Backup - alles auf deiner eigenen Hardware. In diesem ausführlichen Guide zeige ich dir, wie du Immich in deinem Homelab zum Laufen bringst und was die Software wirklich kann.

Was ist Immich?

Immich ist eine Open-Source-Plattform zur Verwaltung von Fotos und Videos, die als vollwertiger Ersatz für Google Photos konzipiert wurde. Das Projekt startete 2022 und hat seitdem eine beeindruckende Entwicklung hingelegt. Der Name ist eine Anspielung auf “I’m Mich” (I’m Michael), den Namen des Hauptentwicklers.

Die Software bietet alle Features, die du von einer modernen Foto-Plattform erwartest: Automatisches Backup von mobilen Geräten, eine übersichtliche Timeline-Ansicht, Alben und Sharing-Funktionen. Der Clou sind jedoch die KI-Features: Immich nutzt moderne Machine-Learning-Modelle für Gesichtserkennung und eine intelligente Suchfunktion, mit der du deine Fotos nach natürlichsprachlichen Begriffen durchsuchen kannst - ganz ohne manuelles Tagging.

Das Projekt ist auf GitHub unter https://github.com/immich-app/immich verfügbar und wird aktiv weiterentwickelt. Monatliche Releases bringen neue Features und Verbesserungen. Die Community ist lebhaft und hilfsbereit, sowohl auf Discord als auch auf Reddit.

Ein wichtiger Punkt vorab: Immich ist noch nicht Version 1.0 und befindet sich in aktiver Entwicklung. Das bedeutet, dass zwischen Updates auch mal Breaking Changes auftreten können. Die Entwickler arbeiten hart daran, die Software production-ready zu machen, aber du solltest dich darauf einstellen, dass Updates manchmal manuelle Anpassungen erfordern.

Immich befindet sich in aktiver Entwicklung und hat noch keine stabile Version 1.0 erreicht. Breaking Changes zwischen Updates sind möglich. Erstelle immer ein Backup vor einem Update!

Features im Überblick

Immich bringt eine beeindruckende Feature-Liste mit, die sich nicht vor kommerziellen Alternativen verstecken muss. Hier ein detaillierter Überblick über die wichtigsten Funktionen:

Foto-Management

Timeline-Ansicht: Die Hauptansicht zeigt deine Fotos in einer chronologischen Timeline, ähnlich wie bei Google Photos. Du kannst zwischen Tages-, Monats- und Jahresansicht wechseln. Die Timeline ist performant optimiert und lädt auch bei großen Bibliotheken (100.000+ Fotos) flüssig nach.

Alben: Erstelle manuelle Alben für besondere Anlässe oder nutze automatische Alben, die Immich basierend auf Datum, Ort oder KI-Tags generiert. Alben können mit anderen Nutzern geteilt werden, sowohl intern als auch über öffentliche Links.

Favoriten und Archiv: Markiere wichtige Fotos als Favoriten oder archiviere Bilder, die du behalten, aber nicht ständig sehen möchtest. Archivierte Fotos verschwinden aus der Timeline, bleiben aber durchsuchbar.

Papierkorb: Gelöschte Fotos landen zunächst im Papierkorb und können dort wiederhergestellt werden. Nach einer konfigurierbaren Zeitspanne (Standard: 30 Tage) werden sie endgültig gelöscht.

Duplikat-Erkennung: Immich erkennt automatisch Duplikate basierend auf Checksummen und bietet dir an, diese zu entfernen. Das spart Speicherplatz und hält deine Bibliothek sauber.

KI-Features

Gesichtserkennung: Immich verwendet das InsightFace-Modell, um Gesichter in deinen Fotos zu erkennen und automatisch zu gruppieren. Du kannst den Clustern dann Namen zuweisen und hast so eine automatische Kategorisierung nach Personen. Die Erkennung funktioniert auch bei Seitenansichten und verschiedenen Altersstufen erstaunlich gut.

CLIP-basierte Textsuche: Das absolute Killer-Feature: Dank des CLIP-Modells von OpenAI kannst du deine Fotos mit natürlichsprachlichen Begriffen durchsuchen. Suche nach “Sonnenuntergang am Meer”, “roter Sportwagen” oder “Geburtstagskuchen” - Immich findet die passenden Bilder, ohne dass du vorher Tags vergeben hättest. Die Suche funktioniert mehrsprachig und versteht auch abstrakte Konzepte wie “Romantik” oder “Abenteuer”.

Smart Albums: Basierend auf den KI-Tags generiert Immich automatisch Smart Albums. Das können ortsbezogene Sammlungen sein (“Fotos aus Paris”), zeitbasierte Erinnerungen (“Dieser Tag vor einem Jahr”) oder thematische Alben (“Tiere”, “Essen”, “Sport”).

Objekt-Erkennung: Neben Gesichtern erkennt Immich auch Objekte, Szenen und Aktivitäten. Das bildet die Grundlage für die intelligente Suche und automatische Kategorisierung.

Shared Albums: Teile Alben mit anderen Immich-Nutzern auf deiner Instanz. Alle Beteiligten können Fotos hinzufügen und kommentieren - perfekt für gemeinsame Urlaube oder Familien-Events.

Externe Freigaben: Generiere öffentliche Links für Alben, die auch ohne Immich-Account zugänglich sind. Du kannst festlegen, ob die Empfänger Fotos herunterladen dürfen oder nur anschauen können.

Partner-Sharing: Eine besonders praktische Funktion: Definiere einen Partner-Account, dessen Fotos automatisch in deiner Timeline erscheinen. So haben Paare oder Familien eine gemeinsame Foto-Sammlung, ohne Fotos doppelt speichern zu müssen.

Mobile Apps

iOS und Android: Native Apps für beide Plattformen bieten die volle Funktionalität. Die Apps sind schnell, zuverlässig und fühlen sich modern an.

Auto-Backup: Konfiguriere automatische Uploads im Vordergrund oder Hintergrund. Die Apps können mehrere Alben gleichzeitig synchronisieren und merken sich, welche Fotos bereits hochgeladen wurden.

Multi-Account-Support: Verwalte mehrere Immich-Instanzen in einer App - praktisch, wenn du sowohl eine private als auch eine Familien-Instanz betreibst.

Video-Support

Immich ist nicht nur für Fotos gedacht: Videos werden ebenfalls unterstützt, inklusive Hardware-beschleunigter Transcoding-Funktionen. Die Video-Player sind in die Web- und Mobile-Apps integriert und bieten Scrubbing, Untertitel und mehr.

Architektur

Immich folgt einer modernen Microservice-Architektur und besteht aus mehreren spezialisierten Komponenten. Das Design ist auf Skalierbarkeit und Performance ausgelegt.

flowchart LR
    subgraph Clients
        Mobile[Mobile App<br/>iOS & Android]
        Web[Web UI<br/>Browser]
        CLI[immich-cli<br/>Bulk Upload]
    end

    subgraph Server
        API[immich-server<br/>REST API & WebUI]
        ML[immich-machine-learning<br/>Python ML Server]
    end

    subgraph Data
        PG[(PostgreSQL<br/>+ pgvector)]
        Redis[(Redis<br/>Cache & Queue)]
        Storage[File Storage<br/>Fotos & Videos]
    end

    Mobile --> API
    Web --> API
    CLI --> API
    API --> PG
    API --> Redis
    API --> Storage
    API <--> ML
    ML --> Storage

Komponenten im Detail

immich-server: Der Haupt-Server ist in TypeScript/Node.js geschrieben und stellt sowohl die REST API als auch das Web-Frontend bereit. Er koordiniert alle Operationen, verwaltet Uploads, generiert Thumbnails und kommuniziert mit der Datenbank und dem ML-Server.

immich-machine-learning: Ein separater Python-Server übernimmt alle Machine-Learning-Aufgaben: Gesichtserkennung, CLIP-Embeddings für die Suche, Objekt-Detection und Smart Tagging. Die Trennung erlaubt es, den ML-Server auf einem anderen Host mit GPU laufen zu lassen.

PostgreSQL mit pgvector: Als Datenbank kommt PostgreSQL zum Einsatz, erweitert um die pgvector-Extension. Diese ermöglicht es, hochdimensionale Vektoren (CLIP-Embeddings) effizient zu speichern und per Ähnlichkeitssuche abzufragen - das Herzstück der intelligenten Suche.

Redis: Dient als Cache und Message Queue für asynchrone Jobs wie Thumbnail-Generierung und ML-Processing.

File Storage: Die Original-Fotos und -Videos werden im Dateisystem gespeichert, organisiert nach User-ID und Upload-Datum. Immich generiert automatisch verschiedene Thumbnail-Größen und speichert diese separat.

Voraussetzungen (Hardware)

Die Hardware-Anforderungen hängen stark von der Größe deiner Foto-Bibliothek und der Nutzung der KI-Features ab. Hier eine Übersicht:

Komponente	Minimum	Empfohlen	Für 100k+ Fotos
CPU	2 Cores	4 Cores	8+ Cores
RAM	4 GB	8 GB	16+ GB
Storage	50 GB + Fotos	SSD für DB, HDD für Fotos	NVMe für DB
GPU	-	Optional (CUDA/OpenVINO)	NVIDIA GPU empfohlen

Detaillierte Empfehlungen

CPU: Der CPU-Bedarf kommt hauptsächlich durch Thumbnail-Generierung und Video-Transcoding. Bei großen Bibliotheken solltest du mindestens 4 Cores einplanen. Für das initiale Processing einer großen Sammlung sind mehr Cores von Vorteil.

RAM: PostgreSQL, Redis und die beiden Server-Komponenten wollen alle im RAM laufen. 8 GB sind ein guter Startpunkt für mittelgroße Bibliotheken (bis 50.000 Fotos). Bei größeren Sammlungen plane 16 GB oder mehr ein, besonders wenn du viele gleichzeitige Nutzer hast.

Storage: Plane den dreifachen Speicherplatz deiner Original-Bibliothek ein: Originale + Thumbnails + Datenbank + Puffer. Die Datenbank sollte auf einer SSD liegen, da Immich viele Index-Lookups macht. Die Foto-Dateien selbst können auch auf günstigeren HDDs liegen.

GPU-Beschleunigung: Hier wird es interessant: Eine dedizierte GPU beschleunigt die ML-Verarbeitung dramatisch. Der Unterschied ist gewaltig:

Eine dedizierte GPU (NVIDIA mit CUDA) beschleunigt die ML-Verarbeitung erheblich. Ohne GPU dauert das initiale Processing von 50.000 Fotos mehrere Tage statt weniger Stunden.

Ohne GPU rechnet der ML-Server auf der CPU und braucht pro Foto mehrere Sekunden für alle Analysen. Mit einer NVIDIA-GPU (z.B. GTX 1660, RTX 3060 oder besser) reduziert sich das auf unter eine Sekunde pro Foto. Für das initiale Setup einer großen Bibliothek ist eine GPU also fast Pflicht - später kannst du sie wieder entfernen, wenn alle Fotos processed sind.

Alternativen zu CUDA sind OpenVINO (Intel-GPUs und CPUs) oder CoreML (Apple Silicon), aber CUDA liefert die beste Performance.

Installation mit Docker

Die empfohlene Installation erfolgt über Docker Compose. Immich stellt eine vollständige Compose-Datei bereit, die alle Komponenten orchestriert.

Vorbereitung

Erstelle zunächst ein Verzeichnis für Immich:

        
mkdir -p /opt/immich
cd /opt/immich

Docker Compose Konfiguration

Erstelle eine docker-compose.yml mit folgendem Inhalt:

        
      
services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:release
    container_name: immich-server
    command: ['start.sh', 'immich']
    volumes:
      - ${UPLOAD_LOCATION}:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    ports:
      - 2283:2283
    depends_on:
      - redis
      - database
    restart: unless-stopped

  immich-microservices:
    image: ghcr.io/immich-app/immich-server:release
    container_name: immich-microservices
    command: ['start.sh', 'microservices']
    volumes:
      - ${UPLOAD_LOCATION}:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    depends_on:
      - redis
      - database
    restart: unless-stopped

  immich-machine-learning:
    image: ghcr.io/immich-app/immich-machine-learning:release
    container_name: immich-ml
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    container_name: immich-redis
    healthcheck:
      test: redis-cli ping || exit 1
    restart: unless-stopped

  database:
    image: tensorchord/pgvecto-rs:pg16-v0.2.0
    container_name: immich-db
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: '--data-checksums'
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: pg_isready --dbname='${DB_DATABASE_NAME}' --username='${DB_USERNAME}' || exit 1
      interval: 5s
      timeout: 5s
      retries: 5
    command: ["postgres", "-c" ,"shared_preload_libraries=vectors.so", "-c", 'search_path="$$user", public, vectors', "-c", "logging_collector=on", "-c", "max_wal_size=2GB", "-c", "shared_buffers=512MB", "-c", "wal_compression=on"]
    restart: unless-stopped

volumes:
  pgdata:
  model-cache:

Umgebungsvariablen

Erstelle eine .env-Datei im gleichen Verzeichnis:

        
      
# Pfad zum Upload-Verzeichnis (Fotos und Videos)
UPLOAD_LOCATION=./library

# Datenbank-Credentials
DB_PASSWORD=immich
DB_USERNAME=postgres
DB_DATABASE_NAME=immich

# Immich-Server Einstellungen
IMMICH_VERSION=release

# Optional: Redis Password
# REDIS_PASSWORD=

# Optional: GPU Support für ML (CUDA)
# NVIDIA_VISIBLE_DEVICES=all
# NVIDIA_DRIVER_CAPABILITIES=compute,utility

# Optional: Log Level
# LOG_LEVEL=log

Container starten

Starte alle Services mit:

docker compose up -d

Docker lädt die Images herunter und startet die Container. Das kann beim ersten Mal ein paar Minuten dauern, da der ML-Server auch die Modelle herunterladen muss (ca. 2 GB).

Initiales Setup

Öffne deinen Browser und navigiere zu http://deine-server-ip:2283. Du wirst durch einen Setup-Wizard geführt:

Admin-Account erstellen: Wähle einen Benutzernamen und ein sicheres Passwort.
Storage Template: Lege fest, wie Immich die Dateien organisiert (empfohlen: Standard).
Machine Learning: Die ML-Features sind standardmäßig aktiviert - lass sie an.
Fertig! Du landest auf der Hauptseite und kannst beginnen, Fotos hochzuladen.

GPU-Support aktivieren (Optional)

Wenn du eine NVIDIA-GPU nutzen möchtest, füge in der docker-compose.yml beim immich-machine-learning-Service folgendes hinzu:

        
      
immich-machine-learning:
  image: ghcr.io/immich-app/immich-machine-learning:release
  container_name: immich-ml
  volumes:
    - model-cache:/cache
  env_file:
    - .env
  restart: unless-stopped
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: 1
            capabilities: [gpu]

Stelle sicher, dass du das NVIDIA Container Toolkit installiert hast:

        
      
# Ubuntu/Debian
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Mobile App einrichten

Die Mobile Apps sind das Herzstück von Immich - sie ersetzen Google Photos’ automatisches Backup und sorgen dafür, dass alle deine Fotos sicher auf deinem Server landen.

Installation

iOS: Lade die App aus dem App Store: Suche nach “Immich” oder nutze den direkten Link vom Immich-Projekt.

Android: Die App ist im Google Play Store verfügbar. Alternativ kannst du die APK auch direkt von GitHub herunterladen, falls du Play Store meidest.

Erstes Setup

Server-URL eingeben: Öffne die App und gib die URL deines Immich-Servers ein. Format: http://192.168.1.100:2283 oder https://immich.deinedomain.de falls du einen Reverse Proxy nutzt.
Login: Melde dich mit dem Admin-Account an, den du im Web-Setup erstellt hast.
Backup-Einstellungen: Die App führt dich durch die Backup-Konfiguration. Hier die wichtigsten Optionen:
- Alben auswählen: Standardmäßig wird die Kamera-Roll gesichert. Du kannst weitere Alben hinzufügen.
- Vordergrund vs. Hintergrund: Vordergrund-Backup ist schneller, Hintergrund-Backup läuft automatisch.
- Nur WLAN: Aktiviere diese Option, um mobile Daten zu schonen.
- Originale behalten: Lege fest, ob Fotos nach dem Upload vom Gerät gelöscht werden sollen.
Benachrichtigungen: Erlaube Benachrichtigungen, um über den Backup-Status informiert zu werden.
Backup starten: Tippe auf “Backup starten” - die App beginnt mit dem Upload deiner Fotos.

Backup-Strategien

Initiales Backup: Beim ersten Sync kann der Upload einer großen Bibliothek (z.B. 10.000 Fotos) mehrere Stunden bis Tage dauern. Tipps für den initialen Upload:

Für den initialen Upload einer großen Bibliothek empfiehlt sich die immich-cli statt der Mobile App. Sie ist deutlich schneller und kann unterbrochene Uploads fortsetzen.

Laufender Betrieb: Nach dem initialen Backup arbeitet die App im Hintergrund und lädt neue Fotos automatisch hoch. Bei iOS musst du die App gelegentlich im Vordergrund öffnen, um den Background-Upload zu triggern - iOS limitiert Hintergrund-Aktivitäten strikt.

Mehrere Geräte: Du kannst mehrere Geräte mit dem gleichen Account verbinden. Immich erkennt Duplikate und lädt jedes Foto nur einmal hoch, auch wenn es auf mehreren Geräten existiert.

KI-Features im Detail

Die Machine-Learning-Funktionen sind das, was Immich von einfachen Foto-Galleries abhebt. Schauen wir uns die einzelnen Features genauer an.

Gesichtserkennung

Immich nutzt das InsightFace-Modell für die Gesichtserkennung - eines der genauesten Open-Source-Modelle überhaupt. Der Prozess läuft in mehreren Schritten:

Face Detection: Zunächst werden alle Gesichter in deinen Fotos erkannt. Das Modell findet auch Gesichter in ungünstigen Winkeln, bei schlechter Beleuchtung oder teilweise verdeckt.

Face Embedding: Für jedes erkannte Gesicht berechnet Immich einen 512-dimensionalen Vektor (Embedding), der die Merkmale des Gesichts repräsentiert. Ähnliche Gesichter haben ähnliche Embeddings.

Clustering: Alle Embeddings werden geclustert - Gesichter, die sich ähneln, landen in einer Gruppe. Das läuft vollautomatisch und ist erstaunlich akkurat.

Manuelle Nachbearbeitung: Im Web-Interface kannst du die Cluster überprüfen und nachbessern:

Namen zuweisen: Gib den Clustern Namen - dann sind alle Fotos dieser Person durchsuchbar.
Merge: Verbinde fälschlicherweise getrennte Cluster.
Split: Trenne Cluster, wenn mehrere Personen zusammengeworfen wurden.
Ausblenden: Markiere Gesichter als “nicht relevant” (z.B. Fremde im Hintergrund).

Privacy-Aspekt: Die gesamte Gesichtserkennung läuft lokal auf deinem Server. Keine Bilder oder Daten verlassen dein Netzwerk. Das ist ein riesiger Vorteil gegenüber Cloud-Services.

CLIP Smart Search

CLIP (Contrastive Language-Image Pre-Training) ist ein Modell von OpenAI, das die semantische Lücke zwischen Text und Bildern überbrückt. Immich nutzt CLIP, um deine Fotos durchsuchbar zu machen - ohne dass du ein einziges Tag setzen musst.

Wie es funktioniert: Für jedes Foto berechnet Immich ein CLIP-Embedding - einen Vektor, der den Inhalt des Bildes repräsentiert. Wenn du eine Suche startest, wird dein Suchbegriff ebenfalls in einen Vektor umgewandelt. Immich findet dann die Fotos, deren Vektoren dem Suchvektor am ähnlichsten sind.

Beispiel-Suchen:

Konkret: “Roter Sportwagen”, “Golden Retriever”, “Pizza”
Szenen: “Sonnenuntergang am Meer”, “Berggipfel mit Schnee”, “Stadtbild bei Nacht”
Aktivitäten: “Skifahren”, “Schwimmen”, “Geburtstag feiern”
Abstrakt: “Romantisch”, “Abenteuer”, “Gemütlich”
Farben: “Blaue Blumen”, “Orange sunset”

Mehrsprachig: CLIP wurde auf Dutzenden von Sprachen trainiert. Suche auf Deutsch, Englisch, Französisch - es funktioniert alles.

Kombination mit Metadaten: Du kannst die CLIP-Suche mit klassischen Filtern kombinieren: “Sonnenuntergang” + Ort: “Spanien” + Zeitraum: 2024.

Smart Albums

Basierend auf den KI-Tags erstellt Immich automatisch Smart Albums. Diese werden dynamisch generiert und aktualisieren sich selbst, wenn neue Fotos hinzukommen.

Kategorien:

Orte: “Fotos aus Paris”, “Berlin”, “Zuhause”
Objekte: “Tiere”, “Essen”, “Autos”, “Pflanzen”
Personen: Automatische Alben für jede erkannte Person
Zeitbasiert: “Dieser Tag vor einem Jahr”, “Letzte Woche”
Events: Immich erkennt Event-Cluster (viele Fotos in kurzer Zeit) und gruppiert sie automatisch

Anpassung: Du kannst eigene Smart-Album-Regeln definieren, z.B. “Alle Fotos von Person X an Ort Y”.

Externe Bibliothek einbinden

Viele Nutzer haben bereits eine große Foto-Sammlung auf einem NAS oder einer externen Festplatte. Statt alles neu hochzuladen, kannst du externe Bibliotheken direkt in Immich einbinden.

Vorteile

Keine Duplikate: Die Originale bleiben, wo sie sind.
Schneller: Kein Upload nötig.
Speicher-effizient: Immich erstellt nur Thumbnails und Metadaten.

Setup

1. Volume in Docker Compose mounten:

Erweitere die docker-compose.yml um ein zusätzliches Volume beim immich-server und immich-microservices:

        
      
volumes:
  - ${UPLOAD_LOCATION}:/usr/src/app/upload
  - /mnt/nas/photos:/usr/src/app/external:ro
  - /etc/localtime:/etc/localtime:ro

Das :ro macht das Volume read-only - Immich kann die Originale nicht verändern.

2. Container neu starten:

docker compose down
docker compose up -d

3. Externe Bibliothek in Immich konfigurieren:

Im Web-Interface:

Gehe zu Administration → External Libraries
Klicke auf Add Library
Name: z.B. “NAS Photos”
Import Path: /usr/src/app/external
Klicke auf Scan Library

Immich durchsucht nun das externe Verzeichnis und importiert alle Fotos. Dabei werden Thumbnails generiert und die KI-Analyse angestoßen - die Originaldateien bleiben unangetastet.

Best Practices

Read-Only Mount: Mounte externe Bibliotheken immer als read-only. So stellst du sicher, dass Immich deine Originale nicht versehentlich verändert oder löscht.

Verzeichnisstruktur: Immich erkennt automatisch die Ordnerstruktur und behält sie bei. Wenn deine Fotos in Ordnern nach Jahr/Monat organisiert sind, bleibt das erhalten.

Mehrere Bibliotheken: Du kannst beliebig viele externe Bibliotheken einbinden - z.B. eine pro NAS-Share oder Festplatte.

Rescan: Wenn du neue Fotos zur externen Bibliothek hinzufügst, triggere einen manuellen Scan in den Admin-Einstellungen. Immich kann auch automatische Rescans schedulen.

Backup-Strategie

Immich verwaltet deine wertvollsten Erinnerungen - ein solides Backup ist Pflicht. Die Backup-Strategie muss drei Komponenten abdecken:

Was muss gesichert werden?

PostgreSQL-Datenbank: Enthält alle Metadaten, Alben, Sharing-Infos, Gesichts-Cluster, etc.
Upload-Verzeichnis: Die Original-Fotos und -Videos.
Thumbnails: Optional - können notfalls neu generiert werden.
Konfiguration: Docker Compose Files und .env-Datei.

Datenbank-Backup

PostgreSQL bietet mit pg_dump ein robustes Backup-Tool:

        
      
#!/bin/bash
# Backup-Verzeichnis mit Datum
BACKUP_DIR=/backup/immich/$(date +%Y-%m-%d)
mkdir -p $BACKUP_DIR

# Datenbank-Dump
docker exec immich-db pg_dumpall -U postgres | gzip > $BACKUP_DIR/db_dump.sql.gz

echo "Database backup completed: $BACKUP_DIR/db_dump.sql.gz"

Wiederherstellung:

        
      
gunzip < db_dump.sql.gz | docker exec -i immich-db psql -U postgres

Upload-Verzeichnis sichern

Die Fotos und Videos sind das Herzstück. Nutze ein Tool wie rsync für inkrementelle Backups:

        
      
#!/bin/bash
BACKUP_DIR=/backup/immich/$(date +%Y-%m-%d)
mkdir -p $BACKUP_DIR

# Inkrementelles Backup mit rsync
rsync -avh --progress \
  ./library/ \
  $BACKUP_DIR/library/

echo "Upload directory backup completed: $BACKUP_DIR/library/"

Alternative: Snapshots Wenn dein Storage-System Snapshots unterstützt (ZFS, Btrfs, LVM), nutze diese. Sie sind schnell, effizient und erlauben Point-in-Time-Recovery.

Komplettes Backup-Script

Kombiniere beide Ansätze in einem Script:

        
      
#!/bin/bash
set -e

# Konfiguration
BACKUP_ROOT=/backup/immich
DATE=$(date +%Y-%m-%d_%H-%M-%S)
BACKUP_DIR=$BACKUP_ROOT/$DATE
RETENTION_DAYS=30

# Backup-Verzeichnis erstellen
mkdir -p $BACKUP_DIR

echo "Starting Immich backup: $BACKUP_DIR"

# 1. Datenbank
echo "Backing up database..."
docker exec immich-db pg_dumpall -U postgres | gzip > $BACKUP_DIR/db_dump.sql.gz

# 2. Upload-Verzeichnis (inkrementell)
echo "Backing up uploads..."
rsync -ah --info=progress2 \
  ./library/ \
  $BACKUP_DIR/library/

# 3. Konfiguration
echo "Backing up configuration..."
cp docker-compose.yml .env $BACKUP_DIR/

# 4. Alte Backups löschen (älter als RETENTION_DAYS)
echo "Cleaning up old backups..."
find $BACKUP_ROOT -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;

# 5. Backup-Größe anzeigen
BACKUP_SIZE=$(du -sh $BACKUP_DIR | cut -f1)
echo "Backup completed: $BACKUP_DIR ($BACKUP_SIZE)"

# Optional: Backup auf Remote-Storage sync (z.B. S3, Backblaze)
# rclone sync $BACKUP_DIR remote:immich-backups/$DATE

Mache das Script ausführbar und richte einen Cronjob ein:

        
chmod +x backup-immich.sh

# Cronjob: Täglich um 3 Uhr nachts
0 3 * * * /opt/immich/backup-immich.sh >> /var/log/immich-backup.log 2>&1

3-2-1-Regel

Befolge die Backup-Best-Practice:

3 Kopien: Original + 2 Backups
2 Medien: z.B. SSD + externe HDD
1 Offsite: z.B. Cloud-Backup (verschlüsselt)

Vergleich: Immich vs. Google Photos vs. PhotoPrism vs. LibrePhotos

Immich ist nicht die einzige Option für selbstgehostete Fotoverwaltung. Hier ein detaillierter Vergleich mit den wichtigsten Alternativen:

Feature	Immich	Google Photos	PhotoPrism	LibrePhotos
Mobile App	Ja (iOS & Android)	Ja (iOS & Android)	Web-only (PWA)	Web-only
Auto-Backup	Ja	Ja	Nein (manuell)	Nein
Gesichtserkennung	Ja (InsightFace)	Ja	Ja (TensorFlow)	Ja (face_recognition)
Smart Search (CLIP)	Ja	Ähnlich	Teilweise	Ja
Map-Ansicht	Ja	Ja	Ja	Ja
Sharing	Ja (intern + extern)	Ja (sehr gut)	Ja	Eingeschränkt
Partner-Sharing	Ja	Ja	Nein	Nein
External Libraries	Ja (read-only)	Nein	Ja	Ja
Video-Support	Ja (mit Transcoding)	Ja	Ja	Ja
Live Photos	Ja	Ja	Eingeschränkt	Nein
Kosten	Kostenlos (Self-Hosted)	Abo ab 1,99€/Monat	Abo oder Self-Hosted	Kostenlos (Self-Hosted)
Self-Hosted	Ja	Nein	Ja	Ja
Aktive Entwicklung	Sehr aktiv (monatlich)	Aktiv	Aktiv	Weniger aktiv
GPU-Support	Ja (CUDA, OpenVINO)	N/A (Cloud)	Ja	Ja
Community	Groß, wachsend	Groß	Mittel	Klein
Komplexität Setup	Mittel (Docker)	Einfach (Cloud)	Mittel (Docker)	Hoch
Ressourcen-Bedarf	Mittel-hoch	N/A (Cloud)	Hoch	Mittel
Multi-User	Ja	Ja (Familie)	Ja	Ja
API	Ja (REST)	Ja (eingeschränkt)	Ja	Ja

Interpretation

Immich vs. Google Photos: Immich ist die beste Self-Hosted-Alternative zu Google Photos. Es bildet fast alle Features nach, inklusive der hervorragenden Mobile Apps. Der Hauptunterschied: Bei Immich hostest du selbst und behältst volle Kontrolle. Dafür musst du selbst für Hardware, Wartung und Backups sorgen. Google Photos ist bequemer, kostet aber monatlich und deine Daten liegen bei Google.

Immich vs. PhotoPrism: PhotoPrism ist älter und ausgereifter, aber auch komplexer und ressourcenhungriger. Es richtet sich eher an Foto-Enthusiasten mit großen RAW-Sammlungen. Immich ist moderner, schneller und hat bessere Mobile Apps. Wenn du einen Google-Photos-Ersatz suchst, nimm Immich. Wenn du eine professionelle Photo-Management-Software brauchst, schau dir PhotoPrism an.

Immich vs. LibrePhotos: LibrePhotos war lange der CLIP-Search-Vorreiter, hat aber in letzter Zeit an Momentum verloren. Immich hat mittlerweile aufgeholt und bietet deutlich mehr Features. LibrePhotos hat keine nativen Mobile Apps und fühlt sich insgesamt weniger poliert an.

Fazit des Vergleichs

Für die meisten Nutzer, die einen Google-Photos-Ersatz suchen, ist Immich die beste Wahl. Es kombiniert moderne Technologie mit einem durchdachten Feature-Set und aktiver Entwicklung.

Tipps und Best Practices

Nach mehreren Monaten Immich-Nutzung haben sich ein paar Best Practices herauskristallisiert:

Vor dem großen Import

Test-Bibliothek: Starte mit einer kleinen Test-Bibliothek (ein paar hundert Fotos), bevor du deine gesamte Sammlung importierst. So bekommst du ein Gefühl für die Performance und kannst die Einstellungen optimieren.

Duplikate vorher bereinigen: Nutze Tools wie fdupes oder rdfind, um Duplikate aus deiner Sammlung zu entfernen, bevor du sie importierst. Das spart Speicher und macht die Bibliothek übersichtlicher.

Metadaten prüfen: Stelle sicher, dass deine Fotos vernünftige EXIF-Daten haben (Datum, GPS). Immich nutzt diese für die Timeline und Karten-Ansicht.

Bulk-Import mit immich-cli

Für große initiale Imports ist die CLI deutlich effizienter als die Mobile App:

        
# Installation
npm install -g @immich/cli

# Upload
immich upload --key YOUR_API_KEY --server http://localhost:2283 /path/to/photos

Die CLI kann unterbrochene Uploads fortsetzen, zeigt Fortschrittsanzeigen und ist generell robuster.

Externe Bibliotheken als Read-Only

Mounte externe Bibliotheken immer als read-only (:ro in Docker). So vermeidest du versehentliche Änderungen an deinen Originalen.

Monitoring

Behalte folgende Metriken im Auge:

Disk Space: Immich generiert viele Thumbnails. Plane den dreifachen Speicherplatz deiner Original-Bibliothek ein.

        
      
# Disk Usage prüfen
du -sh ./library
df -h

RAM-Nutzung: PostgreSQL cached aggressiv im RAM. Wenn der Server andere Dienste hostet, limitiere den RAM:

        
      
database:
  # ...
  command: [
    "postgres",
    "-c", "shared_buffers=512MB",
    "-c", "effective_cache_size=2GB"
  ]

ML-Queue: Im Web-Interface unter Administration siehst du den Status der ML-Jobs. Bei großen Bibliotheken kann die Queue Tage lang voll sein - das ist normal.

Automatisierte Backups

Richte unbedingt automatische Backups ein, bevor du Immich produktiv nutzt. Siehe Abschnitt “Backup-Strategie” weiter oben.

Updates

Immich released monatlich neue Versionen. Update-Prozess:

        
      
# Backup erstellen!
./backup-immich.sh

# Images pullen
docker compose pull

# Container neu starten
docker compose down
docker compose up -d

# Logs prüfen
docker compose logs -f

Lies immer die Release Notes - manchmal sind manuelle Migrations-Schritte nötig.

Community nutzen

Bei Problemen oder Fragen:

Discord: Sehr aktiv, schnelle Antworten
GitHub Issues: Für Bugs und Feature Requests
r/immich: Reddit-Community mit vielen Tipps
Docs: https://immich.app/docs - sehr gute offizielle Dokumentation

Performance-Tuning

PostgreSQL: Für große Bibliotheken (100k+ Fotos) tune PostgreSQL:

        
      
command: [
  "postgres",
  "-c", "shared_buffers=2GB",
  "-c", "effective_cache_size=6GB",
  "-c", "work_mem=64MB",
  "-c", "max_wal_size=4GB"
]

Thumbnail-Qualität: In den Admin-Einstellungen kannst du die Thumbnail-Qualität anpassen. Höhere Qualität = mehr Speicher, aber bessere Vorschau.

ML-Models: Die Standard-Modelle sind ein guter Kompromiss. Für maximale Genauigkeit gibt es größere Modelle in den Einstellungen - die brauchen aber deutlich mehr RAM und Rechenzeit.

Erweiterte Features

Reverse Proxy mit SSL

Fuer den Zugriff von unterwegs solltest du Immich hinter einen Reverse Proxy mit SSL stellen. Hier beide gaengigen Varianten:

Variante 1: Nginx Proxy Manager (NPM)

Die komfortabelste Loesung mit grafischer Oberflaeche:

Domain: immich.example.com
Forward Hostname: immich-server (Container-Name oder IP)
Forward Port: 2283
SSL: Let’s Encrypt aktivieren
Custom Nginx Configuration (Advanced-Tab):

        
      
client_max_body_size 50G;
proxy_read_timeout 600s;
proxy_send_timeout 600s;
proxy_connect_timeout 600s;

Websockets Support: Aktivieren

Das client_max_body_size-Limit ist entscheidend - ohne diese Einstellung blockiert Nginx Uploads ueber 1 MB. Fuer Video-Uploads von mehreren GB sollte der Wert grosszuegig bemessen sein.

Variante 2: Nginx (manuell)

Falls du Nginx direkt konfigurierst:

        
      
server {
    listen 443 ssl http2;
    server_name immich.example.com;

    ssl_certificate /etc/letsencrypt/live/immich.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/immich.example.com/privkey.pem;

    client_max_body_size 50G;

    location / {
        proxy_pass http://localhost:2283;
        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;

        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 600s;
        proxy_send_timeout 600s;
    }
}

Variante 3: Traefik

Fuer Traefik-Setups via Docker-Labels im docker-compose.yml:

        
      
services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:release
    # ... restliche Config ...
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.immich.rule=Host(`immich.example.com`)"
      - "traefik.http.routers.immich.entrypoints=websecure"
      - "traefik.http.routers.immich.tls.certresolver=letsencrypt"
      - "traefik.http.services.immich.loadbalancer.server.port=2283"
      - "traefik.http.middlewares.immich-body.buffering.maxRequestBodyBytes=53687091200"

Bei Traefik muss das Upload-Limit ueber eine Buffering-Middleware gesetzt werden, da Traefik standardmaessig kein Body-Size-Limit hat - was fuer Immich praktisch ist, aber bei Memory-Problemen eingeschraenkt werden sollte.

OAuth/OIDC Integration

Immich unterstützt Single Sign-On via OAuth2/OIDC. Konfiguriere das in der Web-UI unter Administration → Authentication. Kompatibel mit Authentik, Authelia, Keycloak, etc.

Reverse Geocoding

Immich kann GPS-Koordinaten automatisch in Ortsnamen übersetzen. Aktiviere das Feature in den Admin-Einstellungen. Es nutzt OpenStreetMap-Daten und läuft komplett offline.

Erstelle öffentliche Links für Alben:

Öffne ein Album
Klicke auf “Share”
Wähle “Create public link”
Optional: Passwort-Schutz, Ablaufdatum, Download-Rechte

Der Link ist dann ohne Login zugänglich - perfekt zum Teilen mit Freunden oder Familie, die keinen Immich-Account haben.

Multi-User-Setup

Immich ist multi-user-fähig. Lege in den Admin-Einstellungen neue Benutzer an. Jeder Nutzer hat:

Eigenen Upload-Bereich
Eigene Alben und Favoriten
Optional: Partner-Sharing mit anderen Nutzern
Optional: Shared Albums

Gut für Familien oder WGs.

Troubleshooting

Häufige Probleme

ML-Jobs hängen fest: Wenn die ML-Queue nicht weiterläuft:

# ML-Container neu starten
docker restart immich-ml

# Logs prüfen
docker logs immich-ml

Oft hilft es, die Jobs in der Admin-UI komplett zurückzusetzen und neu zu starten.

Uploads schlagen fehl: Check die Logs:

docker logs immich-server
docker logs immich-microservices

Häufige Ursachen:

Disk voll
Permission-Probleme beim Upload-Volume
RAM-Limit erreicht

Langsame Timeline: Bei sehr großen Bibliotheken kann die Timeline langsam werden. Hilft:

PostgreSQL-Tuning (siehe oben)
Thumbnails auf SSD legen
RAM erhöhen

Gesichter werden nicht erkannt:

Prüfe, ob der ML-Service läuft
Schau in die Job-Queue (Admin → Jobs)
Eventuell Modelle neu herunterladen (Delete Model Cache in Einstellungen)

Logs und Debugging

Container-Logs:

        
      
# Alle Services
docker compose logs -f

# Nur Server
docker compose logs -f immich-server

# Nur ML
docker compose logs -f immich-ml

Log-Level erhöhen: In der .env:

LOG_LEVEL=debug

Container neu starten, dann sind die Logs viel ausführlicher.

Datenbank-Konsole:

        
      
docker exec -it immich-db psql -U postgres -d immich

Performance-Probleme

Hoher RAM-Verbrauch: PostgreSQL, Redis und der ML-Server brauchen alle RAM. Limitiere sie bei Bedarf in der docker-compose.yml:

        
      
services:
  database:
    # ...
    mem_limit: 4g

  immich-ml:
    # ...
    mem_limit: 2g

Hohe CPU-Last: Während des initialen ML-Processings normal. Wenn es dauerhaft hoch ist:

Prüfe, ob stuck jobs existieren
Eventuell ML-Features temporär deaktivieren

Roadmap und Zukunft

Immich entwickelt sich rasant weiter. Hier ein Blick auf geplante Features und die Projekt-Roadmap:

Geplante Features (2026)

Version 1.0: Die größte Milestone steht an: Version 1.0 mit Stabilitäts-Garantie. Breaking Changes sollen dann der Vergangenheit angehören.

Collaborative Editing: Gemeinsames Bearbeiten von Fotos (Cropping, Filter, Rotation) direkt im Web-Interface.

Advanced Search: Kombinierte Filter mit UND/ODER-Logik, gespeicherte Suchen, Smart Search API.

Video-Features: Besserer Video-Player, Clip-Extraktion, Video-Transcoding-Presets.

Offline-Modus: Die Mobile Apps sollen auch ohne Netzwerk funktionieren und später synchronisieren.

Langfristige Vision

Das Immich-Team hat eine klare Vision: Eine vollständige, selbstgehostete Alternative zu Google Photos, die in allen Aspekten mithalten kann. Das beinhaltet:

Feature-Parität mit Google Photos
Enterprise-Readiness: Multi-Tenancy, LDAP, SSO, Audit-Logs
Erweiterte KI: Video-Analyse, automatische Kategorisierung, Empfehlungen
Cloud-Backup-Integration: Optionales verschlüsseltes Cloud-Backup für Redundanz
Plugins: Erweiterbarkeit durch Third-Party-Plugins

Die Community ist aktiv und die Entwickler sehr zugänglich. Es lohnt sich, das Projekt zu verfolgen.

Fazit

Immich ist in kurzer Zeit zu einer der besten Self-Hosted-Lösungen für Fotoverwaltung geworden. Die Kombination aus moderner Technologie, durchdachtem Feature-Set und aktiver Entwicklung macht es zur ersten Wahl für alle, die von Google Photos weg wollen, ohne auf Komfort zu verzichten.

Die KI-Features sind beeindruckend und funktionieren auch lokal erstaunlich gut. Die Mobile Apps sind ausgereift und bieten ein Nutzererlebnis, das kommerziellen Alternativen in nichts nachsteht. Die Installation via Docker ist unkompliziert, und die Community hilft bei Problemen schnell weiter.

Wann lohnt sich Immich?

Du hast die Hardware (oder bist bereit zu investieren)
Privacy ist dir wichtig - deine Fotos sollen bei dir bleiben
Du bist bereit, dich um Wartung und Backups zu kümmern
Du möchtest langfristig unabhängig von Abo-Modellen sein

Wann vielleicht nicht?

Du willst null Aufwand - dann ist Google Photos bequemer
Du hast keine zuverlässige Backup-Strategie - dann riskierst du Datenverlust
Deine Hardware ist zu schwach - dann wird die ML-Verarbeitung zur Qual

Für mich persönlich hat sich der Umstieg gelohnt. Die initiale Setup-Zeit war überschaubar, und seitdem läuft Immich stabil und zuverlässig. Ich habe wieder die volle Kontrolle über meine Fotos, ohne auf moderne Features verzichten zu müssen. Wenn du ein Homelab betreibst und einen Google-Photos-Ersatz suchst, ist Immich definitiv einen Test wert.

Ressourcen

Hier findest du weitere Informationen und Hilfe zu Immich:

Offizielle Quellen:

GitHub Repository: github.com/immich-app/immich
Offizielle Dokumentation: immich.app/docs
Demo-Instanz: demo.immich.app
immich-cli: github.com/immich-app/cli

Community:

Discord Server: Der aktivste Support-Kanal, sehr hilfsbereit
r/immich: Reddit-Community mit vielen Tipps und Showcases
GitHub Discussions: Für Feature-Requests und längere Diskussionen

Verwandte Projekte:

PhotoPrism: Alternative für RAW-Fotografen
LibrePhotos: Weitere Alternative mit CLIP-Suche
Photoview: Minimalistischere Galerie-Software

Tools:

Nginx Proxy Manager: Einfacher Reverse Proxy mit Let’s Encrypt
Authentik: OAuth/OIDC-Provider für SSO
rclone: Für Cloud-Backups (S3, Backblaze, etc.)

Viel Erfolg mit deiner Immich-Installation!

Homelab, Medien

immich photos google-photos ai machine-learning self-hosted docker homelab backup web-ui

Dieser Eintrag ist vom Autor unter CC BY 4.0 lizensiert.