Créer un Cloud Personnel & Galerie Photo IA – Raspberry Pi

Prérequis

• Un Raspberry Pi (idéalement un Raspberry Pi 4 avec 4 ou 8 Go de RAM pour de meilleures performances).
• Raspberry Pi OS (version Lite ou Desktop, 64 bits recommandé pour PhotoPrism).
• Une carte SD (minimum 32 Go, 128 Go recommandé pour stocker les photos).
• Une connexion Internet stable.
• Un ordinateur pour configurer le Raspberry Pi (via SSH ou directement).
• Un domaine (optionnel, pour un accès externe sécurisé).
• Un peu de curiosité et d’envie d’apprendre !

 

Étape 1 : Préparer le Raspberry Pi

1. Installer Raspberry Pi OS :
   • Téléchargez l’image officielle sur raspberrypi.com.
   • Flashez l’image sur votre carte SD avec Raspberry Pi Imager.
   • Activez SSH (dans l’Imager ou en créant un fichier ssh vide à la racine de la carte SD) et configurez le Wi-Fi ou Ethernet.
2. Mettre à jour le système : Connectez-vous via SSH (ssh pi@<IP_du_Raspberry>) ou ouvrez un terminal, puis exécutez :
   bash

   sudo apt update && sudo apt full-upgrade -y

3. Configurer le stockage : Si vous utilisez un disque externe ou une carte SD volumineuse, montez-le correctement (par exemple, sous /mnt/storage) :
   bash

   sudo mkdir /mnt/storage
   sudo mount /dev/sda1 /mnt/storage

   Pour un montage automatique, ajoutez une entrée dans /etc/fstab :
   bash

   sudo nano /etc/fstab

   Ajoutez (adaptez /dev/sda1 selon votre disque) :
   /dev/sda1  /mnt/storage  ext4  defaults  0  2

Étape 2 : Installer Docker et Docker Compose

1. Installer Docker :
   bash

   sudo apt update
   sudo apt install docker.io -y
   sudo systemctl enable docker
   sudo systemctl start docker

   Ajoutez votre utilisateur au groupe Docker pour éviter d’utiliser sudo :
   bash

   sudo usermod -aG docker $USER

   Déconnectez-vous et reconnectez-vous pour appliquer les changements.
2. Installer Docker Compose :
   bash

   sudo apt install docker-compose -y

   Vérifiez les versions installées :
   bash

   docker --version
   docker-compose --version

Étape 3 : Configurer PhotoPrism avec Docker Compose

1. Créer un dossier pour le projet :
   bash

   mkdir ~/photoprism && cd ~/photoprism

2. Créer un fichier .env pour les variables sensibles : Créez un fichier pour stocker les mots de passe et configurations :
   bash

   nano .env

   Ajoutez :
   env

   PHOTOPRISM_ADMIN_PASSWORD=mon_mot_de_passe_sécurisé
   PHOTOPRISM_DB_USER=photoprism
   PHOTOPRISM_DB_PASSWORD=autre_mot_de_passe_sécurisé
   PHOTOPRISM_DB_NAME=photoprism

   Générez des mots de passe sécurisés avec :
   bash

   openssl rand -base64 12

   Protégez le fichier :
   bash

   chmod 600 .env

3. Créer le fichier docker-compose.yml :
   bash

   nano docker-compose.yml

   Collez le contenu suivant :
   yaml

   version: '3.8'
   services:
     photoprism:
       image: photoprism/photoprism:latest
       environment:
         - PHOTOPRISM_ADMIN_PASSWORD=${PHOTOPRISM_ADMIN_PASSWORD}
         - PHOTOPRISM_DB_DRIVER=mysql
         - PHOTOPRISM_DB_NAME=${PHOTOPRISM_DB_NAME}
         - PHOTOPRISM_DB_USER=${PHOTOPRISM_DB_USER}
         - PHOTOPRISM_DB_PASSWORD=${PHOTOPRISM_DB_PASSWORD}
         - PHOTOPRISM_HTTP_PORT=2342
         - PHOTOPRISM_SITE_URL=https://photos.votre-domaine.com
       ports:
         - "2342:2342"
       depends_on:
         - photoprism-db
       volumes:
         - /mnt/storage/photos:/photoprism/originals
         - /mnt/storage/photoprism/storage:/photoprism/storage
       restart: unless-stopped
   
     photoprism-db:
       image: mariadb:10.11
       environment:
         - MYSQL_ROOT_PASSWORD=${PHOTOPRISM_DB_PASSWORD}
         - MYSQL_DATABASE=${PHOTOPRISM_DB_NAME}
         - MYSQL_USER=${PHOTOPRISM_DB_USER}
         - MYSQL_PASSWORD=${PHOTOPRISM_DB_PASSWORD}
       volumes:
         - /mnt/storage/photoprism-db:/var/lib/mysql
       restart: unless-stopped

   Explications :
   • Volumes : /mnt/storage/photos contient vos photos, /mnt/storage/photoprism/storage stocke les vignettes et métadonnées, et /mnt/storage/photoprism-db contient la base de données MariaDB. Créez ces dossiers au préalable :
     bash

     sudo mkdir -p /mnt/storage/photos /mnt/storage/photoprism/storage /mnt/storage/photoprism-db

   • Ports : PhotoPrism utilise le port 2342 par défaut.
   • Variables d’environnement : Les variables sensibles sont lues depuis le fichier .env. PHOTOPRISM_ADMIN_PASSWORD définit le mot de passe de l’admin initial.
