Post

Immich (photos et vidéos)

Posté Mis à jour
Preview Image
Par Yann
16 min lire
Immich (photos et vidéos)

immich - Gestionnaire web photos et vidéos installé sur une machine virtuelle Alpine Linux

Immich

Immich est une application qui permet de télécharger et d’afficher des actifs (photos et vidéos) sur un serveur Immich auto-hébergé. L’application offre des fonctionnalités de sauvegarde automatique, de marquage, de recherche, de géocodage et de détection d’objet.

Exigences

Un système avec au moins 4 Go de RAM et 2 cœurs CPU.

Voici quelques-unes des fonctionnalités clés qui en font une solution intéressante :

  • Lecteur photo et vidéo : Prise en charge les formats de fichiers courants, y compris les fichiers RAW pour les photos
  • Données Exif : Les informations Exif (Exchangeable Image File Format) sont utilisées pour fournir des détails supplémentaires aux photos, comme la date de prise de vue, le modèle de l’appareil photo…
  • Vue carte : Permet de visualiser où les photos ont été prises sur une carte, cela ajoute une dimension géographique intéressante
  • Détection des visages : Immich utilise des algorithmes de reconnaissance faciale pour organiser et retrouver plus facilement des photos de personnes
  • Gestion par Dossier et Favoris : Organisez vos photos comme vous le souhaitez et marquez les photos préférées pour un accès plus rapide
  • Portail d’administration : Gestion des paramètres de l’application et des utilisateurs
  • Partage via des liens : Partagez vos photos et vidéos facilement avec des liens
  • Moteur de recherche : Facilite la recherche des photos grâce à des options avancées
  • Vue 360° : Profitez d’une vue immersive de vos photos panoramiques
  • Accélération matérielle (GPU) : Optimisez la performance de traitement des images et vidéos grâce à l’accélération matérielle
  • Édition rapide, mode sombre, authentification viaOAuth2 et OIDC, etc.

Particularités

  • son ergonomie, sobre et efficace, agréable à utiliser
  • les options de tri « intelligentes » pour classer automatiquement les photos/vidéos qui permettent de les retrouver très facilement ( lieu,détection des visages, tags personnalisés etc)
  • les vidéos super fluides, avec un aperçu au survol de la souris digne des perfs d’un Netflix
  • la possibilité de synchroniser les photos de son smartphone
  • autohébergeable, tu peux l’installer sur ton serveur ou sur ton pc en local avec docker
  • une appli conçue et orientée « respect de la vie privée »

Télécharger les fichiers requis

Créez un répertoire de votre choix (par exemple ./immich-app) pour tenir les fichiers docker-compose.yml et .env.
Déplacer vers le répertoire que vous avez créé

1
2

mkdir -p /sharenfs/docker-app/immich-app
cd /sharenfs/docker-app/immich-app

Télécharger docker-compose.yml et example.env en exécutant les commandes suivantes:

1
2

wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env

Personnaliser

fichier docker-compose.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:${IMMICH_VERSION:-release}
    # extends:
    #   file: hwaccel.transcoding.yml
    #   service: cpu # set to one of [nvenc, quicksync, rkmpp, vaapi, vaapi-wsl] for accelerated transcoding
    volumes:
      # Do not edit the next line. If you want to change the media storage location on your system, edit the value of UPLOAD_LOCATION in the .env file
      - ${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
    # For hardware acceleration, add one of -[armnn, cuda, rocm, openvino, rknn] to the image tag.
    # Example tag: ${IMMICH_VERSION:-release}-cuda
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}
    # extends: # uncomment this section for hardware acceleration - see https://docs.immich.app/features/ml-hardware-acceleration
    #   file: hwaccel.ml.yml
    #   service: cpu # set to one of [armnn, cuda, rocm, openvino, openvino-wsl, rknn] for accelerated inference - use the `-wsl` version for WSL2 where applicable
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9@sha256:3b55fbaa0cd93cf0d9d961f405e4dfcc70efe325e2d84da207a0a8e6d8fde4f9
    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:bcf63357191b76a916ae5eb93464d65c07511da41e3bf7a8416db519b40b1c23
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: '--data-checksums'
      # Uncomment the DB_STORAGE_TYPE: 'HDD' var if your database isn't stored on SSDs
      # DB_STORAGE_TYPE: 'HDD'
    volumes:
      # Do not edit the next line. If you want to change the database storage location on your system, edit the value of DB_DATA_LOCATION in the .env file
      - ${DB_DATA_LOCATION}:/var/lib/postgresql/data
    shm_size: 128mb
    restart: always
    healthcheck:
      disable: false

