MinIO su VPS: storage a oggetti S3 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. Configura restic o qualsiasi SDK S3 per usare il tuo server, modifica un'unica impostazione dell'endpoint e il client non rileverà alcuna differenza. Questa guida crea un nodo singolo su Ubuntu 24.04: un binario 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. Inserisci un oggetto in un bucket con una chiave usando PUT e lo recuperi con GET; non esistono scritture parziali né operazioni di ridenominazione. Gli strumenti di backup apprezzano questo modello perché un oggetto o è arrivato integralmente oppure non è arrivato.

Un nodo conserva una sola copia dei dati. Questo è il compromesso. Ottieni un endpoint S3 sotto il tuo controllo al costo di un VPS, ma devi anche occuparti di tutte le attività che normalmente svolgerebbe 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 è appropriato.

Stato della community edition di MinIO a luglio 2026

Leggere questa sezione prima di basarsi su queste istruzioni, perché la situazione è cambiata di recente. A maggio 2025 MinIO ha rimosso le funzioni di amministrazione dalla console web della community edition. Nel browser resta un object browser; i bucket e le access key si gestiscono quindi 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 ora che la community edition viene distribuita solo come codice sorgente. I vecchi URL per il download funzionano ancora: a luglio 2026 forniscono la build del server RELEASE.2025-09-07T16-13-09Z e la build del client RELEASE.2025-08-13T08-35-41Z, e non è comparsa alcuna build community più recente. Il binario riportato di seguito è quindi reale, funziona, ma è congelato. Non contiene le correzioni di sicurezza pubblicate dopo settembre 2025.

Questo fatto determina il resto della guida. Per questo MinIO rimane in ascolto su 127.0.0.1 e raggiunge Internet soltanto tramite un proxy sotto il tuo controllo. Se preferisci ricevere le correzioni, compila il software dal codice sorgente. Il README del fornitore indica un unico comando, go install github.com/minio/minio@latest, che richiede una toolchain Go e scrive il binario in ~/go/bin/minio. Installa quel binario in /usr/local/bin/minio; tutti gli altri passaggi restano invariati.

Installare il binario MinIO e verificare il download

Scaricare la release fissata e il relativo checksum pubblicato. Il flag -f fa sì che curl termini con un errore HTTP invece di salvare la pagina di errore con il nome richiesto. In caso contrario, si può finire per installare una pagina 404 e chiedersi perché non venga eseguita.

cd /tmp
REL=RELEASE.2025-09-07T16-13-09Z
curl -fsSL "https://dl.min.io/server/minio/release/linux-amd64/archive/minio.$REL" -o minio
curl -fsSL "https://dl.min.io/server/minio/release/linux-amd64/archive/minio.$REL.sha256sum" -o minio.sha256sum

Confrontare i due hash e confrontare soltanto gli hash.

published=$(awk '{print $1}' minio.sha256sum)
downloaded=$(sha256sum minio | awk '{print $1}')
[ "$published" = "$downloaded" ] && echo "checksum ok"

Qui non usare sha256sum -c minio.sha256sum. L'etichetta scritta dopo l'hash nel file è minio.RELEASE.2025-09-07T16-13-09Z, mentre il download è stato salvato come minio. Di conseguenza, -c cerca un file che non esiste. Il comando segnala No such file or directory e poi WARNING: 1 listed file could not be read. Questo può sembrare un download danneggiato, ma non lo è. L'etichetta è soltanto un nome. L'hash è l'elemento che fornisce la garanzia.

È importante chiarire che cosa dimostra questo controllo. Il binario e l'hash provengono dallo stesso fornitore e sono stati scaricati tramite la stessa connessione. Una corrispondenza dimostra quindi che il download è completo e non è stato danneggiato o modificato durante il trasferimento. Non dimostra che il fornitore sia affidabile. Questo è un problema diverso e nessun comando sha256sum lo risolve.

sudo install -o root -g root -m 755 minio /usr/local/bin/minio
minio --version

minio --version stampa minio version RELEASE.2025-09-07T16-13-09Z seguito da un paio di righe relative alla build. Un Permission denied indica che la modalità è errata, mentre command not found indica che /usr/local/bin non si trova nel tuo PATH.

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.

Installare mc e verificare un round trip

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

cd /tmp
curl -fsSL https://dl.min.io/client/mc/release/linux-amd64/mc -o mc
curl -fsSL https://dl.min.io/client/mc/release/linux-amd64/mc.sha256sum -o mc.sha256sum
[ "$(awk '{print $1}' mc.sha256sum)" = "$(sha256sum mc | awk '{print $1}')" ] && echo "checksum ok"
sudo install -o root -g root -m 755 mc /usr/local/bin/mc

Registra il server come alias, quindi sposta un oggetto attraverso 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 la relativa dimensione, mentre mc cat dovrebbe stampare hello object storage. Questo round trip dimostra che il server funziona, perché genera le stesse richieste S3 firmate che genererà qualsiasi altro client. mc admin info local stampa lo stato del server, se vuoi un'ulteriore verifica.

Esegui subito 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 riesce, il file dell'ambiente non è stato trasmesso al processo e il server sta usando le credenziali predefinite. Risolvi il problema prima che qualsiasi altra operazione interessi la macchina.

