Esegui il backup degli eventi Partoska su Raspberry Pi
Immagina che la tua società organizzi un evento ogni sabato. Gli ospiti aggiungono foto a Partoska, ma nessuno ricorda di esportarle prima che l'evento successivo assorba l'attenzione di tutti. Un backup delle foto con Raspberry Pi può risolvere il problema in silenzio: lascia il Pi accanto a un SSD esterno, esegui un comando ogni notte e lascia che raccolga le nuove foto mentre dormi.
La configurazione finale ha una semplice divisione dei compiti. Partoska raccoglie dagli ospiti le foto tramite un codice QR. Raspberry Pi conserva una copia locale su uno spazio che controlli tu. Quando un file ha raggiunto l'unità esterna, la sua successiva eliminazione da Partoska non rimuove la copia locale.
Questa guida parte da una scheda microSD vuota. Descrive l'installazione di Raspberry Pi OS su Windows, macOS e Linux, la preparazione di un'unità esterna, l'installazione di p6a, l'accesso OAuth e la creazione di un processo cron giornaliero.
Cosa ti serve?
Usa un Raspberry Pi che supporti un sistema operativo a 64 bit. Pi 3, Pi 4, Pi 5 o Zero 2 W hanno potenza sufficiente; un modello precedente a 32 bit non può eseguire l'attuale build ARM64 ufficiale di p6a.
Ti serviranno inoltre:
- Una scheda microSD. Raspberry Pi consiglia almeno 16 GB per Raspberry Pi OS Lite, anche se una scheda da 32 GB lascia più spazio a log e aggiornamenti di sistema.
- Un alimentatore adatto al Pi.
- Un SSD esterno, un disco rigido o un'unità flash USB abbastanza capiente per l'archivio.
- Un lettore di schede microSD per il computer che preparerà la scheda.
- Una connessione Ethernet o Wi-Fi.
Un SSD è l'unità esterna meno problematica. Alcuni dischi rigidi portatili assorbono più energia di quella che una porta USB del Raspberry Pi riesce a fornire in modo affidabile; se il disco si scollega sotto carico, usa un hub USB alimentato o un'unità dotata di alimentatore proprio.
Scrivi Raspberry Pi OS sulla scheda microSD
Il vecchio nome «Raspbian» compare ancora nei tutorial, ma il sistema operativo attuale si chiama Raspberry Pi OS. Usa Raspberry Pi Imager invece di formattare manualmente la scheda. Imager cancella il dispositivo selezionato, scrive le partizioni e verifica il risultato nello stesso flusso.
Installa Raspberry Pi Imager sul computer collegato al lettore:
- Su Windows, scarica il programma di installazione per Windows dalla pagina del software Raspberry Pi ed eseguilo.
- Su macOS, scarica il programma di installazione per macOS e aprilo normalmente.
- Su Linux, scarica la build x86_64 ufficiale. Chi usa Debian o Ubuntu può anche installarla con
sudo apt install rpi-imagerse il pacchetto è disponibile nella distribuzione.
Le schermate di Imager sono uguali su tutti e tre i sistemi:
- Seleziona il modello di Raspberry Pi.
- Scegli Raspberry Pi OS Lite (64-bit). Un ambiente desktop non aggiunge nulla a un dispositivo che resterà accanto a un disco e verrà gestito tramite SSH.
- Seleziona la scheda microSD come dispositivo di archiviazione.
- Apri la personalizzazione del sistema operativo prima di scrivere l'immagine.
Imposta un nome host come partoska-backup, crea nome utente e password, configura il Wi-Fi se non usi Ethernet e scegli il fuso orario corretto. Nella sezione Servizi, abilita SSH. Se usi già chiavi SSH, è preferibile l'autenticazione con chiave pubblica; per la prima configurazione su una rete domestica fidata va bene anche la password.
Controlla ancora una volta il dispositivo selezionato prima di premere Scrivi. Imager lo cancellerà. Scollegare prima gli altri dischi USB è un modo semplice per evitare di scegliere quello sbagliato.
Attendi il completamento della verifica, espelli la scheda, inseriscila nel Raspberry Pi e collega l'unità esterna. Accendi il Pi e attendi uno o due minuti affinché si connetta alla rete.
Collegati tramite SSH e aggiorna il Pi
Dal Terminale su macOS o Linux, oppure da PowerShell su Windows, collegati con il nome utente creato in Imager:
ssh your-user@partoska-backup.local
Se l'indirizzo .local non viene risolto, trova l'indirizzo IP del Pi nel router e usa quello:
ssh your-user@192.168.1.50
Aggiorna Raspberry Pi OS prima di installare altro:
sudo apt update sudo apt full-upgrade -y sudo reboot
Dopo il riavvio, ricollegati e conferma che il sistema operativo sia a 64 bit:
uname -m
Il risultato previsto è aarch64. Se compare armv7l, il Pi esegue un'immagine a 32 bit; riscrivi la scheda con Raspberry Pi OS Lite (64-bit) prima di continuare.
Prepara l'unità esterna
Un backup su unità esterna con Raspberry Pi affidabile parte da un punto di montaggio fisso. Collega l'unità ed elenca i dispositivi disponibili:
lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINTS,MODEL
Usa dimensione, modello ed etichetta per identificare la partizione esterna. Gli esempi seguenti usano /dev/sda1, ma il tuo Pi potrebbe chiamarla /dev/sdb1 o in altro modo. La microSD compare solitamente come /dev/mmcblk0: non formattarla.
Se l'unità esterna contiene già file che vuoi conservare, salta il comando di formattazione. Copia quei file in un luogo sicuro prima di cambiare il filesystem.
Per un disco che rimarrà collegato al Pi, ext4 è la scelta più sensata:
sudo mkfs.ext4 -L PARTOSKA /dev/sda1
Questo comando cancella la partizione selezionata. Controlla di nuovo lsblk prima di eseguirlo. Se intendi scollegare l'unità e leggerla direttamente su Windows o macOS, formattala invece come exFAT:
sudo apt install -y exfatprogs sudo mkfs.exfat -n PARTOSKA /dev/sda1
Anche il comando di formattazione exFAT cancella la partizione.
Crea un punto di montaggio fisso e trova l'UUID della partizione:
sudo mkdir -p /mnt/partoska sudo blkid /dev/sda1
Esegui il backup della tabella dei filesystem prima di modificarla:
sudo cp /etc/fstab /etc/fstab.before-partoska sudo nano /etc/fstab
Aggiungi una riga alla fine, sostituendo l'UUID di esempio con il valore mostrato da blkid:
UUID=12345678-1234-1234-1234-123456789abc /mnt/partoska ext4 defaults,nofail,x-systemd.device-timeout=10 0 2
Per exFAT, cambia il tipo di filesystem in exfat e imposta uid e gid sui numeri mostrati da id -u e id -g, solitamente 1000 per il primo utente:
UUID=1234-ABCD /mnt/partoska exfat defaults,nofail,x-systemd.device-timeout=10,uid=1000,gid=1000,umask=0022 0 0
In Nano, premi Ctrl+O per salvare, poi Enter per confermare il nome del file. Premi Ctrl+X per chiudere l'editor. Nano mostra queste scorciatoie come ^O e ^X; l'accento circonflesso rappresenta il tasto Ctrl.
Monta tutto ciò che è dichiarato nel file e conferma che sia presente il dispositivo previsto:
sudo mount -a findmnt /mnt/partoska
Un controllo findmnt riuscito appare simile a questo:
TARGET SOURCE FSTYPE OPTIONS /mnt/partoska /dev/sda1 ext4 rw,relatime
TARGET deve essere /mnt/partoska, mentre SOURCE dovrebbe indicare la partizione esterna identificata in precedenza. Non continuare se findmnt non mostra nulla o indica la partizione di sistema della microSD. Correggi prima l'UUID o il tipo di filesystem.
Crea la directory delle foto e concedi al tuo account normale il permesso di usarla:
sudo mkdir -p /mnt/partoska/events sudo chown "$USER":"$USER" /mnt/partoska/events touch /mnt/partoska/events/.write-test unlink /mnt/partoska/events/.write-test
Salta il comando chown su exFAT; le opzioni di montaggio uid e gid assegnano già la proprietà.
Gli esempi successivi di installazione e cron funzionano con entrambi i filesystem una volta montati in /mnt/partoska. La documentazione di Raspberry Pi sui dispositivi di archiviazione esterni descrive ulteriori opzioni per unità exFAT e NTFS.
Installa p6a
p6a è lo strumento open source da riga di comando di Partoska. La release attuale offre un file binario Linux ARM64, quindi p6a su Raspberry Pi funziona senza doverlo compilare. Scegli un solo metodo di installazione; non servono tutti e tre.
Opzione A: scarica il file binario ARM64 con wget
È il percorso più leggero per un Pi dedicato al backup, perché non installa Node.js né un altro gestore di pacchetti. La versione seguente era quella attuale alla pubblicazione dell'articolo; consulta la pagina delle release di p6a per verificare se ne esiste una più recente.
sudo apt install -y wget ca-certificates P6A_VERSION="1.11.5" wget "https://github.com/partoska/p6a-cmd/releases/download/v${P6A_VERSION}/p6a_${P6A_VERSION}_linux_arm64" -O p6a sudo install -m 0755 p6a /usr/local/bin/p6a p6a version
Opzione B: installa tramite npm
Raspberry Pi OS non include necessariamente npm. Installa prima Node.js e npm, quindi installa il pacchetto p6a specifico per la piattaforma:
sudo apt update sudo apt install -y nodejs npm sudo npm install -g @partoska/p6a p6a version
Opzione C: usa Homebrew su Linux
Homebrew supporta Linux ARM64 e la formula Partoska seleziona il file binario corretto per Raspberry Pi. Se Homebrew è già presente sul Pi, basta un comando:
brew install partoska/tap/p6a p6a version
Per i comandi precedenti, p6a version dovrebbe mostrare p6a v1.11.5, oppure una versione più recente se nel frattempo ne è stata pubblicata una. Un Exec format error indica di solito che il Pi esegue un sistema operativo a 32 bit oppure che è stato scaricato il file binario sbagliato.
Installare Homebrew soltanto per p6a è un lavoro inutile. Richiede strumenti di compilazione e un proprio albero di directory, mentre il file binario diretto svolge lo stesso compito. Homebrew rimane una buona scelta se lo usi già per gestire altro software sul Pi.
Qualunque percorso tu abbia scelto, annota il percorso esatto del file binario. Lo script cron ne avrà bisogno in seguito:
command -v p6a
Il download diretto mostra normalmente /usr/local/bin/p6a. Homebrew su Linux mostra solitamente un percorso sotto /home/linuxbrew/.linuxbrew/bin.
Accedi tramite OAuth
Esegui l'accesso con il tuo account normale, senza sudo:
p6a login
Il comando mostra un URL di autorizzazione. Aprilo in un browser, normalmente sul computer da cui ti sei collegato tramite SSH, quindi accedi a Partoska e approva l'accesso. Alla fine del flusso OAuth2 con codice di autorizzazione, il browser mostra un codice; copialo negli appunti e incollalo nel prompt di p6a in attesa. Il browser non deve essere eseguito sul Raspberry Pi.
p6a salva le credenziali nel tuo account utente, per impostazione predefinita in ~/.p6a. Il processo cron deve essere eseguito come lo stesso utente. Accedere con sudo p6a login salverebbe invece le credenziali di root, impedendo al processo dell'utente normale di autenticarsi.
Verifica la connessione:
p6a list
Dovresti vedere gli eventi Partoska disponibili per il tuo account.
Esegui manualmente il primo backup
Prima di affidarti a un backup automatico delle foto su Raspberry Pi, dimostra che l'intero percorso funzioni:
mountpoint -q /mnt/partoska && echo "External drive mounted" p6a sync -t /mnt/partoska/events --owner-only find /mnt/partoska/events -maxdepth 2 -type f | head df -h /mnt/partoska
Il primo comando dovrebbe mostrare:
External drive mounted
Se non mostra nulla, fermati. L'unità esterna non è montata nel percorso previsto. Il comando di sincronizzazione dovrebbe terminare senza errori di autenticazione, rete o filesystem; l'output esatto dipende dal numero di eventi e nuovi file trovati.
Il comando find mostra quindi fino a dieci percorsi dei file scaricati. Un risultato reale apparirà simile a questo:
/mnt/partoska/events/2026-07-18 Summer Match/.event.p6a.ini /mnt/partoska/events/2026-07-18 Summer Match/IMG_0001.jpg /mnt/partoska/events/2026-07-18 Summer Match/IMG_0002.jpg /mnt/partoska/events/2026-07-18 Summer Match/MOV_0001.mp4
p6a crea una cartella per ogni evento nel formato YYYY-MM-DD Event Name. Le immagini ricevono nomi come IMG_0001.jpg, mentre i video usano MOV_0001.mp4. Il file nascosto .event.p6a.ini registra quali ID dell'evento e dei contenuti multimediali Partoska appartengono alla cartella; lascialo al suo posto. head limita la visualizzazione a dieci percorsi, quindi questo comando serve per un rapido controllo e non per contare i file.
Infine, df dovrebbe mostrare la partizione esterna montata in /mnt/partoska. Le capacità saranno diverse, ma contano l'ultima colonna e il filesystem:
Filesystem Size Used Avail Use% Mounted on /dev/sda1 916G 18G 852G 3% /mnt/partoska
Size, Used e Avail mostrano lo spazio totale, occupato e disponibile dell'unità. Il filesystem dovrebbe corrispondere alla partizione esterna identificata con lsblk, per esempio /dev/sda1. Se il comando mostra /dev/mmcblk0p2, /dev/root o un'altra partizione di sistema della microSD, fermati: l'unità USB non è montata e le foto finirebbero sulla scheda di sistema del Raspberry Pi.
Dopo questi controlli, esegui una seconda volta il comando di sincronizzazione. Dovrebbe saltare i file già registrati localmente e recuperare soltanto quelli nuovi.
Scegli quali eventi sincronizzare
Il comando principale accetta due filtri per gli eventi:
# Every event the account can access p6a sync -t /mnt/partoska/events # Only events created by this account p6a sync -t /mnt/partoska/events --owner-only # Only events marked as favourites p6a sync -t /mnt/partoska/events --favorite-only # Events that are both owned and marked as favourites p6a sync -t /mnt/partoska/events -o -f
L'opzione breve -f indica gli eventi preferiti. Non indica le foto preferite all'interno di un evento. Per un Raspberry Pi appartenente a una società o a una location, --owner-only è un'impostazione predefinita sensata perché evita di archiviare eventi estranei a cui qualcuno ha partecipato come ospite.
Proteggi il backup con un controllo
Una semplice riga cron che richiama p6a sync ha una brutta modalità di errore. Se l'unità esterna è assente ma /mnt/partoska esiste ancora come directory normale, Linux può scrivere i download sulla microSD. Un numero sufficiente di video la riempirà.
Usa un piccolo script che si rifiuti di partire se il disco esterno non è montato. Crea una directory bin personale:
mkdir -p "$HOME/bin" nano "$HOME/bin/partoska-backup.sh"
Incolla questo script, adattando P6A_BIN al percorso restituito da command -v p6a:
#!/usr/bin/env bash set -euo pipefail P6A_BIN="/usr/local/bin/p6a" MOUNT_POINT="/mnt/partoska" TARGET="${MOUNT_POINT}/events" if ! /usr/bin/mountpoint -q "$MOUNT_POINT"; then echo "External drive is not mounted at $MOUNT_POINT" >&2 exit 1 fi if [[ ! -x "$P6A_BIN" ]]; then echo "p6a is not executable at $P6A_BIN" >&2 exit 1 fi mkdir -p "$TARGET" "$P6A_BIN" sync -t "$TARGET" --owner-only
Salva e chiudi l'editor.
Rendilo eseguibile ed eseguilo manualmente una volta:
chmod 700 "$HOME/bin/partoska-backup.sh" "$HOME/bin/partoska-backup.sh"
Il permesso 700 indica che soltanto il proprietario può leggere, modificare o eseguire lo script. Se anche un gruppo Linux fidato deve poterlo leggere ed eseguire, usa invece chmod 750: il proprietario ottiene lettura, scrittura ed esecuzione, il gruppo lettura ed esecuzione, tutti gli altri nessun accesso.
Non pianificare uno script che non supera questa prova manuale.
Pianifica il processo cron giornaliero
Ora il backup cron con Raspberry Pi può richiamare lo script protetto. Assicurati che il servizio cron esista e venga avviato all'accensione:
sudo apt install -y cron sudo systemctl enable --now cron
Apri il crontab del tuo utente:
crontab -e
Aggiungi questa riga per eseguire il backup ogni giorno alle 03:15 nel fuso orario configurato sul Pi:
15 3 * * * "$HOME/bin/partoska-backup.sh" >> "$HOME/partoska-backup.log" 2>&1
Salva e chiudi l'editor, quindi verifica che cron abbia accettato la voce:
crontab -l
Il comando dovrebbe mostrare la pianificazione salvata:
15 3 * * * "$HOME/bin/partoska-backup.sh" >> "$HOME/partoska-backup.log" 2>&1
Dopo la prima esecuzione pianificata, controlla il log e l'unità:
tail -n 50 "$HOME/partoska-backup.log" findmnt /mnt/partoska df -h /mnt/partoska
Cron non riprova alle 03:16 se il Pi era spento alle 03:15. Qui non è un problema: la successiva sincronizzazione riuscita recupera i file non ancora scaricati. Esegui manualmente lo script dopo una lunga interruzione se non vuoi aspettare la notte seguente.
Cosa succede quando una foto viene eliminata da Partoska?
p6a sync è un download unidirezionale e incrementale, non una copia speculare esatta. Scarica i file online mancanti e salta quelli già presenti sull'unità esterna. Non rimuove una foto locale soltanto perché quella foto, o l'intero evento, non compare più online.
La distinzione è importante. Dopo che il processo notturno ha scaricato una foto, eliminarla da Partoska non tocca la copia sul Raspberry Pi. Una foto eliminata prima della prima sincronizzazione riuscita non può essere recuperata da p6a, quindi mantieni il Pi in funzione durante la finestra di conservazione dell'evento.
Rinominare un evento è diverso dall'eliminarlo. Se un evento online riceve un nuovo nome, p6a può rinominare la cartella locale mantenendo al suo interno i contenuti già scaricati.
Un disco esterno accanto a un Raspberry Pi rimane comunque un solo disco, e i dischi si rompono. Per le foto insostituibili, copia l'archivio anche su un'altra unità o in una destinazione esterna.
Partoska continua a gestire il lato rivolto agli ospiti
Nulla in questa configurazione cambia il modo in cui le persone contribuiscono. Gli ospiti scansionano il codice QR dell'evento e caricano tramite il browser; non vedono Raspberry Pi, p6a o cron. Il Pi gestisce soltanto l'archivio dell'organizzatore dopo l'arrivo dei file su Partoska.
L'app web rimane disponibile anche per creare eventi, moderare e sfogliare. Questo flusso di backup Partoska è utile quando le copie locali devono essere eseguite regolarmente senza un altro promemoria. Se vuoi anche creare eventi, generare codici QR o lavorare dal terminale con un assistente IA, leggi la relativa guida alla CLI e all'IA di Partoska.
I piccoli eventi possono provare l'intera configurazione con il piano gratuito; i limiti di spazio e conservazione dipendono dal piano.
Poi verifica la sincronizzazione manuale e lascia al Pi il turno di notte.
FAQ
Quale Raspberry Pi dovrei usare per il backup delle foto Partoska?
Usa un modello in grado di eseguire Raspberry Pi OS a 64 bit, come Pi 3, Pi 4, Pi 5 o Zero 2 W. L'attuale release Raspberry Pi di p6a usa ARM64. Pi 4 o Pi 5 con un SSD esterno offrono la configurazione meno problematica, ma la sincronizzazione delle foto non richiede molta potenza di calcolo.
Il Raspberry Pi deve rimanere acceso tutto il giorno?
No. Deve avere alimentazione, accesso alla rete e unità esterna disponibile all'orario pianificato. Lasciarlo acceso è più semplice e consuma poca elettricità. Se salta un'esecuzione, la sincronizzazione successiva scarica i file non ancora presenti localmente.
Cosa scarica p6a sync -f?
Scarica gli eventi che hai contrassegnato come preferiti. Non limita il download alle foto preferite all'interno di quegli eventi. Combina -f con -o se vuoi gli eventi che sono sia tuoi sia preferiti.
Cron riempirà la microSD se l'unità USB si scollega?
Lo script di questa guida controlla mountpoint prima di avviarsi. Se il disco esterno manca, termina con un errore e non scrive nulla. Non rimuovere questo controllo.
Le foto eliminate da Partoska rimangono sul Raspberry Pi?
Sì, purché p6a le abbia scaricate prima dell'eliminazione online. La sincronizzazione non rimuove i file locali per allinearsi alle eliminazioni remote. Se una foto è scomparsa prima che il Pi la copiasse, non è mai arrivata nell'archivio locale.
Posso collegare direttamente l'unità di archivio a Windows o macOS?
Usa exFAT se è importante accedere regolarmente e direttamente da tutti e tre i sistemi operativi. Usa ext4 se il disco rimarrà sul Pi; accedi ai file tramite SSH, SFTP o una condivisione di rete.
Posso continuare a usare l'app web di Partoska?
Sì. Crea e modera gli eventi nell'app web quando è più comodo. p6a usa lo stesso account e gli stessi eventi, aggiungendo l'accesso da terminale e i download locali pianificati.