volumes:
  model-cache:

fichier .env

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# You can find documentation for all the supported env variables at https://docs.immich.app/install/environment-variables

# The location where your uploaded files are stored
UPLOAD_LOCATION=../../docker-data/immich/data

# The location where your database files are stored. Network shares are not supported for the database
DB_DATA_LOCATION=../../docker-data/immich/postgres

# To set a timezone, uncomment the next line and change Etc/UTC to a TZ identifier from this list: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
TZ=Europe/Paris

# The Immich version to use. You can pin this to a specific version like "v2.1.0"
IMMICH_VERSION=v2

# Connection secret for postgres. You should change it to a random password
# Please use only the characters `A-Za-z0-9`, without special characters or spaces
DB_PASSWORD=Mot_de_Passe_Database

# The values below this line do not need to be changed
###################################################################################
DB_USERNAME=postgres
DB_DATABASE_NAME=immich
  • UPLOAD_LOCATION avec votre emplacement préféré pour stocker des actifs de sauvegarde. Ce devrait être un nouveau répertoire sur le serveur avec suffisamment d’espace libre.
  • Envisagez de changer DB_PASSWORD en une valeur personnalisée. Postgres n’est pas publiquement exposé, donc ce mot de passe n’est utilisé que pour l’authentification locale. Pour éviter les problèmes avec l’analyse de cette valeur par Docker, il est préférable d’utiliser uniquement les caractères A-Za-z0-9. pwgen est un utilitaire pratique pour cela.
  • Définir le fuseau horaire en décommentant la ligne TZ=.

Démarrer les conteneurs

À partir du répertoire que vous avez créé à l’étape 1 (qui devrait maintenant contenir vos fichiers docker-compose.yml et .env personnalisés), exécutez la commande suivante pour démarrer Immich comme un service de fond :

1
2

cd ~/immich-app
docker compose up -d

Proxy nginx immich.rnmkcy.eu

Configurer le fichier /etc/nginx/conf.d/immich.rnmkcy.eu.conf sur serveur debian cwwk rnmkcy.eu

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;

    server_name immich.rnmkcy.eu;

    include /etc/nginx/conf.d/ssl-modern.inc;

    client_max_body_size 0;

    location / {
        proxy_pass http://192.168.0.205:2283;
        proxy_http_version 1.1;

        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 https;
        proxy_set_header X-Forwarded-Host  $host;
        proxy_set_header X-Forwarded-Port  443;

        proxy_set_header Upgrade            $http_upgrade;
        proxy_set_header Connection         "upgrade";

        proxy_redirect off;

        proxy_read_timeout 600s;
        proxy_send_timeout 600s;
        send_timeout 600s;
    }
}

Le point le plus important est :

1

proxy_set_header X-Forwarded-Proto https;

Sans cet en-tête, Immich peut considérer la requête comme arrivant en HTTP depuis 192.168.0.205:2283, alors que l’utilisateur se connecte en réalité à https://immich.rnmkcy.eu. Cela peut provoquer un callback incorrect ou une erreur lors de la finalisation OAuth.

Se connecter sur le lien https://immich.rnmkcy.eu

Le premier utilisateur à s’enregistrer sera l’utilisateur administrateur.
L’utilisateur administrateur pourra ajouter d’autres utilisateurs à l’application.

cliquez sur le bouton Commencer.

  • Thème: Sombre
  • Langue: French





Bibliothèque externe

Ce guide vous accompagne dans l’ajout d’une bibliothèque externe. Ce guide suppose que vous exécutez Immich dans Docker et que les fichiers auxquels vous souhaitez accéder sont stockés dans un répertoire sur la même machine.(External Library)

Le dossier externe /sharenfs/docker-data/immich/PhotosVideos

