MinIO su VPS: object storage S3 self-hosted

Che cosa offre l'object storage self-hosted con MinIO

MinIO è un object storage self-hosted che supporta l'API Amazon S3. Indicate il vostro server in restic o in un SDK S3, modificate una sola impostazione dell'endpoint e il client non rileverà alcuna differenza. Questa guida crea un singolo nodo 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. Inserite un oggetto in un bucket usando una chiave con PUT e recuperatelo con GET. Non esistono scritture parziali né operazioni di rinomina. Gli strumenti di backup apprezzano questo modello, perché un oggetto arriva completo oppure non arriva.

Un singolo nodo contiene una sola copia dei dati. Questo è il compromesso scelto. Ottenete un endpoint S3 sotto il vostro controllo al costo di un VPS, ma dovete anche occuparvi 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 è appropriato.

Stato della community edition di MinIO a luglio 2026

Leggere questa sezione prima di basarsi su di essa, perché è cambiata di recente. A maggio 2025 MinIO ha rimosso le funzionalità di amministrazione dalla console web della community edition. Nel browser rimane un browser di oggetti; i bucket e le chiavi di accesso si gestiscono quindi con il client da riga di comando mc.

Più avanti, nel 2025, MinIO ha smesso di pubblicare i binari precompilati della community edition. Il README del progetto ora indica che la community edition è distribuita solo come codice sorgente. I vecchi URL di 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 ed è congelato. Non include le correzioni di sicurezza pubblicate dopo settembre 2025.

Questo fatto determina il resto della guida. Per questo MinIO ascolta su 127.0.0.1 e raggiunge Internet solo tramite un proxy sotto il tuo controllo. Se preferisci ricevere le correzioni, compila dal codice sorgente. Il README del fornitore indica un solo 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 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 installare una pagina 404 e poi 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 solo 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 inesistente. Restituisce 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 è solo un nome. L'hash è la parte che fornisce la garanzia.

È importante capire che cosa dimostra questo controllo. Il binario e l'hash provengono dallo stesso fornitore e attraverso la stessa connessione. Una corrispondenza dimostra quindi 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 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 di build. Un Permission denied indica che la modalità è errata, mentre command not found indica che /usr/local/bin non è presente nel tuo PATH.

Creare un utente di sistema e una directory dati

MinIO accetta caricamenti dalla rete, quindi non deve essere eseguito come root. Assegnargli 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 per gli utenti personali. -M omette la directory home, perché un account che non esegue mai l'accesso non ha nulla da conservarvi. Verificare il risultato con id minio-user e con stat -c '%U %a' /var/lib/minio, che dovrebbe stampare minio-user 750.

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

Inserire le credenziali di root in un file di ambiente

Le credenziali di root consentono di accedere a ogni bucket, quindi non devono trovarsi nel file dell'unità, che è leggibile da tutti. Creare prima il file con i permessi corretti e scrivervi dopo, in modo che la password non si trovi mai, neppure 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 i permessi restano 600 e il proprietario resta root. È una scelta intenzionale. systemd legge EnvironmentFile come root prima di abbandonare i privilegi a favore di User=; l'account del servizio non deve quindi leggere 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 avviarlo, è importante conoscere due comportamenti di MinIO. 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'operazione appare completamente funzionante. Invece, una password con meno di 8 caratteri viene rifiutata: MinIO termina all'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. Il binding a 127.0.0.1 impedisce a qualsiasi sistema esterno a questo VPS di raggiungere l'API S3 per il momento, ed è il comportamento predefinito corretto. L'accesso viene aperto deliberatamente in seguito, tramite un proxy che gestisce un certificato.

Scrivere l'unità systemd

Crea /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

