Automatischer SD-Karten Import auf dein NAS mit Telegram-Benachrichtigung

18.05.2026 Allgemein
#Ubuntu #SAMBA #Automatisierung #Fotos #Videos #NAS #Telegram #udev

SD-Karte einstecken und fünf Minuten später liegt alles sortiert auf dem NAS. Anleitung für automatischen Import mit Ubuntu, Samba, udev und Telegram-Benachrichtigung.

Anleitung personalisieren

Trage Benutzername, NAS-Pfad und Share-Name ein, damit die Befehle und Konfiguration direkt zu deinem Setup passen.

Du kommst vom Shooting nach Hause, steckst die SD-Karte in den Slot – und fünf Minuten später liegt alles sauber sortiert auf deinem NAS. Kein manuelles Kopieren, kein Vergessen, kein Chaos. In dieser Anleitung bauen wir genau das: einen vollautomatischen SD-Karten Import auf einem Intel NUC mit Ubuntu 24.04, Samba-Share und Telegram-Benachrichtigungen.

Was du brauchst:

  • Intel NUC oder ähnlicher Mini-PC mit Ubuntu 24.04
  • SD-Karten Slot (intern oder extern über USB)
  • Telegram Account

Was wir bauen:

  • Samba NAS Share im Heimnetzwerk
  • udev-Regel die die SD-Karte automatisch erkennt
  • Import-Script das Clips, Fotos und Thumbnails sortiert
  • Telegram Bot der dich über Start und Ende informiert

1. Samba Share einrichten

Zuerst richten wir den Samba-Share ein, damit das NAS im Heimnetzwerk erreichbar ist. Installiere zunächst Samba:

sudo apt update && sudo apt upgrade -y
sudo apt install samba -y

Erstelle das Verzeichnis für deine Fotos und setze die Berechtigungen. Ersetze neyer durch deinen eigenen Linux-Benutzernamen:

sudo mkdir -p /nas/fotos
sudo chown neyer:neyer /nas/fotos
sudo chmod 755 /nas/fotos

Sichere die bestehende Samba-Konfiguration und öffne sie zur Bearbeitung:

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak
sudo nano /etc/samba/smb.conf

Füge am Ende der Datei folgenden Block hinzu. Der Share-Name NAS-Fotos ist der Name, unter dem der Ordner im Netzwerk erscheint:

[NAS-Fotos]
   path = /nas/fotos
   browseable = yes
   read only = no
   guest ok = no
   valid users = neyer
   create mask = 0644
   directory mask = 0755

Lege ein Samba-Passwort für deinen Benutzer fest und starte den Dienst:

sudo smbpasswd -a neyer
sudo systemctl restart smbd nmbd
sudo systemctl enable smbd nmbd

Verbinde dich nun von einem anderen Gerät im selben Netzwerk:

  • Mac: Cmd+K → smb://IP-DES-NUC/NAS-Fotos
  • Windows: \\IP-DES-NUC\NAS-Fotos

Die IP-Adresse deines NUC findest du mit:

ip a | grep "inet " | grep -v 127

2. SD-Karte identifizieren

Bevor wir die Automatisierung einrichten, müssen wir wissen, wie das System die SD-Karte benennt. Stecke die Karte ein und prüfe den Gerätenamen:

lsblk

In der Ausgabe siehst du das Gerät – typischerweise mmcblk0 für interne SD-Slots mit der Partition mmcblk0p1. Für detaillierte udev-Informationen:

udevadm info --name=/dev/mmcblk0p1 --query=all

Sony-Kameras formatieren ihre Karten üblicherweise als exFAT. Installiere den Support dafür und erstelle den Mount-Punkt:

sudo apt install exfatprogs -y
sudo mkdir -p /mnt/sd-import

3. Import-Script erstellen

Das Herzstück der Automatisierung ist ein Bash-Script, das folgendes erledigt:

  • SD-Karte einhängen
  • Kamera-Thumbnails (*T01.JPG) direkt löschen
  • Clips (.MP4, .MTS, .MOV) in den Ordner DATUM/Clips/ kopieren
  • Fotos (.ARW, .JPG und andere RAW-Formate) in den Ordner DATUM/Fotos/ kopieren
  • Duplikate erkennen und überspringen
  • Berechtigungen korrekt setzen
  • Telegram-Benachrichtigungen über Start und Abschluss senden

