MinIO op een VPS installeren voor eigen S3-opslag

Wat zelf gehoste objectopslag met MinIO u biedt

MinIO is zelf gehoste objectopslag die de Amazon S3 API ondersteunt. Wijs restic of een S3 SDK naar uw eigen server, wijzig één endpointinstelling en de client merkt het verschil niet. In deze handleiding bouwt u één node op Ubuntu 24.04: een geverifieerd binair bestand, een speciale systeemgebruiker, een systemd-unit die de root-referenties buiten het unitbestand houdt en een bucket waarin restic back-ups opslaat.

S3 (Simple Storage Service) is een HTTP API en geen bestandssysteem. U plaatst een object met PUT in een bucket onder een sleutel en haalt het met GET weer op. Gedeeltelijk schrijven en hernoemen zijn niet mogelijk. Back-uptools gebruiken dit model graag, omdat een object volledig is aangekomen of helemaal niet.

Eén node bevat één kopie van uw gegevens. Dat is de afweging die u maakt. U krijgt een S3-endpoint dat u beheert voor de prijs van een VPS. Tegelijkertijd neemt u alle taken over die de cloudprovider uitvoerde, van het vervangen van een defecte schijf tot het patchen van de serversoftware. In het gedeelte aan het einde wordt duidelijk uitgelegd wanneer deze afweging verantwoord is.

De status van de MinIO-communityeditie in juli 2026

Lees dit deel voordat u ermee verdergaat, omdat de situatie onlangs is gewijzigd. In mei 2025 verwijderde MinIO de beheerfuncties uit de webconsole van de communityeditie. In de browser is alleen nog een objectbrowser beschikbaar. Buckets en toegangssleutels worden daarom beheerd met de mc-opdrachtregelclient.

Later in 2025 stopte MinIO met het publiceren van vooraf gecompileerde communitybinaries. In het README-bestand van het project staat nu dat de communityeditie alleen als broncode wordt gedistribueerd. De oudere download-URL's werken nog steeds. In juli 2026 leveren ze serverbuild RELEASE.2025-09-07T16-13-09Z en clientbuild RELEASE.2025-08-13T08-35-41Z. Er is geen nieuwere communitybuild verschenen. Het onderstaande binaire bestand bestaat dus echt en werkt, maar is niet meer bijgewerkt. Beveiligingsupdates die na september 2025 zijn gepubliceerd, zijn hierin niet opgenomen.

Dat ene feit bepaalt de rest van deze handleiding. Daarom luistert MinIO hier op 127.0.0.1 en bereikt het alleen via een proxy die u beheert het internet. Als u beveiligingsupdates wilt blijven volgen, bouwt u MinIO vanuit de broncode. In het README-bestand van de leverancier staat hiervoor één opdracht: go install github.com/minio/minio@latest. Hiervoor zijn een Go-toolchain en een uitvoerbaar bestand op ~/go/bin/minio nodig. Installeer dat bestand in /usr/local/bin/minio. Alle overige stappen in deze handleiding blijven ongewijzigd.

Installeer het MinIO-binarybestand en controleer de download

Download de vastgelegde release en de gepubliceerde checksum. De -f-flag zorgt ervoor dat curl mislukt bij een HTTP-fout, in plaats van de foutpagina op te slaan onder de naam die u hebt opgegeven. Zo installeren gebruikers soms een 404-pagina en vragen zij zich af waarom deze niet kan worden uitgevoerd.

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

Vergelijk de twee hashes en vergelijk alleen de hashes.

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

Gebruik hier niet sha256sum -c minio.sha256sum. Het label dat na de hash in dat bestand staat, is minio.RELEASE.2025-09-07T16-13-09Z. We hebben de download opgeslagen als minio. Daarom zoekt -c naar een bestand dat niet bestaat. Het rapporteert No such file or directory en vervolgens WARNING: 1 listed file could not be read. Dat lijkt op een beschadigde download, maar dat is niet het geval. Het label is alleen een naam. De hash is het onderdeel dat de garantie biedt.

Wees duidelijk over wat deze controle aantoont. Het binarybestand en de hash zijn via dezelfde verbinding van dezelfde leverancier afkomstig. Een overeenkomst toont daarom aan dat de download volledig is en tijdens de overdracht niet is beschadigd of gewijzigd. Dit toont niet aan dat de leverancier betrouwbaar is. Dat is een ander probleem en geen enkele sha256sum-opdracht lost dat op.

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