Non c'è alcun - iniziale su EnvironmentFile. È una scelta, 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, un file mancante causa il fallimento dell'unità prima che MinIO venga avviato 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 quotate sugli spazi vuoti e le trasforma in argomenti separati. In questo modo, le quattro parole in MINIO_OPTS diventano quattro argomenti per minio server. LimitNOFILE=65536 aumenta il limite dei descrittori di file, perché ogni connessione aperta e ogni file di dati aperto richiedono un descrittore, mentre il valore predefinito di 1024 viene esaurito 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 e l'endpoint di integrità 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 rinuncia e registra Start request repeated too quickly. Questo significa che MinIO termina a ogni tentativo. La causa viene stampata nelle righe precedenti a quel messaggio, quindi scorri il log verso l'alto.

Per un isolamento maggiore, aggiungi ProtectSystem=full e ProtectHome=true alla sezione [Service]. Entrambi 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à può quindi segnalare status=226/NAMESPACE. Rimuovi queste due righe e l'unità si avvia. L'unità è una normale unità systemd e i servizi e i timer systemd su un VPS illustrano le altre direttive.

Installare mc e verificare un percorso completo

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 trasferisci un oggetto attraverso di esso.

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 sistema è ancora vuoto.

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

Questo comando deve non riuscire. Se riesce, il file dell'ambiente non è mai stato passato al processo e il server usa le credenziali predefinite. Risolvi il problema prima che qualsiasi altra cosa acceda alla macchina.

mc memorizza gli alias in ~/.mc/config.json in testo normale, quindi le credenziali si trovano nella home directory dell'utente che ha eseguito il comando. L'esecuzione di mc con sudo inserisce le credenziali root in /root/.mc/config.json. Mantieni l'alias root in un solo account amministrativo e assegna a ogni applicazione una chiave propria.

Condividere 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. Ci sono due aspetti che spesso sorprendono. Il link viene creato usando l'endpoint dell'alias utilizzato; quindi, se un alias punta a 127.0.0.1, il link sarà accessibile solo da questa macchina. Crea un secondo alias sul tuo hostname pubblico per i link che intendi condividere. Inoltre, non esiste un pulsante per revocare il link. La firma rimane valida fino alla scadenza, quindi una scadenza breve è l'unico controllo disponibile. Il formato delle firme S3 consente una durata massima di sette giorni.

Assegnare a restic una chiave e un bucket dedicati

