MinIO su VPS: storage a oggetti self-hosted

Cosa offre lo storage a oggetti self-hosted con MinIO

MinIO è uno storage a oggetti self-hosted che supporta l'API Amazon S3. Configurate restic o un SDK S3 per usare il vostro server, modificate un'impostazione dell'endpoint e, per le operazioni quotidiane di lettura, scrittura ed elenco degli oggetti e per i link presigned, non serve altro. Compatibile non significa però identico. Per esempio, MinIO non implementa le ACL degli oggetti Amazon e i suoi manutentori hanno dichiarato di non avere intenzione di farlo. Un'applicazione che dipende dal comportamento delle ACL richiede quindi più della semplice modifica dell'endpoint. Questa guida crea un nodo singolo su Ubuntu 24.04: un binario compilato da codice sorgente verificato, un utente di sistema dedicato, un'unità systemd che mantiene le credenziali root fuori dal file dell'unità e un bucket in cui restic esegue i backup.

S3 (simple storage service) è un'API HTTP, non un filesystem. Inserite un oggetto in un bucket usando una chiave con PUT e recuperatelo con GET; in un bucket standard non esistono scritture parziali né operazioni di rinomina. I bucket directory di Amazon S3 Express One Zone fanno eccezione e dispongono di proprie operazioni di aggiunta e rinomina, ma si tratta di una classe di storage specifica e nulla in questa guida dipende da essa. Gli strumenti di backup preferiscono il modello standard, perché un oggetto è arrivato completamente oppure non è arrivato.

Un nodo conserva una sola copia dei dati. Questo è il compromesso che state accettando. Ottenete un endpoint S3 sotto il vostro controllo al costo di un VPS, ma vi fate carico anche di tutte le attività che prima svolgeva il provider cloud, dalla sostituzione di un disco guasto all'applicazione delle patch al software del server. La sezione verso la fine spiega chiaramente quando questo compromesso è una scelta adeguata.

Lo stato della community edition di MinIO a ottobre 2026

Leggere questa sezione prima di procedere, perché la situazione è cambiata di recente. A maggio 2025 MinIO ha rimosso le funzioni di amministrazione dalla console web della community edition. Nel browser rimane un object browser; bucket e access key vengono quindi gestiti con il client a riga di comando mc.

Più avanti, nel 2025, MinIO ha smesso di pubblicare i binari precompilati della community edition. Il README del progetto indica che la community edition viene distribuita solo come codice sorgente e, da aprile 2026, il repository minio/minio è stato archiviato con l'avviso THIS REPOSITORY IS NO LONGER MAINTAINED. Anche il vecchio server di download ha smesso di distribuire i file della community edition. Alla verifica del 20 ottobre 2026, ogni percorso dl.min.io utilizzato in precedenza da questa guida per scaricare il binario del server, il binario del client e i relativi file checksum risponde con 410 Gone. Si tratta di una rimozione deliberata, non di un'interruzione del servizio. L'unico binario mc ancora presente su quel server è AIStor Client, disponibile all'indirizzo /aistor/mc/release/, che appartiene alla linea commerciale. La pagina dei download di min.io elenca ora AIStor Server, AIStor Client, AIStor SDK e alcuni componenti aggiuntivi AIStor, oltre a un livello gratuito di AIStor descritto come destinato a sviluppatori, ricercatori e piccole organizzazioni che gestiscono deployment standalone. Non è disponibile alcuna build della community edition.

Il codice sorgente è ancora disponibile ed è più recente dell'ultimo binario. L'ultima release della community edition è RELEASE.2025-10-15T17-29-55Z, pubblicata il 16 ottobre 2025 come release di sicurezza: corregge un'escalation dei privilegi dovuta all'aggiramento delle policy di sessione negli account di servizio e in STS. Le note di rilascio raccomandano a tutti gli utenti di eseguire immediatamente l'upgrade. L'ultimo binario precompilato era la build di settembre 2025, quindi non includeva questa correzione. Questa guida compila la release di ottobre e, poiché il repository è archiviato, anche questa è l'ultima correzione che la community edition riceverà.

Questo singolo fatto determina il resto della guida. Per questo MinIO rimane in ascolto su 127.0.0.1 e raggiunge Internet solo tramite un proxy sotto il tuo controllo.