minio --version geeft minio version RELEASE.2025-09-07T16-13-09Z weer, gevolgd door enkele buildregels. Permission denied betekent hier dat de modus onjuist is. command not found betekent dat /usr/local/bin niet op uw PATH staat.

Een systeemgebruiker en een gegevensdirectory maken

MinIO accepteert uploads vanaf het netwerk en mag daarom niet als root worden uitgevoerd. Geef het een account zonder homedirectory en zonder login-shell.

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 maakt een systeemaccount aan met een UID lager dan 1000. Daardoor valt het buiten het bereik dat voor gebruikers wordt gebruikt. -M slaat de homedirectory over, omdat een account dat nooit inlogt daar niets hoeft op te slaan. Controleer het resultaat met id minio-user en met stat -c '%U %a' /var/lib/minio. Dit moet minio-user 750 afdrukken.

De gebruiker moet schrijfrechten hebben voor de gegevensdirectory, niet alleen leesrechten. Bij de eerste start maakt MinIO een .minio.sys-directory aan in het volume voor de eigen configuratie. Daarom wordt MinIO tijdens het opstarten beëindigd met een bericht dat eindigt op permission denied als de directory eigendom is van root. Dezelfde regel geldt voor elke service die u op deze manier uitvoert. least-privilege-servicegebruikers op een VPS behandelt dit uitgebreid.

Zet de root-inloggegevens in een omgevingsbestand

De root-inloggegevens geven toegang tot elke bucket. Ze horen daarom niet in het unitbestand, dat voor iedereen leesbaar is. Maak het bestand eerst met de juiste modus aan en schrijf er daarna in. Zo staat het wachtwoord geen moment in een leesbaar bestand.

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 kapt een bestaand bestand af in plaats van het opnieuw aan te maken. Daardoor blijven de modus 600 en de eigenaar root behouden. Dat is bewust zo ingesteld. systemd leest EnvironmentFile als root voordat het de privileges verlaagt naar User=. Het serviceaccount hoeft daardoor zijn eigen inloggegevens nooit te lezen. Controleer dit zodra de service actief is met sudo -u minio-user cat /etc/default/minio. Die opdracht moet Permission denied afdrukken.

Voordat u MinIO start, moet u twee gedragingen kennen. Als MINIO_ROOT_USER en MINIO_ROOT_PASSWORD niet in de omgeving zijn ingesteld, weigert MinIO niet om te starten. Het start met de gedocumenteerde standaardinloggegevens minioadmin:minioadmin. Dat is het eerste paar dat scanners proberen. De service lijkt daarbij volledig gezond. Een wachtwoord met minder dan 8 tekens wordt wel geweigerd. MinIO wordt tijdens het opstarten afgesloten met een foutmelding dat de inloggegevens ongeldig zijn. De access key moet namelijk minimaal 3 tekens bevatten en de secret key minimaal 8.

MINIO_VOLUMES is het gegevenspad en MINIO_OPTS bevat de flags. Door te binden aan 127.0.0.1 kan niets buiten deze VPS de S3 API bereiken. Dat is de juiste standaardinstelling. Open de toegang later bewust via een proxy waarop een certificaat is geïnstalleerd.

De systemd-unit schrijven

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

Op EnvironmentFile staat geen voorafgaande -. Dat is een bewuste keuze en geen typefout. Met het streepje negeert systemd een ontbrekend bestand en start het MinIO toch. Daardoor kan een verwijderd bestand of een verkeerd gespeld pad ongemerkt een server starten die minioadmin:minioadmin gebruikt. Zonder het streepje faalt de unit voordat MinIO wordt uitgevoerd. journalctl -u minio toont dan Failed to load environment files: No such file or directory. Een unit die niet wil starten, valt veel eerder op dan een server die stilzwijgend het standaardwachtwoord accepteert.

$MINIO_VOLUMES en $MINIO_OPTS staan bewust zonder aanhalingstekens, omdat systemd variabelen zonder aanhalingstekens op witruimte splitst in afzonderlijke argumenten. Zo worden de vier woorden in MINIO_OPTS vier argumenten voor minio server. LimitNOFILE=65536 verhoogt de limiet voor bestandsdescriptors. Elke open verbinding en elk geopend gegevensbestand gebruikt één descriptor. De standaardwaarde van 1024 is bij belasting snel bereikt.

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 moet active afdrukken. Het health-endpoint moet antwoorden met 200. journalctl -u minio -n 20 --no-pager toont het API-adres waarop de server luistert. Als de unit steeds opnieuw wordt gestart, geeft systemd het op en logt het Start request repeated too quickly. Dit betekent dat MinIO bij elke poging wordt beëindigd. De reden staat in de regels boven deze melding. Lees daarom omhoog.