Le credenziali di 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 permessi.

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, ma concede l'accesso completo a ogni bucket del server. La policy precedente indica il bucket due volte di proposito: una volta come arn:aws:s3:::restic, affinché l'elenco del bucket funzioni, e una volta come arn:aws:s3:::restic/* per gli oggetti al suo interno. In S3, un bucket e i relativi oggetti sono risorse distinte, quindi una policy che ne indica solo una fallisce in un modo che sembra indicare un problema del client.

Verifica il limite prima di fare affidamento su di esso.

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 non verificata è solo un'ipotesi.

Ora configura restic per utilizzare il bucket. restic legge le credenziali S3 dalle variabili d'ambiente AWS standard, quindi non viene utilizzato 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 memorizza solo testo cifrato; se la password viene persa, il backup non può essere recuperato. Un'esecuzione avviata da un timer systemd non ha un terminale in cui inserire la password, quindi imposta RESTIC_PASSWORD_FILE su un file con permessi mode 600 per i backup pianificati.

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

Terminare TLS con nginx

MinIO è in ascolto su localhost, quindi nginx è il punto di accesso pubblico. Rilascia prima il certificato, come descritto in Certificati Let's Encrypt con certbot e nginx, quindi usa questo blocco server.

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;
    }
}

Alcune di queste righe sono essenziali. client_max_body_size 0 rimuove il limite predefinito di 1 MB per il corpo della richiesta. Senza questa impostazione, ogni caricamento più grande viene rifiutato con 413 Request Entity Too Large prima ancora che MinIO riceva la richiesta. proxy_request_buffering off inoltra il caricamento direttamente, perché la configurazione predefinita salva prima l'intera richiesta in un file temporaneo. Un oggetto di grandi dimensioni richiederebbe quindi il doppio dello spazio su disco. proxy_set_header Host $http_host è l'impostazione più delicata: una firma S3 include l'header Host. Se il proxy lo riscrive, ogni richiesta fallisce con SignatureDoesNotMatch, anche se il log degli accessi mostra l'arrivo di una richiesta normale.

Configura anche il nome pubblico in MinIO, in modo che i collegamenti generati puntino al proxy anziché a localhost.

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

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

Quando MinIO a nodo singolo è sufficiente e quando serve S3 reale

Qui, nodo singolo significa un solo disco senza alcuna parità. La documentazione di MinIO indica questa configurazione come adatta ai test e ai carichi ridotti senza requisiti di disponibilità. All'interno della distribuzione 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 erasure, tra cui la replica dei bucket e il blocco degli oggetti, appartengono alle distribuzioni con più dischi. Non promettere quindi a nessuno una policy di conservazione immutabile su questa configurazione.

È una scelta adatta come destinazione di restic su un secondo VPS in un'altra regione e come endpoint S3 per lo sviluppo e gli artefatti CI, quando la perdita di un bucket richiede solo una nuova build. È una soluzione ragionevole anche per gli upload degli utenti in una piccola applicazione, purché il piano di ripristino sia sotto il tuo controllo e tu 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 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 questa limitazione, oppure compilare dal codice sorgente e seguire personalmente il progetto.

È utile chiarire un limite, perché viene citato spesso. Lo storage a oggetti non è un database. Ogni scrittura sostituisce un oggetto intero, quindi un file SQL attivo in un bucket S3 è lento e non sicuro. Mantieni il database sul disco locale ed esegui invece il backup nel bucket: eseguire SQLite in produzione su un VPS descrive questa separazione.

Modalità di errore e messaggi visualizzati

L'unità si arresta 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 dell'ambiente non è mai stato trasmesso 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 quel file senza riavviare il servizio non produce alcun effetto.

Address already in use all'avvio. Un altro processo usa 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 attraverso 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 riscritto l'header Host, incluso nella firma.

RequestTimeTooSkewed. L'orologio del client o del server è errato. Ogni richiesta S3 contiene un timestamp e viene rifiutata se si trova al di fuori di una finestra di 15 minuti. Controllare timedatectl e verificare che la sincronizzazione dell'ora sia attiva.

Access Denied su un bucket di cui si sa che esiste. La key è associata a un bucket diverso. Visualizzare ciò che la policy consente effettivamente con mc admin policy info local restic-rw e confrontare il nome del bucket nelle righe resource.

FAQ

MinIO a nodo singolo è sufficiente per backup reali?

È sufficiente come destinazione restic eseguita su una macchina separata dai dati che protegge. Non è sufficiente come unica copia. Un'installazione su una sola unità non ha alcuna parità, quindi non esiste una seconda copia all'interno di MinIO. Se il disco della VPS perde dati, gli oggetti vengono persi. Mantieni una seconda destinazione in un altro luogo ed esegui almeno una volta un ripristino da entrambe, per verificare che il processo funzioni.

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

Perché l'etichetta dopo l'hash 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 scritto nel file dei checksum, non lo trova e segnala 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?

MinIO ha rimosso le funzioni di amministrazione dalla console della community edition a maggio 2025, lasciando nell'interfaccia web un browser per gli oggetti. I bucket e gli utenti ora si gestiscono con il client mc, usando comandi come mc admin user add e mc admin policy attach. Questo è il metodo supportato nella community edition, non una soluzione temporanea. 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 access key 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 ha il permesso di creare bucket. restic cifra ogni elemento con la propria password del repository prima del caricamento. MinIO memorizza quindi dati cifrati 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é le credenziali S3 e i dati degli oggetti viaggiano entrambi nella richiesta. Un proxy sulla porta 443 con un certificato ottenuto da certbot è il modo più semplice per farlo 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. In questo caso, però, l'account del servizio deve avere accesso in lettura alla chiave privata rinnovata. È un lavoro aggiuntivo per ottenere lo stesso risultato.