Installare il binario MinIO e verificare il download

MinIO è scritto in Go e il README del fornitore lo compila con un unico comando go install, che richiede Go 1.24 o versioni successive. Installare prima Go dal tarball ufficiale. Il 20 October 2026, la release stabile corrente disponibile su go.dev/dl è go1.27.3, pubblicata il 19 October 2026 con una correzione di sicurezza per il pacchetto crypto/x509; l'hash riportato di seguito è quello pubblicato su quella pagina per l'archivio linux-amd64. Se si sceglie una versione più recente di Go, prelevarne l'hash dalla stessa pagina. Il flag -f fa sì che curl restituisca un errore in caso di errore HTTP, invece di salvare la pagina di errore con il nome richiesto. In questo modo si evita di estrarre una pagina 404 chiedendosi poi perché non sia un archivio.

cd /tmp
GOVER=go1.27.3
curl -fsSL "https://go.dev/dl/$GOVER.linux-amd64.tar.gz" -o go.tar.gz

Confrontare i due hash e confrontare soltanto gli hash.

published=65efbc80fdc1fa2cd2631cad5b481777a68e8725f34e89f50fc6ac714e379b40
downloaded=$(sha256sum go.tar.gz | awk '{print $1}')
[ "$published" = "$downloaded" ] && echo "checksum ok"

È importante chiarire che cosa dimostra questo controllo. Una corrispondenza dimostra che il download è completo e non è stato danneggiato o alterato durante il trasferimento. Non dimostra che il fornitore sia affidabile. È un problema diverso e nessun comando sha256sum può risolverlo.

sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go.tar.gz
export PATH=$PATH:/usr/local/go/bin
go version

Ora compilare la release community finale con l'utente normale. go install verifica ogni modulo scaricato, incluso il codice sorgente di MinIO, rispetto al database pubblico dei checksum di Go disponibile all'indirizzo sum.golang.org. Un modulo manomesso o sostituito interrompe quindi la compilazione con un errore di sicurezza, invece di produrre un binario.

go install github.com/minio/minio@RELEASE.2025-10-15T17-29-55Z
sudo install -o root -g root -m 755 ~/go/bin/minio /usr/local/bin/minio
minio --version
go version -m /usr/local/bin/minio | head -n 3

minio --version stampa DEVELOPMENT.GOGET al posto del nome della release, perché go install non applica i flag di compilazione usati dal fornitore per contrassegnare i propri binari. go version -m legge le informazioni sul modulo che Go incorpora in ogni binario e la relativa riga mod github.com/minio/minio indica il commit compilato. Un valore Permission denied in questo punto indica che la modalità è errata, mentre command not found indica che /usr/local/bin non è presente nel proprio PATH. Se la VPS dispone di poca memoria per la compilazione, eseguire lo stesso go install su un'altra macchina Linux con la stessa architettura e copiare il binario sulla VPS.

Crea un utente di sistema e una directory per i dati

MinIO accetta caricamenti dalla rete, quindi non deve essere eseguito come root. Assegnagli un account senza directory home e senza shell di login.

sudo groupadd -r minio-user
sudo useradd -M -r -g minio-user -s /usr/sbin/nologin minio-user
sudo mkdir -p /var/lib/minio/data
sudo chown -R minio-user:minio-user /var/lib/minio
sudo chmod 750 /var/lib/minio

-r crea un account di sistema con un UID inferiore a 1000, mantenendolo fuori dall'intervallo usato dagli utenti reali. -M omette la directory home, perché un account che non effettua mai il login non ha nulla da conservarvi. Verifica il risultato con id minio-user e con stat -c '%U %a' /var/lib/minio, che dovrebbe stampare minio-user 750.

La directory dei dati deve essere scrivibile da quell'utente, non soltanto leggibile. Al primo avvio MinIO crea una directory .minio.sys all'interno del volume per contenere la propria configurazione; per questo una directory di proprietà di root fa terminare MinIO durante l'avvio con un messaggio che termina in permission denied. La stessa regola vale per ogni servizio eseguito in questo modo e utenti di servizio con privilegi minimi su un VPS la illustra in dettaglio.

Inserire le credenziali root in un file di ambiente