Voor verdere isolatie voegt u ProtectSystem=full en ProtectHome=true toe aan de sectie [Service]. Beide vereisen mount-naamruimten van de hostkernel. Bij containervirtualisatie waarbij de hostkernel wordt gedeeld, zoals OpenVZ of LXC, kunnen ze mislukken. De unit meldt dan status=226/NAMESPACE. Verwijder deze twee regels om de unit te starten. De unit zelf is een gewone unit. systemd-services en timers op een VPS behandelt de overige directives.

mc installeren en een roundtrip uitvoeren

De MinIO-client is mc. Installeer deze niet met apt install mc. Dat pakket is Midnight Commander, een bestandsbeheerder die niets met MinIO te maken heeft.

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

Registreer de server als alias en verplaats vervolgens een object via de 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 moet hello.txt met de grootte ervan weergeven en mc cat moet hello object storage afdrukken. Deze roundtrip bewijst dat de server werkt, omdat hierbij dezelfde ondertekende S3-aanvragen worden uitgevoerd als door elke andere client. mc admin info local geeft de serverstatus weer als u een tweede controle wilt uitvoeren.

Voer nu nog een controle uit, zolang de machine nog leeg is.

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

Deze opdracht moet mislukken. Als de opdracht slaagt, is het omgevingsbestand niet doorgegeven aan het proces en draait uw server met de standaardreferenties. Los dit eerst op voordat iets anders de machine gebruikt.

mc slaat aliassen in ~/.mc/config.json op als platte tekst. Deze referenties staan dus in de persoonlijke map van degene die de opdracht heeft uitgevoerd. Als u mc uitvoert onder sudo, worden de root-referenties opgeslagen in /root/.mc/config.json. Gebruik de root-alias voor één beheerdersaccount en geef elke toepassing een eigen sleutel.

Eén object delen met een presigned URL

Een presigned URL is een gewone HTTPS-link met een handtekening en een vervaltijd. Iedereen die de link heeft, kan dat ene object ophalen zonder account en zonder client.

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

De uitvoer bevat X-Amz-Signature en X-Amz-Expires in de queryreeks. Twee aspecten ervan verrassen mensen. De link wordt opgebouwd met het endpoint uit de gebruikte alias. Een alias op 127.0.0.1 levert dus een link op die alleen op deze machine kan worden geopend. Maak een tweede alias op uw openbare hostnaam voor links die u wilt delen. Er is ook geen knop om de link in te trekken. De handtekening blijft geldig totdat deze verloopt. Een korte vervaltijd is daarom de enige beschikbare controle. Zeven dagen is het maximum dat de S3-handtekeningindeling toestaat.

Geef restic een eigen sleutel en bucket