Modifier le fichier docker-compose.yml
Ajout de la ligne - /sharenfs/docker-data/immich/PhotosVideos:/mnt/PhotosVideos:ro
Dossier local: /sharenfs/docker-data/immich/PhotosVideos
Dossier container: /mnt/PhotosVideos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:${IMMICH_VERSION:-release}
    # extends:
    #   file: hwaccel.transcoding.yml
    #   service: cpu # set to one of [nvenc, quicksync, rkmpp, vaapi, vaapi-wsl] for accelerated transcoding
    volumes:
      # Do not edit the next line. If you want to change the media storage location on your system, edit the value of UPLOAD_LOCATION in the .env file
      - ${UPLOAD_LOCATION}:/data
      - /etc/localtime:/etc/localtime:ro
      - /sharenfs/docker-data/immich/PhotosVideos:/mnt/PhotosVideos:ro
    env_file:
      - .env
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false

Mise à jour

1

docker compose up -d

Vérifier que le dossier est bien lisible “dans les conteneurs”

1

docker exec -it immich_server sh -lc 'ls -la /mnt/PhotosVideos | head'

Ouvrir le site immich


Se connecter en administration


Nom de la source externe: /mnt/PhotosVideos/
Propriétaire de la source: yann



Dossier: /mnt/PhotosVideos
Un message vous indique que la bibliothèque est mise à jour
Cliquer sur modifier pour changer le nom de bibliothèque
Cliquer sur Analyser puis sur Bibliothèques externes

Configuration SSO pour Immich avec Authelia OIDC

Dans cet article de blog, nous allons configurer Authelia comme fournisseur OIDC et l’utiliser pour activer l’authentification unique (SSO) dans Immich ⭐

Générer un client_secret via la commande suivante :

1

authelia crypto hash generate pbkdf2 --variant sha512 --random --random.length 72 --random.charset rfc3986

La commande précédente renvoie 2 lignes

1
2

Random Password: -G3xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Digest: $pbkdf2-sha512xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

⚠️ Veuillez noter le mot de passe en clair (Random Password) ainsi que le hachage $pbkdf2 (Digest) du mot de passe pour une utilisation ultérieure.

Ajouter ce qui suit à la configuration authelia OIDC Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    clients:


      - client_id: immich
        client_name: Immich OIDC
        client_secret: '$pbkdf2-<PASSWORD-HASH-DATA>'
        public: false
        authorization_policy: 'two_factor'
        require_pkce: false
        redirect_uris:
          - 'https://immich.rnmkcy.eu/auth/login'
          - 'https://immich.rnmkcy.eu/user-settings'
          - 'https://immich.rnmkcy.eu/api/oauth/mobile-redirect'
          - 'app.immich:///oauth-callback'
        scopes:
          - 'openid'
          - 'profile'
          - 'email'
        response_types:
          - 'code'

        grant_types:
          - 'authorization_code'
        id_token_signed_response_alg: 'RS256'
        userinfo_signed_response_alg: 'none'
        token_endpoint_auth_method: 'client_secret_post'

Après avoir ajusté la configuration d’Authelia, vérifiez et redémarrez-le pour appliquer la nouvelle configuration. Inspectez activement les journaux des conteneurs pour détecter d’éventuels problèmes.

1
2
3
4
5

# en mode su
# vérification
authelia validate-config --config /etc/authelia/configuration.yml
# relancer
systemctl restart authelia

Immich - Configuration OAuth

La configuration OAuth Immich peut être ajustée en vous connectant à l’application web en tant qu’administrateur.

Accédez à votre instance web Immich et connectez-vous en tant qu’administrateur.

Voici une brève explication des paramètres clés :

  • issuer_url: https://auth.rnmkcy.eu
    il s’agit du nom de domaine complet (FQDN) de votre instance Authelia
  • client_id: immich
    Il s’agit du nom du client défini dans le fichier configuration.yml d’Authelia
  • client_secret: -G3xxxxxxxxxxxxxxxxxxxxx
    Il s’agit du secret client sous forme de mot de passe en clair (Random Password). Défini dans le fichier configuration.yml d’Authelia comme $pbkdf2 hachage du mot de passe.
  • scope: openid email profile
    Peut être laissé tel quel
  • id_token_signed_response_alg: RS256
    Pour Authelia, veuillez choisir RS256.
  • userinfo_signed_response_alg: none
  • Inscription automatique: DESACTIVEE, Démarrage automatique du flux d’authentification OAuth/OIDC. Si cette option est activée, l’option d’authentification locale avec nom d’utilisateur et mot de passe ne sera plus disponible.