Le credenziali root consentono di accedere a tutti i bucket, quindi non devono essere inserite nel file dell'unità, che è leggibile da tutti. Creare prima il file con i permessi corretti e scriverci solo dopo, in modo che la password non rimanga mai, nemmeno per un istante, in un file leggibile.

sudo install -o root -g root -m 600 /dev/null /etc/default/minio
printf 'MINIO_ROOT_USER=minio-root\nMINIO_ROOT_PASSWORD=%s\nMINIO_VOLUMES="/var/lib/minio/data"\nMINIO_OPTS="--address 127.0.0.1:9000 --console-address 127.0.0.1:9001"\n' "$(openssl rand -base64 24)" | sudo tee /etc/default/minio > /dev/null
sudo sed -n 's/^MINIO_ROOT_PASSWORD=//p' /etc/default/minio

tee tronca un file esistente invece di ricrearlo, quindi la modalità resta 600 e il proprietario resta root. È una scelta intenzionale. systemd legge EnvironmentFile come root prima di abbandonare i privilegi a favore di User=. Di conseguenza, l'account del servizio non deve leggere direttamente le proprie credenziali. Dopo l'avvio del servizio, verificarlo con sudo -u minio-user cat /etc/default/minio. Il comando deve stampare Permission denied.

Prima di avviare MinIO, è utile conoscere due comportamenti. Se nell'ambiente non sono presenti MINIO_ROOT_USER e MINIO_ROOT_PASSWORD, MinIO non rifiuta l'avvio. Si avvia con le credenziali predefinite documentate minioadmin:minioadmin, che sono la prima coppia provata da qualsiasi scanner, e durante l'avvio appare completamente operativo. Invece, una password con meno di 8 caratteri viene rifiutata: MinIO termina durante l'avvio con un errore che indica che le credenziali non sono valide, perché la chiave di accesso deve contenere almeno 3 caratteri e la chiave segreta almeno 8.

MINIO_VOLUMES è il percorso dei dati e MINIO_OPTS contiene i flag. L'associazione a 127.0.0.1 impedisce per ora a qualsiasi sistema esterno a questo VPS di raggiungere l'API S3, ed è l'impostazione predefinita corretta. L'accesso verrà aperto deliberatamente in seguito, tramite un proxy che gestisce un certificato.

Scrivere l'unità systemd

Creare /etc/systemd/system/minio.service:

[Unit]
Description=MinIO object storage
Documentation=https://github.com/minio/minio
Wants=network-online.target
After=network-online.target

[Service]
User=minio-user
Group=minio-user
EnvironmentFile=/etc/default/minio
ExecStart=/usr/local/bin/minio server $MINIO_VOLUMES $MINIO_OPTS
Restart=always
RestartSec=5
LimitNOFILE=65536
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target

In EnvironmentFile non è presente alcun - iniziale. È una scelta intenzionale, non un errore di battitura. Con il trattino, systemd ignora un file mancante e avvia comunque MinIO. In questo modo, un file eliminato o un percorso scritto in modo errato espone silenziosamente un server che usa minioadmin:minioadmin. Senza il trattino, l'assenza del file fa fallire l'unità prima ancora che MinIO venga eseguito e journalctl -u minio mostra Failed to load environment files: No such file or directory. Un'unità che rifiuta di avviarsi è molto più facile da rilevare rispetto a un server che accetta silenziosamente la password predefinita.

$MINIO_VOLUMES e $MINIO_OPTS non sono racchiuse tra virgolette intenzionalmente, perché systemd suddivide le variabili non racchiuse tra virgolette in argomenti separati in corrispondenza degli spazi. È così che le quattro parole in MINIO_OPTS diventano quattro argomenti per minio server. LimitNOFILE=65536 aumenta il limite dei file descriptor, perché ogni connessione aperta e ogni file di dati aperto consumano un descriptor, e il valore predefinito di 1024 si esaurisce sotto carico.

sudo systemctl daemon-reload
sudo systemctl enable --now minio
systemctl is-active minio
curl -fsS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:9000/minio/health/live

is-active dovrebbe stampare active, mentre l'endpoint di health check dovrebbe rispondere con 200. journalctl -u minio -n 20 --no-pager mostra l'indirizzo API su cui il server è in ascolto. Se l'unità continua a riavviarsi, systemd interrompe i tentativi e registra Start request repeated too quickly. Questo significa che MinIO termina a ogni tentativo. Il motivo è riportato nelle righe precedenti a quel messaggio, quindi è necessario scorrere il log verso l'alto.