De root-referenties kunnen elke bucket lezen en verwijderen. Een back-uptaak mag deze referenties daarom niet bevatten. Maak een bucket, een policy die tot die bucket is beperkt en een gebruiker die geen andere rechten krijgt.

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 levert een ingebouwde readwrite-policy die één opdracht korter zou zijn geweest. Deze verleent volledige toegang tot elke bucket op de server. In de bovenstaande policy wordt de bucket bewust twee keer genoemd: eenmaal als arn:aws:s3:::restic zodat het weergeven van de bucket werkt, en eenmaal als arn:aws:s3:::restic/* voor de objecten in de bucket. In S3 zijn een bucket en de objecten daarin afzonderlijke resources. Een policy waarin slechts een van beide wordt genoemd, faalt op een manier die lijkt op een defecte client.

Test de beperking voordat u erop vertrouwt.

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

De eerste ls slaagt en de tweede mislukt met Access Denied. Een policy die u niet hebt getest, is slechts een aanname.

Richt restic nu op de bucket. restic leest S3-referenties uit de standaard AWS-omgevingsvariabelen. Er is dus geen restic-specifiek referentiebestand nodig.

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 vraagt om een repositorywachtwoord. Dat wachtwoord versleutelt de repository. MinIO slaat daardoor alleen versleutelde gegevens op. Als u het wachtwoord verliest, bent u ook de backup kwijt. Een uitvoering die door een systemd-timer wordt gestart, heeft geen terminal waarin u iets kunt invoeren. Stel daarom RESTIC_PASSWORD_FILE in op een bestand met mode 600 voor geplande backups.

Eén plaatsingsregel is belangrijker dan alle bovenstaande opdrachten. Een restic-repository op dezelfde VPS als de gegevens die deze beschermt, beschermt u tegen een defecte rm en tegen niets anders. De MinIO-node moet op een andere machine staan, bij voorkeur in een andere regio. restic-backups op een VPS behandelt de planning en retentie hierop aanvullend.

TLS beëindigen met nginx

MinIO draait op localhost, dus nginx is het openbare toegangspunt. Vraag eerst het certificaat aan, zoals beschreven in Let's Encrypt-certificaten met certbot en nginx, en gebruik daarna dit serverblok.

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

Enkele regels zijn essentieel. client_max_body_size 0 verwijdert de standaardlimiet van 1 MB voor de aanvraagbody. Zonder deze instelling wordt elke grotere upload met 413 Request Entity Too Large geweigerd voordat MinIO het verzoek überhaupt ontvangt. proxy_request_buffering off stuurt de upload rechtstreeks door. Standaard wordt de volledige aanvraag eerst naar een tijdelijk bestand geschreven. Een groot object vereist daardoor twee keer zoveel schijfruimte. proxy_set_header Host $http_host is subtieler: een S3-handtekening omvat de header Host. Als een proxy deze header herschrijft, mislukt elk verzoek met SignatureDoesNotMatch, terwijl het toegangslogboek een normaal binnenkomend verzoek toont.

Geef MinIO ook de openbare naam door. Dan verwijzen de gegenereerde koppelingen naar de proxy in plaats van naar localhost.

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

De firewall blijft beperkt. Sta SSH en HTTPS toe. Laat poorten 9000 en 9001 volledig zonder regel, omdat een adres dat aan 127.0.0.1 is gebonden vanaf een andere machine onbereikbaar is, ongeacht de firewallconfiguratie. Basisprincipes van ufw-firewalls op een VPS bevat de opdrachten.

Wanneer een single-node MinIO volstaat en wanneer u echte S3 nodig hebt

Single node betekent hier één schijf zonder pariteit. In de eigen documentatie van MinIO wordt deze indeling beschreven als geschikt voor tests en kleine workloads zonder beschikbaarheidsvereisten. Binnen de deployment is geen tweede kopie aanwezig. De duurzaamheid van elk object is dus gelijk aan de duurzaamheid van één VPS-schijf. Functies die uitgaan van een gedistribueerde backend met erasure coding, waaronder bucketreplicatie en object locking, zijn bedoeld voor deployments met meerdere schijven. Beloof daarom niemand een onveranderlijk bewaarbeleid op deze configuratie.

Dit is een goede keuze als restic-doel op een tweede VPS in een andere regio en als S3-endpoint voor ontwikkelwerk en CI-artefacten. Dat geldt wanneer het verlies van een bucket alleen betekent dat u de omgeving opnieuw moet opbouwen. Het is ook een redelijke keuze voor gebruikersuploads in een kleine applicatie, zolang u eigenaar bent van het herstelplan en daadwerkelijk hebt getest of u een back-up kunt terugzetten.

Kies managed S3 wanneer een contract of toezichthouder vraagt om object lock of duurzaamheid in meerdere regio's. Kies het ook wanneer u liever niet degene bent die om 03:00 uur wordt opgepiept omdat een schijf vol is geraakt. De bevroren build is de andere objectieve reden. Sinds July 2026 dateert de voorgecompileerde community-binary uit September 2025 en ontvangt deze geen fixes. Als u deze binary uitvoert, accepteert u dat. Een alternatief is zelf bouwen from source en het project zelfstandig blijven volgen.

Een grens moet worden benoemd omdat deze vaak ter sprake komt. Object storage is geen database. Elke write vervangt een volledig object. Een actief SQL-bestand op een S3-bucket is daarom traag en onveilig. Houd de database op de lokale schijf en maak in plaats daarvan een back-up naar de bucket: SQLite in productie uitvoeren op een VPS beschrijft deze scheiding.

Foutscenario's en de meldingen die u ziet

De unit mislukt direct na systemctl enable --now. Lees journalctl -u minio -n 30 --no-pager. Failed to load environment files: No such file or directory betekent dat /etc/default/minio ontbreekt of dat het pad ernaartoe verkeerd is gespeld in de unit. Een melding die eindigt op permission denied betekent dat de gegevensmap niet schrijfbaar is voor het serviceaccount. Controleer daarom of stat -c '%U' /var/lib/minio/data minio-user afdrukt.

minioadmin:minioadmin meldt zich nog steeds aan. Het omgevingsbestand heeft het proces nooit bereikt. Controleer of de unit EnvironmentFile=/etc/default/minio bevat, voer sudo systemctl daemon-reload uit en start de service vervolgens opnieuw. MinIO leest de root-referenties eenmaal bij het opstarten. Als u dat bestand zonder herstart bewerkt, verandert er niets.

Address already in use bij het opstarten. Een ander proces gebruikt poort 9000. Zoek het proces met sudo ss -ltnp | grep :9000 voordat u de poort van MinIO wijzigt.

Uploads groter dan 1 MB mislukken via de proxy. nginx heeft 413 Request Entity Too Large geretourneerd en MinIO heeft het verzoek nooit ontvangen. Stel client_max_body_size 0 in het serverblok in.

SignatureDoesNotMatch. De geheime sleutel is onjuist, of iets tussen de client en MinIO heeft de header Host gewijzigd. Deze header valt onder de handtekening.

RequestTimeTooSkewed. De klok op de client of server loopt niet goed. Elk S3-verzoek bevat een tijdstempel en wordt buiten een venster van 15 minuten geweigerd. Controleer timedatectl en bevestig dat tijdsynchronisatie actief is.

Access Denied voor een bucket waarvan u weet dat deze bestaat. De sleutel is beperkt tot een andere bucket. Geef met mc admin policy info local restic-rw weer wat het beleid daadwerkelijk toestaat en vergelijk de bucketnaam in de resource-regels.

FAQ

Is MinIO met één node voldoende voor echte back-ups?

Het is voldoende als restic-doel dat op een andere machine draait dan de gegevens die het beschermt. Het is niet voldoende als enige kopie. Een implementatie met één schijf heeft geen pariteit. Er is dus geen tweede kopie binnen MinIO. Als die VPS-schijf gegevens verliest, zijn de objecten weg. Gebruik ergens anders een tweede doel. Voer minstens één keer een herstel uit vanaf beide doelen, zodat u weet dat het proces werkt.

Waarom mislukt sha256sum -c bij het checksum-bestand van MinIO?

Omdat het label na de hash in dat bestand de release minio.RELEASE.2025-09-07T16-13-09Z vermeldt, terwijl uw gedownloade bestand normaal minio heet. sha256sum -c zoekt naar een bestand met de naam die in het checksum-bestand staat, vindt dat bestand niet en meldt No such file or directory en WARNING: 1 listed file could not be read. De download is in orde. Vergelijk de hashtekenreeksen rechtstreeks en negeer het label. Het label heeft geen beveiligingsbetekenis.

Waar is de webconsole voor MinIO-beheer gebleven?

MinIO heeft in mei 2025 de beheerfuncties verwijderd uit de console van de community edition. In de webinterface bleef een objectbrowser over. Buckets en gebruikers worden nu beheerd met de mc-client, met opdrachten zoals mc admin user add en mc admin policy attach. Dit is de ondersteunde werkwijze in de community edition en geen tijdelijke oplossing. Daarom voert deze handleiding alles uit vanaf de opdrachtregel.

Hoe configureer ik restic voor MinIO als S3-backend?

Stel AWS_ACCESS_KEY_ID en AWS_SECRET_ACCESS_KEY in op een MinIO access key en het bijbehorende secret. Gebruik vervolgens een repositorytekenreeks in de vorm s3:https://s3.example.com/restic, waarbij het laatste padelement de bucketnaam is. Maak de bucket eerst aan met mc mb. Een key die tot één bucket is beperkt, heeft namelijk geen toestemming om buckets aan te maken. restic versleutelt alles met het eigen repositorywachtwoord voordat het de gegevens uploadt. MinIO slaat daardoor ciphertext op en krijgt nooit uw bestanden te zien.

Moet ik MinIO achter nginx uitvoeren?

U hebt TLS (transport layer security) nodig wanneer een client zich niet op dezelfde machine bevindt. S3-referenties en objectgegevens worden dan beide in het verzoek verzonden. Een proxy op poort 443 met een certificaat van certbot is de eenvoudigste manier om dit in te richten. Hiermee worden certificaatvernieuwingen buiten MinIO afgehandeld. MinIO kan TLS ook zelf beëindigen als u --certs-dir laat verwijzen naar een map met public.crt en private.key. Het serviceaccount moet dan leestoegang hebben tot de vernieuwde private key. Dat vereist extra werk voor hetzelfde resultaat.