Ensuite, vous pouvez cliquer sur le bouton Enregistrer et tester le SSO OIDC nouvellement configuré.

Se déconnecter de la session en cours.

Depuis l’hôte Immich, testez la découverte OIDC :

1

curl -fsS https://auth.rnmkcy.eu/.well-known/openid-configuration | jq

La valeur issuer retournée doit correspondre exactement à https://auth.rnmkcy.eu

1
2
3
4
5
6
7

{
  "issuer": "https://auth.rnmkcy.eu",
  "authorization_endpoint": "...",
  "token_endpoint": "...",
  "jwks_uri": "...",
  "userinfo_endpoint": "..."
}

Les applications web et mobile d’Immich afficheront un nouveau bouton Login with OAuth pour se connecter via OAuth/OIDC. Cliquez simplement sur ce bouton, authentifiez-vous sur Authelia et vous serez redirigé vers Immich en tant qu’utilisateur authentifié.




Docker Immich cli

Vérifier que le dossier est bien lisible “dans les conteneurs”

1

docker exec -it immich_server sh -lc 'ls -la /mnt/PhotosVideos | head'

Lier un container

1
2
3

docker exec -it <id or name> <command>          # attach to a container with a command
docker exec -it immich_server bash
docker exec -it immich_machine_learning bash

Se lier au serveur

1

docker exec -it immich_server bash

Liste des utilisateurs: immich-admin list-users

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Initializing Immich v1.134.0
Detected CPU Cores: 2
[
  {
    id: '9e4c8992-8987-4840-9197-219ec8be1f67',
    email: 'yann@yanfi.net',
    name: 'yann',
    profileImagePath: '',
    avatarColor: 'primary',
    profileChangedAt: 2025-06-10T18:07:16.330Z,
    storageLabel: 'admin',
    shouldChangePassword: true,
    isAdmin: false,
    createdAt: 2025-06-10T18:07:16.330Z,
    deletedAt: null,
    updatedAt: 2025-06-10T18:47:44.121Z,
    oauthId: '9aec801a-75f3-4452-a55d-1d3e94e045fe',
    quotaSizeInBytes: null,
    quotaUsageInBytes: 0,
    status: 'active',
    license: null
  }
]

Désactiver oauth: immich-admin disable-oauth-login

1
2
3

Initializing Immich v1.134.0
Detected CPU Cores: 2
OAuth login has been disabled.

Basculer immich vers Portainer

Docker et Portainer tournent sur le serveur qui héberge directement /sharens. Il ne s’agit donc pas d’un montage NFS vu depuis un autre client Docker.

Le chemin :

1

/sharenfs/docker-app/immich-app

est simplement un chemin local du point de vue du démon Docker. Vos bind mounts peuvent donc rester tels quels. Docker utilise directement les chemins de l’hôte pour les bind mounts.

Vous n’avez pas besoin de :

  • modifier UPLOAD_LOCATION ;
  • modifier DB_DATA_LOCATION ;
  • créer un volume Docker NFS ;
  • monter /sharens dans Portainer ;
  • recopier les photos ou la base PostgreSQL.

Portainer doit seulement gérer le même environnement Docker local.

Vérifiez simplement que Portainer est bien connecté à :

1

local

et non à un autre endpoint Docker.

Procédure adaptée

Depuis le serveur :

1
2
3
4
5
6
7
8
9

cd /sharenfs/docker-app/immich-app

set -a
. ./.env
set +a

docker exec -t immich_postgres \
  pg_dumpall -c -U "$DB_USERNAME" \
  > /sharenfs/docker-app/immich-backup.sql

Puis arrêtez l’installation actuelle :

1

docker compose down

N’utilisez pas :

1

docker compose down -v

Ensuite, dans Portainer :

1

Stacks → Add stack → Web editor

Utilisez le nom de Stack :

1

immich

Fichier Compose

Vous pouvez reprendre votre fichier presque tel quel.