Per un isolamento maggiore, aggiungere ProtectSystem=full e ProtectHome=true alla sezione [Service]. Entrambe richiedono namespace di mount forniti dal kernel dell'host. Nella virtualizzazione basata su container che condivide il kernel dell'host, come OpenVZ o LXC, possono verificarsi errori e l'unità riporta status=226/NAMESPACE. Rimuovere queste due righe consente l'avvio. L'unità è una normale unità systemd; i servizi e i timer systemd su un VPS descrivono le restanti direttive.

Installa mc e verifica un percorso completo

Il client MinIO è mc. Non installarlo con apt install mc. Quel pacchetto è Midnight Commander, un file manager non correlato a MinIO.

dl.min.io distribuisce ancora un binario mc, ma non quello della community. Il vecchio percorso della community, https://dl.min.io/client/mc/release/linux-amd64/mc, risponde con 410 Gone. Oggi MinIO offre lì l’AIStor Client in https://dl.min.io/aistor/mc/release/linux-amd64/mc. La relativa documentazione di riferimento dell’AIStor CLI indica questo client e lo descrive come dotato di funzionalità esclusive per le distribuzioni con licenza di AIStor Server. La documentazione non indica che possa essere usato con un server della community. Per questo la guida continua a usare il client della community. Il repository minio/mc è archiviato da luglio 2026. Compila quindi l’ultima release, RELEASE.2025-08-13T08-35-41Z, con la stessa toolchain Go. Il database dei checksum copre anche questo download.

go install github.com/minio/mc@RELEASE.2025-08-13T08-35-41Z
sudo install -o root -g root -m 755 ~/go/bin/mc /usr/local/bin/mc

Registra il server come alias, quindi trasferisci un oggetto tramite il server.

MINIO_PASS=$(sudo sed -n 's/^MINIO_ROOT_PASSWORD=//p' /etc/default/minio)
mc alias set local http://127.0.0.1:9000 minio-root "$MINIO_PASS"
mc mb local/backups
echo "hello object storage" > /tmp/hello.txt
mc cp /tmp/hello.txt local/backups/hello.txt
mc ls local/backups
mc cat local/backups/hello.txt

mc ls dovrebbe elencare hello.txt con le relative dimensioni, mentre mc cat dovrebbe stampare hello object storage. Questo percorso completo è la verifica effettiva del funzionamento del server, perché esegue le stesse richieste S3 firmate che eseguirà qualsiasi altro client. mc admin info local stampa lo stato del server, se vuoi un'ulteriore verifica.

Esegui ora un altro controllo, mentre il server è ancora vuoto.

mc alias set defaultcheck http://127.0.0.1:9000 minioadmin minioadmin

Questo comando deve fallire. Se ha esito positivo, il file dell'ambiente non è stato passato al processo e il server utilizza le credenziali predefinite. Risolvi il problema prima che qualsiasi altra operazione venga eseguita sulla macchina.

mc memorizza gli alias in ~/.mc/config.json in testo semplice. Di conseguenza, queste credenziali restano nella home directory dell'utente che ha eseguito il comando. Eseguendo mc con sudo, le credenziali root vengono inserite in /root/.mc/config.json. Mantieni l'alias root su un solo account amministrativo e assegna a ogni applicazione una chiave distinta.

Distribuire un oggetto con un URL presigned

Un URL presigned è un normale link HTTPS con una firma e una scadenza associate. Chiunque disponga del link può scaricare quell'oggetto senza un account e senza un client.

mc share download --expire 12h local/backups/hello.txt

L'output contiene X-Amz-Signature e X-Amz-Expires nella stringa di query. Due aspetti possono sorprendere. Il link viene creato usando l'endpoint dell'alias utilizzato. Di conseguenza, un alias su 127.0.0.1 produce un link che può essere aperto soltanto da questa macchina. Crea un secondo alias sul tuo hostname pubblico per i link che intendi distribuire. Inoltre, non esiste un pulsante per revocare un singolo link. La firma resta valida fino alla scadenza oppure finché la chiave che l'ha generata non viene rimossa o modificata. Per un link firmato con le credenziali root, questo significa ruotare tali credenziali. Una scadenza breve è quindi il controllo pratico da usare. Sette giorni è il limite massimo consentito dal formato delle firme S3.