Erstelle das Script:

sudo nano /usr/local/bin/sd-import.sh

Füge folgenden Inhalt ein. Token und Chat-ID trägst du im nächsten Schritt ein, der Benutzername neyer muss deinem Linux-Benutzer entsprechen:

#!/bin/bash

MOUNT_POINT="/mnt/sd-import"
NAS_PATH="/nas/fotos"
LOG_FILE="/var/log/sd-import.log"
TELEGRAM_TOKEN="DEIN_BOT_TOKEN"
TELEGRAM_CHAT_ID="DEINE_CHAT_ID"
DEVICE="$1"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

send_telegram() {
    curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage" \
        -d chat_id="${TELEGRAM_CHAT_ID}" \
        -d text="$1" > /dev/null
}

log "=== SD-Import gestartet fuer $DEVICE ==="
send_telegram "SD-Import gestartet: $DEVICE"

if ! mountpoint -q "$MOUNT_POINT"; then
    mount -t exfat "$DEVICE" "$MOUNT_POINT" 2>>"$LOG_FILE"
    if [ $? -ne 0 ]; then
        log "FEHLER: Mount fehlgeschlagen"
        send_telegram "SD-Import fehlgeschlagen: Mount-Fehler bei $DEVICE"
        exit 1
    fi
fi

log "SD-Karte eingehaengt"

IMPORTED=0
SKIPPED=0
DELETED=0

while IFS= read -r -d '' file; do
    rm -f "$file"
    ((DELETED++))
done < <(find "$MOUNT_POINT" -type f -iname "*T01.JPG" -print0)

log "Thumbnails geloescht: $DELETED"

while IFS= read -r -d '' file; do
    filename=$(basename "$file")
    ext="${filename##*.}"
    ext_upper="${ext^^}"

    date_str=$(date -r "$file" "+%Y-%m-%d")

    case "$ext_upper" in
        MP4|MTS|MOV)
            target_dir="$NAS_PATH/$date_str/Clips"
            ;;
        ARW|CR2|CR3|NEF|RAF|JPG|JPEG|PNG)
            target_dir="$NAS_PATH/$date_str/Fotos"
            ;;
        *)
            log "Uebersprungen (unbekanntes Format): $filename"
            ((SKIPPED++))
            continue
            ;;
    esac

    mkdir -p "$target_dir"

    if [ -f "$target_dir/$filename" ]; then
        log "Bereits vorhanden, uebersprungen: $filename"
        ((SKIPPED++))
        continue
    fi

    cp "$file" "$target_dir/$filename"
    chmod 644 "$target_dir/$filename"
    log "Importiert: $filename -> $date_str"
    ((IMPORTED++))

done < <(find "$MOUNT_POINT" -type f \( \
    -iname "*.MP4" -o -iname "*.MTS" -o -iname "*.MOV" \
    -o -iname "*.ARW" -o -iname "*.CR2" -o -iname "*.CR3" \
    -o -iname "*.NEF" -o -iname "*.RAF" \
    -o -iname "*.JPG" -o -iname "*.JPEG" -o -iname "*.PNG" \) -print0)

chown -R neyer:neyer "$NAS_PATH"
find "$NAS_PATH" -type d -exec chmod 755 {} \;

umount "$MOUNT_POINT"
log "SD-Karte ausgehaengt"

log "Abgeschlossen: $IMPORTED importiert, $SKIPPED uebersprungen, $DELETED Thumbnails geloescht"
send_telegram "SD-Import abgeschlossen
Importiert: $IMPORTED
Uebersprungen: $SKIPPED
Thumbnails geloescht: $DELETED"

Mache das Script ausführbar und prüfe die Syntax:

sudo chmod +x /usr/local/bin/sd-import.sh
bash -n /usr/local/bin/sd-import.sh && echo "Syntax OK"

4. Telegram Bot einrichten