Je vous conseille toutefois de remplacer les chemins variables par leurs valeurs absolues dans la Stack, afin d’éviter toute ambiguïté de résolution par Portainer :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:release
    volumes:
      - /sharens/chemin-reel-de-vos-photos:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - stack.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:release
    volumes:
      - model-cache:/cache
    env_file:
      - stack.env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9@sha256:3b55fbaa0cd93cf0d9d961f405e4dfcc70efe325e2d84da207a0a8e6d8fde4f
    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:bcf63357191b76a916ae5eb93464d65c07511da41b3ef7a8416db519b40b1c23
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: "--data-checksums"
    volumes:
      - /sharens/chemin-reel-de-postgres:/var/lib/postgresql/data
    shm_size: 128mb
    restart: always
    healthcheck:
      disable: false

volumes:
  model-cache:

Remplacez les deux chemins d’exemple par les valeurs exactes de votre .env :

1

grep -E '^(UPLOAD_LOCATION|DB_DATA_LOCATION)=' /sharenfs/docker-app/immich-app/.env

Vous pouvez aussi conserver ${UPLOAD_LOCATION} et ${DB_DATA_LOCATION} si vous importez correctement les variables dans Portainer. Pour une migration, les chemins absolus sont néanmoins plus sûrs.

Le fichier docker compose immich portainer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:release
    volumes:
      - ${UPLOAD_LOCATION}:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - stack.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:release
    volumes:
      - model-cache:/cache
    env_file:
      - stack.env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9
    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
    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
    healthcheck:
      disable: false

volumes:
  model-cache:
    external: true
    name: immich_model-cache

Importer .env dans Portainer

Dans l’écran de création de Stack :

  1. Cliquez sur Load variables from .env file.
  2. Chargez : 
    1

    /sharenfs/docker-app/immich-app/.env
  3. Vérifiez que les variables sont présentes dans Environment variables.
  4. Utilisez stack.env dans les deux services qui possèdent env_file.

Portainer permet de charger un fichier .env pour une Stack et de le rendre disponible sous le nom stack.env.

Attention : selon la version de Portainer, les variables de stack.env peuvent être utilisables par env_file sans forcément servir à l’interpolation de toutes les expressions ${...} du Compose. Si Portainer affiche une erreur du type :[

1

variable UPLOAD_LOCATION is not set

mettez alors directement les chemins absolus dans les volumes, et renseignez les variables DB_PASSWORD, DB_USERNAME et DB_DATABASE_NAME dans la section Environment variables de Portainer.

Volume model-cache

Avant le déploiement, vérifiez son nom :

1

docker volume ls | grep model-cache

Si vous voyez :

1

immich_model-cache

ajoutez éventuellement ceci dans le Compose Portainer pour garantir sa réutilisation :

1
2
3
4

volumes:
  model-cache:
    external: true
    name: immich_model-cache

Cela évite que Portainer crée un nouveau cache ML vide.

Vérifications après déploiement

Après Deploy the stack :

1

docker ps

Vous devez retrouver :

1
2
3
4

immich_server
immich_machine_learning
immich_redis
immich_postgres

Puis contrôlez :

1
2

docker logs --tail=100 immich_server
docker logs --tail=100 immich_postgres

Le point essentiel est donc : ne changez aucun chemin de stockage. Arrêtez le projet Compose actuel, créez une Stack Portainer immich avec le même Compose et les mêmes variables, puis redéployez.

Les fichiers Portainer immich

1
2
3

/sharenfs/docker-data/portainer/compose/41/
├── docker-compose.yml
└── stack.env

docker-compose.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:release
    volumes:
      - ${UPLOAD_LOCATION}:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - stack.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:release
    volumes:
      - model-cache:/cache
    env_file:
      - stack.env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9
    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
    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
    healthcheck:
      disable: false

volumes:
  model-cache:
    external: true
    name: immich_model-cache

stack.env

1
2
3
4
5
6

UPLOAD_LOCATION=/sharenfs/docker-data/immich/data
DB_DATA_LOCATION=/sharenfs/docker-data/immich/postgres
IMMICH_VERSION=v3
DB_PASSWORD=Mot_de_passe_base_postgre
DB_USERNAME=postgres
DB_DATABASE_NAME=immich
Blog, Applications
virtuel
Cet article est sous licence CC BY 4.0 par l'auteur.