4. Lancer les conteneurs :
   bash

   docker-compose up -d

   Vérifiez que tout fonctionne :
   bash

   docker-compose ps
   docker-compose logs photoprism

5. Accéder à PhotoPrism : Ouvrez un navigateur et allez sur http://<IP_du_Raspberry>:2342. Connectez-vous avec l’utilisateur admin et le mot de passe défini dans PHOTOPRISM_ADMIN_PASSWORD. Suivez les instructions pour indexer vos photos (placez-les dans /mnt/storage/photos).

 

Étape 4 : Sécuriser l’accès

1. Configurer un reverse proxy avec Nginx : Installez Nginx :
   bash

   sudo apt install nginx -y

   Créez un fichier de configuration :
   bash

   sudo nano /etc/nginx/sites-available/photoprism

   Ajoutez :
   nginx

   server {
       listen 80;
       server_name photos.votre-domaine.com;
   
       location / {
           proxy_pass http://localhost:2342;
           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;
       }
   }

   Activez le site et redémarrez Nginx :
   bash

   sudo ln -s /etc/nginx/sites-available/photoprism /etc/nginx/sites-enabled/
   sudo systemctl restart nginx

2. Ajouter HTTPS avec Let’s Encrypt : Installez Certbot :
   bash

   sudo apt install certbot python3-certbot-nginx -y
   sudo certbot --nginx -d photos.votre-domaine.com

   Suivez les instructions pour obtenir un certificat SSL. Cela activera HTTPS automatiquement.
3. Configurer le pare-feu : Installez et configurez UFW :
   bash

   sudo apt install ufw -y
   sudo ufw allow 80
   sudo ufw allow 443
   sudo ufw enable

Étape 5 : Gestion des utilisateurs

1. Connectez-vous en tant qu’admin (http://<IP_du_Raspberry>:2342 ou https://photos.votre-domaine.com).
2. Allez dans Settings > Users et créez des comptes pour d’autres utilisateurs.
3. Pour plus de sécurité, activez l’authentification à deux facteurs (2FA) si disponible dans PhotoPrism (vérifiez les mises à jour, car cette fonctionnalité peut varier).

Étape 6 : Sauvegardes

1. Sauvegarder les volumes Docker : Créez un script de sauvegarde :
   bash

   nano backup.sh

   Ajoutez :
   bash

   #!/bin/bash
   BACKUP_DIR="/mnt/storage/backups"
   mkdir -p $BACKUP_DIR
   tar -czf $BACKUP_DIR/photos-$(date +%F).tar.gz /mnt/storage/photos
   tar -czf $BACKUP_DIR/photoprism-storage-$(date +%F).tar.gz /mnt/storage/photoprism/storage
   tar -czf $BACKUP_DIR/photoprism-db-$(date +%F).tar.gz /mnt/storage/photoprism-db

   Rendez-le exécutable et planifiez-le avec cron :
   bash

   chmod +x backup.sh
   crontab -e

   Ajoutez pour une sauvegarde quotidienne à 2h du matin :
   0 2 * * * /home/pi/photoprism/backup.sh

2. Stocker les sauvegardes à distance (optionnel) : Utilisez rsync pour envoyer les sauvegardes vers un NAS ou un cloud :
   bash

   rsync -av /mnt/storage/backups user@remote-server:/path/to/backups

Étape 7 : Optimiser les fonctionnalités IA

• Performances : Un Raspberry Pi 4 avec 8 Go de RAM est recommandé. Si l’indexation est trop lente, réduisez la qualité des vignettes dans les paramètres de PhotoPrism.
• Accélération matérielle : Si vous avez un Coral TPU ou un GPU externe, configurez-les selon la documentation de PhotoPrism.
• Désactiver l’IA : Si nécessaire, désactivez les fonctionnalités IA dans les paramètres pour économiser des ressources.

• Vérifier les logs :
  bash

  docker-compose logs photoprism

• Redémarrer les services :
  bash

  docker-compose restart

• Problèmes de mémoire : Surveillez avec htop. Si nécessaire, ajoutez un fichier swap :
  bash

  sudo fallocate -l 2G /swapfile
  sudo chmod 600 /swapfile
  sudo mkswap /swapfile
  sudo swapon /swapfile