Assegna a restic una chiave e un bucket dedicati

Le credenziali root possono leggere ed eliminare ogni bucket, quindi un job di backup non deve utilizzarle. Crea un bucket, una policy limitata a quel bucket e un utente senza altri privilegi.

mc mb local/restic
cat > /tmp/restic-rw.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket", "s3:GetBucketLocation"],
      "Resource": ["arn:aws:s3:::restic"]
    },
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
      "Resource": ["arn:aws:s3:::restic/*"]
    }
  ]
}
EOF
RESTIC_KEY=$(openssl rand -base64 24)
mc admin policy create local restic-rw /tmp/restic-rw.json
mc admin user add local restic-backup "$RESTIC_KEY"
mc admin policy attach local restic-rw --user restic-backup

MinIO include una policy readwrite integrata che avrebbe richiesto un comando in meno e concede l'accesso completo a ogni bucket del server. La policy precedente indica intenzionalmente il bucket due volte: una volta come arn:aws:s3:::restic, in modo da consentirne l'elenco, e una volta come arn:aws:s3:::restic/* per gli oggetti al suo interno. In S3 un bucket e i relativi oggetti sono risorse separate, quindi una policy che ne indica soltanto una fallisce in un modo che può sembrare un problema del client.

Verifica il limite prima di considerarlo affidabile.

mc alias set resticuser http://127.0.0.1:9000 restic-backup "$RESTIC_KEY"
mc ls resticuser/restic
mc ls resticuser/backups

Il primo ls ha esito positivo e il secondo fallisce con Access Denied. Una policy che non hai testato è solo un'ipotesi.

Ora configura restic per usare il bucket. restic legge le credenziali S3 dalle variabili d'ambiente AWS standard, quindi non è necessario alcun file di credenziali specifico di restic.

sudo apt install -y restic
export AWS_ACCESS_KEY_ID=restic-backup
export AWS_SECRET_ACCESS_KEY="$RESTIC_KEY"
restic -r s3:http://127.0.0.1:9000/restic init
restic -r s3:http://127.0.0.1:9000/restic backup /etc
restic -r s3:http://127.0.0.1:9000/restic snapshots

restic init richiede una password per il repository. Questa password cifra il repository, quindi MinIO conserva soltanto testo cifrato e, se la password viene persa, il backup non è più recuperabile. Un'esecuzione avviata da un timer systemd non dispone di un terminale in cui inserire la password, quindi imposta RESTIC_PASSWORD_FILE su un file con modalità 600 per i backup pianificati.

Una regola di posizionamento è più importante di qualsiasi comando precedente. Un repository restic sullo stesso VPS dei dati che protegge consente di recuperare da un rm e da nient'altro. Il nodo MinIO deve trovarsi su una macchina diversa, idealmente in una regione diversa. backup restic su un VPS descrive la pianificazione e la conservazione dei backup a partire da questa configurazione.

Terminare TLS con nginx

MinIO è in ascolto su localhost, quindi nginx costituisce la superficie pubblica. Emettere prima il certificato, come descritto in Certificati Let's Encrypt con certbot e nginx, quindi usare questo server block.

server {
    listen 443 ssl;
    server_name s3.example.com;

    ignore_invalid_headers off;
    client_max_body_size 0;
    proxy_buffering off;
    proxy_request_buffering off;

    location / {
        proxy_set_header Host $http_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_connect_timeout 300;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        chunked_transfer_encoding off;
        proxy_pass http://127.0.0.1:9000;
    }
}

Diverse di queste righe sono essenziali. client_max_body_size 0 rimuove il limite predefinito di 1 MB per il body, che altrimenti rifiuta qualsiasi upload più grande con 413 Request Entity Too Large prima ancora che MinIO riceva la richiesta. proxy_request_buffering off inoltra l'upload direttamente, perché il comportamento predefinito salva prima l'intera richiesta in un file temporaneo; un oggetto di grandi dimensioni richiede quindi il doppio dello spazio su disco. proxy_set_header Host $http_host è l'impostazione più delicata: una firma S3 include l'header Host, quindi un proxy che lo riscrive fa fallire ogni richiesta con SignatureDoesNotMatch, mentre l'access log mostra l'arrivo di una richiesta normale.

Indicare a MinIO anche il nome pubblico, in modo che i link generati puntino al proxy invece che a localhost.

echo 'MINIO_SERVER_URL=https://s3.example.com' | sudo tee -a /etc/default/minio
sudo systemctl restart minio

Il firewall resta essenziale. Consentire SSH e HTTPS e non aggiungere alcuna regola per le porte 9000 e 9001, perché un indirizzo associato a 127.0.0.1 non è raggiungibile da un'altra macchina, indipendentemente dalla configurazione del firewall. Nozioni di base sul firewall ufw su un VPS contiene i comandi.

Quando MinIO su un singolo nodo è sufficiente e quando serve un vero S3

Singolo nodo significa un solo disco. Non sono quindi disponibili né la parità né una seconda copia all'interno della distribuzione, e la durabilità di ogni oggetto dipende da quella del disco della singola VPS. La documentazione ufficiale di MinIO, disponibile come sorgente soltanto nel repository minio/docs da quando la documentazione della community ospitata è stata rimossa nell'ottobre 2025, descrive la distribuzione standalone come destinata alle prime fasi di sviluppo e alla valutazione, e specifica che MinIO non la raccomanda in produzione. Il blocco degli oggetti può essere attivato per un bucket, ma su una singola VPS impedisce soltanto la cancellazione tramite l'API S3. Chiunque disponga dell'accesso root alla macchina può comunque rimuovere i file dal disco. Non promettere quindi una policy di conservazione immutabile con questa configurazione.

È una soluzione adatta come destinazione di restic su una seconda VPS in un'altra regione e come endpoint S3 per attività di sviluppo e artefatti CI, quando la perdita di un bucket richiede soltanto una nuova build. È ragionevole anche per gli upload degli utenti di una piccola applicazione, purché tu abbia definito il piano di ripristino e abbia effettivamente verificato un restore.

Scegli S3 gestito quando un contratto o un'autorità di regolamentazione richiede il blocco degli oggetti o la durabilità su più regioni, oppure quando preferisci non essere la persona da contattare alle 03:00 perché un disco si è riempito. Anche il codice congelato è un motivo concreto. Al 20 ottobre 2026, la community edition è archiviata e non è più mantenuta. L'ultima release, RELEASE.2025-10-15T17-29-55Z, è quella compilata da questa guida. Non verranno corretti i problemi successivi. Eseguire questa versione significa accettare tale condizione, oppure passare alla linea commerciale AIStor di MinIO o a un altro object store self-hosted. Il confronto è disponibile in alternative self-hosted a MinIO.

È importante chiarire un limite che ricorre spesso. L'object storage non è un database. In un bucket standard ogni scrittura sostituisce un oggetto intero. Anche la chiamata append aggiunta da Amazon per S3 Express One Zone aggiunge dati soltanto alla fine. Un file SQL utilizzato direttamente su un bucket S3 è quindi lento e non sicuro. Mantieni il database sul disco locale ed esegui invece il backup nel bucket: eseguire SQLite in produzione su una VPS descrive questa separazione.

Modalità di errore e messaggi visualizzati

L'unità non riesce ad avviarsi subito dopo systemctl enable --now. Leggere journalctl -u minio -n 30 --no-pager. Failed to load environment files: No such file or directory indica che /etc/default/minio non è disponibile oppure che il relativo percorso è scritto in modo errato nell'unità. Un messaggio che termina con permission denied indica che l'account del servizio non può scrivere nella directory dei dati. Verificare quindi che stat -c '%U' /var/lib/minio/data restituisca minio-user.

minioadmin:minioadmin continua ad accedere. Il file dell'ambiente non è mai stato passato al processo. Verificare che l'unità contenga EnvironmentFile=/etc/default/minio, eseguire sudo systemctl daemon-reload, quindi riavviare il servizio. MinIO legge le credenziali root una sola volta all'avvio. Modificare il file senza riavviare il servizio non produce alcun effetto.

Address already in use all'avvio. Un altro processo sta utilizzando la porta 9000. Individuarlo con sudo ss -ltnp | grep :9000 prima di modificare la porta di MinIO.

I caricamenti superiori a 1 MB non riescono tramite il proxy. nginx ha restituito 413 Request Entity Too Large e MinIO non ha mai ricevuto la richiesta. Impostare client_max_body_size 0 nel blocco server.

SignatureDoesNotMatch. La secret key è errata oppure un componente tra il client e MinIO ha modificato l'header Host, incluso nella firma.

RequestTimeTooSkewed. L'orologio del client o del server non è corretto. Ogni richiesta S3 firmata contiene un timestamp e MinIO, come Amazon S3, rifiuta una richiesta con firma nell'header se il timestamp differisce di più di 15 minuti dal proprio orologio. I link presigned vengono invece verificati rispetto alla relativa scadenza. Controllare timedatectl e verificare che la sincronizzazione dell'ora sia attiva.

Access Denied su un bucket di cui si sa che esiste. La chiave è associata a un bucket diverso. Visualizzare le autorizzazioni effettive della policy con mc admin policy info local restic-rw e confrontare il nome del bucket nelle righe delle risorse.

FAQ

MinIO su un singolo nodo è sufficiente per backup reali?

È sufficiente come destinazione restic eseguita su una macchina separata dai dati che protegge. Non è sufficiente come unica copia. Una distribuzione con un solo disco non ha alcuna parità, quindi in MinIO non esiste una seconda copia; se il disco della VPS perde dati, gli oggetti vanno persi. Mantieni una seconda destinazione in un'altra posizione ed esegui almeno una volta un ripristino da entrambe, così verifichi che la procedura funzioni.

Perché sha256sum -c non funziona sul file dei checksum di MinIO?

Troverai quel file soltanto in una copia salvata in precedenza, perché dl.min.io ha restituito 410 Gone per ogni binario e file di checksum della community edition al controllo del 20 October 2026. L'etichetta dopo l'hash nel file indica la release, ad esempio minio.RELEASE.2025-09-07T16-13-09Z, mentre il file scaricato normalmente si chiama minio. sha256sum -c cerca un file con il nome scritto nel file dei checksum, non lo trova e restituisce No such file or directory e WARNING: 1 listed file could not be read. Il download è corretto. Confronta direttamente le stringhe hash e ignora l'etichetta, che non ha alcun significato per la sicurezza.

Che fine ha fatto la console web di amministrazione di MinIO?

A May 2025 MinIO ha rimosso le funzioni di amministrazione dalla console della community edition, lasciando nell'interfaccia web un browser per gli oggetti. Bucket e utenti ora si gestiscono con il client mc, usando comandi come mc admin user add e mc admin policy attach. Nella community edition questa è la procedura prevista, non una soluzione provvisoria; per questo questa guida esegue tutte le operazioni dalla riga di comando.

Come configuro restic per usare MinIO come backend S3?

Imposta AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY con una chiave di accesso MinIO e il relativo secret, quindi usa una stringa del repository nella forma s3:https://s3.example.com/restic, dove l'ultimo elemento del percorso è il nome del bucket. Crea prima il bucket con mc mb, perché una chiave limitata a un solo bucket non dispone dell'autorizzazione per creare bucket. restic cifra tutto con la propria password del repository prima del caricamento, quindi MinIO archivia testo cifrato e non vede mai i tuoi file.

Devo eseguire MinIO dietro nginx?

Ti serve TLS (sicurezza del livello di trasporto) ogni volta che un client si trova su un'altra macchina, perché senza TLS ogni oggetto attraversa la rete in testo in chiaro, insieme all'ID della chiave di accesso e alla firma della richiesta. La secret key non lascia mai il client, perché la firma S3 la usa soltanto localmente per calcolare quella firma; tuttavia, chiunque si trovi lungo il percorso può comunque leggere i dati e riprodurre una richiesta intercettata finché il relativo timestamp è valido. Un proxy sulla porta 443 con un certificato ottenuto da certbot è il modo più semplice per usare TLS e mantiene il rinnovo del certificato separato da MinIO. MinIO può anche terminare TLS direttamente se punti --certs-dir a una directory che contiene public.crt e private.key, ma in tal caso l'account del servizio deve avere accesso in lettura alla chiave privata rinnovata, con lavoro aggiuntivo per ottenere lo stesso risultato.