mc memorizza gli alias in ~/.mc/config.json in formato testo semplice, quindi le credenziali restano nella directory home dell'utente che ha eseguito il comando. Eseguire mc con sudo inserisce le credenziali root in /root/.mc/config.json. Mantieni l'alias root su un unico account amministrativo e assegna a ogni applicazione una propria chiave.

Distribuire un oggetto con un URL presigned

Un URL presigned è un normale link HTTPS a cui sono associati una firma e una scadenza. 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 sorprendono spesso gli utenti. Il link viene creato usando l'endpoint dell'alias utilizzato, quindi un alias su 127.0.0.1 genera un link che può essere aperto soltanto da questa macchina: create un secondo alias sul vostro hostname pubblico per i link che intendete distribuire. Inoltre, non esiste un pulsante per revocarlo. La firma resta valida fino alla scadenza, quindi una scadenza breve è l'unico controllo disponibile. Sette giorni è il limite massimo consentito dal formato della firma 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 basta un MinIO a nodo singolo e quando scegliere un vero S3

Un nodo singolo significa un solo disco senza alcuna parità. La documentazione di MinIO descrive questa configurazione come adatta ai test e ai carichi ridotti senza requisiti di disponibilità. Nel deployment non esiste una seconda copia, quindi la durabilità di ogni oggetto dipende da quella del disco di un solo VPS. Le funzionalità che presuppongono un backend distribuito con codifica di cancellazione, tra cui la replica dei bucket e il blocco degli oggetti, appartengono ai deployment con più dischi. Non promettere quindi a nessuno una policy di conservazione immutabile su questa configurazione.

È una scelta adatta come destinazione restic su un secondo VPS in un'altra regione e come endpoint S3 per attività di sviluppo e artefatti CI, dove la perdita di un bucket richiede solo una nuova build. È ragionevole anche per gli upload degli utenti in una piccola applicazione, purché il piano di ripristino sia sotto il tuo controllo e tu abbia realmente 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 avvisata alle 03:00 perché un disco si è riempito. Anche la build congelata è un motivo concreto. A luglio 2026 il binario precompilato della community risale a settembre 2025 e non riceve correzioni. Eseguirlo significa accettare questo limite, oppure compilare dai sorgenti e seguire autonomamente gli aggiornamenti del progetto.

È importante chiarire un limite, perché viene chiesto spesso. L'object storage non è un database. Ogni scrittura sostituisce un oggetto intero, quindi un file SQL in uso su un bucket S3 è lento e non sicuro. Mantieni il database sul disco locale e salvalo nel bucket: eseguire SQLite in produzione su un VPS descrive questa separazione.

Modalità di errore e messaggi visualizzati

L'unità ha esito negativo 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 manca oppure che il relativo percorso contiene un errore di ortografia 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 d'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, quindi modificare il file senza riavviare il servizio non produce alcun effetto.

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

I caricamenti superiori a 1 MB tramite il proxy hanno esito negativo. nginx ha risposto con 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 non è corretta oppure un componente tra il client e MinIO ha riscritto l'header Host, incluso nella firma.

RequestTimeTooSkewed. L'orologio del client o del server non è corretto. Ogni richiesta S3 contiene un timestamp e viene rifiutata se l'orario non rientra in una finestra di 15 minuti. Controllare timedatectl e verificare che la sincronizzazione dell'ora sia attiva.

Access Denied su un bucket di cui si conosce l'esistenza. La key è 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 a nodo singolo è sufficiente per backup reali?

È sufficiente come destinazione restic su una macchina separata dai dati che protegge. Non è sufficiente come unica copia. Un deployment su un solo disco non ha alcuna parità, quindi non esiste una seconda copia all'interno di MinIO. 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, per verificare che il processo funzioni.

Perché sha256sum -c non riesce a verificare il file dei checksum di MinIO?

Perché l'etichetta dopo l'hash contenuto nel file indica la release, minio.RELEASE.2025-09-07T16-13-09Z, mentre il file scaricato normalmente si chiama minio. sha256sum -c cerca un file con il nome riportato 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 degli 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 maggio 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 vengono gestiti con il client mc, usando comandi come mc admin user add e mc admin policy attach. Nella community edition questa è la procedura supportata, non un workaround. Per questo la 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 access key MinIO e il relativo secret, quindi usa una stringa del repository nel formato 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 key limitata a un singolo bucket non dispone dell'autorizzazione per creare bucket. Prima dell'upload, restic cifra tutto con la propria password del repository. MinIO memorizza quindi il ciphertext e non vede mai i tuoi file.

Devo eseguire MinIO dietro nginx?

Devi usare TLS (transport layer security) quando un client non si trova sulla stessa macchina, perché sia le credenziali S3 sia i dati degli oggetti viaggiano nella richiesta. Un proxy sulla porta 443 con un certificato ottenuto tramite certbot è il modo più semplice per farlo e mantiene il rinnovo del certificato separato da MinIO. MinIO può anche gestire direttamente la terminazione TLS se imposti --certs-dir su una directory che contiene public.crt e private.key. In questo caso, però, l'account del servizio deve avere accesso in lettura alla chiave privata rinnovata, con lavoro aggiuntivo a parità di risultato.