Damit das Script Benachrichtigungen senden kann, brauchst du einen Telegram Bot. Die Einrichtung dauert wenige Minuten:

  • Öffne @BotFather in Telegram
  • Sende /newbot und vergib einen Namen sowie einen Benutzernamen (muss auf bot enden)
  • Kopiere den angezeigten API Token

Für die Chat-ID schickst du deinem neuen Bot zunächst eine beliebige Nachricht, dann rufst du folgende URL im Browser auf – ersetze DEIN_TOKEN durch deinen echten Token:

https://api.telegram.org/botDEIN_TOKEN/getUpdates

In der JSON-Antwort findest du unter result[0].message.chat.id deine Chat-ID. Trage Token und Chat-ID nun in das Script unter TELEGRAM_TOKEN und TELEGRAM_CHAT_ID ein.

Teste den Bot direkt aus der Kommandozeile:

curl -s -X POST "https://api.telegram.org/botDEIN_TOKEN/sendMessage" \
  -d chat_id="DEINE_CHAT_ID" \
  -d text="Bot funktioniert!"

Eine Antwort mit "ok":true bestätigt, dass alles korrekt eingerichtet ist.

5. udev-Regel einrichten

udev ist das Linux-Subsystem, das Hardware-Events verwaltet. Wir richten eine Regel ein, die beim Einstecken der SD-Karte automatisch unser Import-Script startet.

Da udev-Regeln keine lang laufenden Prozesse direkt starten dürfen, verwenden wir ein Wrapper-Script mit systemd-run:

sudo nano /usr/local/bin/sd-import-wrapper.sh
#!/bin/bash
systemd-run --no-block /usr/local/bin/sd-import.sh "$1"
sudo chmod +x /usr/local/bin/sd-import-wrapper.sh

Jetzt die eigentliche udev-Regel. Der KERNEL-Wert muss mit dem Gerätenamen übereinstimmen, den du in Schritt 2 ermittelt hast:

sudo nano /etc/udev/rules.d/99-sd-import.rules
ACTION=="add", KERNEL=="mmcblk0p1", SUBSYSTEM=="block", RUN+="/usr/local/bin/sd-import-wrapper.sh /dev/mmcblk0p1"

Regeln neu laden, damit die Änderung sofort wirksam ist:

sudo udevadm control --reload-rules

6. Testen

Vor dem ersten echten Einsatz testest du das Script manuell mit einer eingesteckten SD-Karte:

sudo /usr/local/bin/sd-import.sh /dev/mmcblk0p1

Beobachte den Log in Echtzeit:

tail -f /var/log/sd-import.log

Nach erfolgreichem Testlauf steckst du die SD-Karte aus und wieder ein. Innerhalb weniger Sekunden sollte eine Telegram-Nachricht ankommen, und nach Abschluss die Zusammenfassung mit Anzahl der importierten Dateien.

Die fertige Ordnerstruktur auf dem NAS sieht dann so aus:

/nas/fotos/
  2026-05-16/
    Clips/
      C0089.MP4
    Fotos/
      DSC01016.ARW
      DSC01016.JPG
  2026-04-07/
    Clips/
      C0050.MP4
    Fotos/
      DSC00997.ARW
      DSC00997.JPG

SD-Karte einstecken – Telegram Nachricht – Kaffee holen – fertig.

7. Troubleshooting

Falls etwas nicht funktioniert, sind hier die häufigsten Probleme und Lösungen:

  • SD-Karte wird nicht erkannt: lsblk prüfen, Kernel-Name in der udev-Regel anpassen
  • Mount schlägt fehl: sudo fdisk -l für den korrekten Partitionsnamen ausführen, und prüfen ob exfatprogs installiert ist
  • Telegram sendet nicht: Token und Chat-ID im Script prüfen, curl-Test aus Schritt 4 wiederholen
  • Script startet nicht automatisch: journalctl -f beim Einstecken beobachten, Wrapper-Script und udev-Regel-Syntax prüfen
  • Berechtigungsfehler beim Kopieren: Benutzername in der chown-Zeile am Ende des Scripts prüfen und anpassen

Weiterführende Anleitungen