Installer MinIO sur un VPS Ubuntu 24.04

Ce que vous offre un stockage d’objets auto-hébergé avec MinIO

MinIO est un stockage d’objets auto-hébergé compatible avec l’API Amazon S3. Configurez restic ou n’importe quel SDK S3 pour utiliser votre propre serveur, modifiez un seul paramètre d’endpoint, et le client ne fera pas la différence. Ce guide configure un nœud unique sur Ubuntu 24.04 : un binaire vérifié, un utilisateur système dédié, une unité systemd qui ne stocke pas les identifiants root dans son fichier d’unité, et un bucket dans lequel restic effectue les sauvegardes.

S3 (simple storage service) est une API HTTP, pas un système de fichiers. Vous envoyez un objet dans un bucket sous une clé avec PUT, puis vous le récupérez avec GET. Il n’existe ni écriture partielle ni renommage. Les outils de sauvegarde apprécient ce modèle, car un objet est soit arrivé entièrement, soit il n’est pas arrivé.

Un seul nœud contient une seule copie de vos données. C’est le compromis que vous acceptez. Vous disposez d’un endpoint S3 que vous contrôlez, au prix d’un VPS, mais vous devez aussi assurer toutes les tâches que le fournisseur cloud effectuait, du remplacement d’un disque défaillant à l’application des correctifs au logiciel serveur. La section vers la fin explique clairement dans quels cas ce compromis est pertinent.

État de l’édition communautaire de MinIO en juillet 2026

Lisez cette partie avant de vous appuyer dessus, car la situation a récemment changé. En mai 2025, MinIO a retiré les fonctions d’administration de la console web de l’édition communautaire. Le navigateur fournit désormais uniquement un explorateur d’objets. Les buckets et les clés d’accès se gèrent donc avec le client en ligne de commande mc.

Plus tard en 2025, MinIO a cessé de publier des binaires communautaires précompilés. Le fichier README du projet indique désormais que l’édition communautaire est distribuée uniquement sous forme de code source. Les anciennes URL de téléchargement fonctionnent toujours : en juillet 2026, elles fournissent le build serveur RELEASE.2025-09-07T16-13-09Z et le build client RELEASE.2025-08-13T08-35-41Z, et aucun build communautaire plus récent n’est apparu. Le binaire ci-dessous est donc réel et fonctionnel, mais il est figé. Les correctifs de sécurité publiés après septembre 2025 n’y sont pas inclus.

Ce point détermine la suite de ce guide. C’est pourquoi MinIO écoute ici sur 127.0.0.1 et n’accède à Internet que par l’intermédiaire d’un proxy que vous contrôlez. Si vous préférez suivre les correctifs, compilez depuis les sources. Le README du fournisseur indique une seule commande, go install github.com/minio/minio@latest. Elle nécessite une chaîne d’outils Go et écrit le binaire dans ~/go/bin/minio. Installez ce binaire dans /usr/local/bin/minio ; toutes les autres étapes restent inchangées.

Installer le binaire MinIO et vérifier le téléchargement

Téléchargez la release définie et sa somme de contrôle publiée. L’option -f oblige curl à échouer en cas d’erreur HTTP au lieu d’enregistrer la page d’erreur sous le nom demandé. Cela évite d’installer une page 404 et de chercher pourquoi elle ne s’exécute pas.

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

Comparez les 2 hachages, et uniquement les hachages.

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

N’utilisez pas sha256sum -c minio.sha256sum ici. Le libellé écrit après le hachage dans ce fichier est minio.RELEASE.2025-09-07T16-13-09Z, et nous avons enregistré le téléchargement sous le nom minio. -c cherche donc un fichier qui n’existe pas. Il signale No such file or directory, puis WARNING: 1 listed file could not be read. Cela ressemble à un téléchargement corrompu, mais ce n’est pas le cas. Le libellé est uniquement un nom. Le hachage est l’élément qui fournit la garantie.

Soyez précis sur ce que cette vérification prouve. Le binaire et le hachage proviennent du même fournisseur et ont été téléchargés via la même connexion. Une correspondance prouve donc que le téléchargement est complet et qu’il n’a pas été endommagé ou modifié pendant le transit. Elle ne prouve pas que le fournisseur est digne de confiance. C’est un autre problème, et aucune commande sha256sum ne permet de le résoudre.

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

minio --version affiche minio version RELEASE.2025-09-07T16-13-09Z, suivi de quelques lignes de build. Un Permission denied indique ici que le mode est incorrect, et command not found indique que /usr/local/bin ne se trouve pas dans votre PATH.

Créer un utilisateur système et un répertoire de données

MinIO accepte les téléversements depuis le réseau. Il ne doit donc pas s’exécuter en tant que root. Créez-lui un compte sans répertoire personnel et sans shell de connexion.

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 crée un compte système avec un UID inférieur à 1000, afin de le maintenir en dehors de la plage utilisée pour les utilisateurs humains. -M ignore la création du répertoire personnel, car un compte qui ne se connecte jamais n’a rien à y conserver. Vérifiez le résultat avec id minio-user, puis avec stat -c '%U %a' /var/lib/minio, qui doit afficher minio-user 750.

Le répertoire de données doit être accessible en écriture par cet utilisateur, et pas seulement en lecture. Au premier démarrage, MinIO crée un répertoire .minio.sys dans le volume pour y stocker sa propre configuration. Un répertoire appartenant à root provoque donc l’arrêt de MinIO pendant le démarrage, avec un message qui se termine par permission denied. La même règle s’applique à chaque service exécuté de cette manière. La page utilisateurs de service avec le principe du moindre privilège sur un VPS l’explique correctement.

Placez les identifiants root dans un fichier d’environnement

Les identifiants root donnent accès à tous les buckets. Ils ne doivent donc pas figurer dans le fichier unit, qui est lisible par tous. Créez d’abord le fichier avec les bonnes permissions, puis écrivez-y les identifiants. Ainsi, le mot de passe ne se trouve jamais, même momentanément, dans un fichier lisible.

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 tronque un fichier existant au lieu de le recréer. Le mode reste donc à 600 et le propriétaire reste root. C’est volontaire. systemd lit EnvironmentFile en tant que root avant d’abandonner les privilèges pour utiliser User=. Le compte de service n’a donc jamais besoin de lire ses propres identifiants. Une fois le service démarré, vérifiez-le avec sudo -u minio-user cat /etc/default/minio. Cette commande doit afficher Permission denied.

Deux comportements de MinIO sont importants à connaître avant le démarrage. Si ni MINIO_ROOT_USER ni MINIO_ROOT_PASSWORD ne sont définis dans son environnement, MinIO refuse pas de démarrer. Il démarre avec les identifiants par défaut documentés, minioadmin:minioadmin. C’est la première paire essayée par les scanners. Le service semble alors parfaitement opérationnel. En revanche, un mot de passe de moins de 8 caractères est refusé. MinIO s’arrête au démarrage avec une erreur indiquant que les identifiants sont invalides, car la clé d’accès doit comporter au moins 3 caractères et la clé secrète au moins 8 caractères.

MINIO_VOLUMES est le chemin des données et MINIO_OPTS contient les options. L’écoute sur 127.0.0.1 signifie qu’aucun accès à l’API S3 n’est encore possible depuis l’extérieur de ce VPS. C’est le comportement par défaut recommandé. Vous l’ouvrez ensuite délibérément via un proxy qui possède un certificat.

Écrire l’unité systemd

Créez /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

Il n’y a pas de - au début de EnvironmentFile, et c’est un choix, pas une erreur de frappe. Avec le tiret, systemd ignore un fichier manquant et démarre quand même MinIO. Un fichier supprimé ou un chemin mal orthographié vous laisse donc silencieusement avec un serveur qui utilise minioadmin:minioadmin. Sans le tiret, un fichier manquant fait échouer l’unité avant même le démarrage de MinIO, et journalctl -u minio affiche Failed to load environment files: No such file or directory. Une unité qui refuse de démarrer est beaucoup plus facile à remarquer qu’un serveur qui accepte silencieusement le mot de passe par défaut.

$MINIO_VOLUMES et $MINIO_OPTS ne sont volontairement pas placés entre guillemets, car systemd découpe les variables non placées entre guillemets selon les espaces et les transforme en arguments distincts. C’est ainsi que les quatre mots de MINIO_OPTS deviennent quatre arguments pour minio server. LimitNOFILE=65536 augmente la limite de descripteurs de fichiers, car chaque connexion ouverte et chaque fichier de données ouvert consomme un descripteur, et la valeur par défaut de 1024 est insuffisante sous charge.

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 doit afficher active, et l’endpoint de health check doit répondre 200. journalctl -u minio -n 20 --no-pager affiche l’adresse API sur laquelle le serveur est en écoute. Si l’unité redémarre continuellement, systemd abandonne et journalise Start request repeated too quickly. Cela signifie que MinIO se termine à chaque tentative. La raison est affichée dans les lignes précédant ce message ; remontez donc dans le journal.

Pour renforcer l’isolation, ajoutez ProtectSystem=full et ProtectHome=true à la section [Service]. Les deux nécessitent des mount namespaces fournis par le kernel de l’hôte. Avec une virtualisation par conteneurs qui partage le kernel de l’hôte, comme OpenVZ ou LXC, ils peuvent échouer, et l’unité signale alors status=226/NAMESPACE. Supprimez ces deux lignes pour permettre le démarrage. L’unité elle-même est une unité ordinaire, et les services et timers systemd sur un VPS couvrent le reste des directives.

Installer mc et vérifier un aller-retour

Le client MinIO est mc. Ne l’installez pas avec apt install mc. Ce paquet correspond à Midnight Commander, un gestionnaire de fichiers sans rapport avec 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

Enregistrez le serveur comme alias, puis transférez-y un objet.

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 doit afficher hello.txt avec sa taille, et mc cat doit afficher hello object storage. Cet aller-retour prouve réellement que le serveur fonctionne, car il effectue les mêmes requêtes S3 signées que tous les autres clients. mc admin info local affiche l’état du serveur si vous souhaitez une seconde vérification.

Effectuez maintenant un contrôle supplémentaire, tant que la machine est encore vide.

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

Cette commande doit échouer. Si elle réussit, le fichier d’environnement n’a jamais été transmis au processus et votre serveur utilise les identifiants par défaut. Corrigez cela avant toute autre opération sur la machine.

mc stocke les alias dans ~/.mc/config.json en texte brut. Ces identifiants se trouvent donc dans le répertoire personnel de la personne qui a exécuté la commande. L’exécution de mc avec sudo place les identifiants root dans /root/.mc/config.json. Conservez l’alias root sur un seul compte d’administrateur et attribuez à chaque application sa propre clé.

Distribuer un objet avec une URL présignée

Une URL présignée est un lien HTTPS ordinaire auquel sont associés une signature et une durée d’expiration. Toute personne qui possède ce lien peut récupérer cet objet sans compte et sans client.

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

La sortie contient X-Amz-Signature et X-Amz-Expires dans la chaîne de requête. Deux points peuvent surprendre. Le lien est construit à partir du endpoint de l’alias utilisé. Ainsi, un alias sur 127.0.0.1 produit un lien que seule cette machine peut ouvrir. Créez un second alias sur votre nom d’hôte public pour les liens que vous prévoyez d’envoyer. Il n’existe pas non plus de bouton de révocation. La signature reste valide jusqu’à son expiration. Une durée d’expiration courte est donc le seul contrôle dont vous disposez. Sept jours est la durée maximale autorisée par le format de signature S3.

Donnez à restic sa propre clé et son propre bucket

Les identifiants root peuvent lire et supprimer tous les buckets. Une tâche de sauvegarde ne doit donc pas les utiliser. Créez un bucket, une policy limitée à ce bucket et un utilisateur qui n’a aucun autre accès.

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 fournit une policy readwrite intégrée. Elle aurait nécessité une commande de moins, mais elle accorde un accès complet à tous les buckets du serveur. La policy ci-dessus mentionne volontairement le bucket deux fois : une fois comme arn:aws:s3:::restic pour permettre l’énumération du bucket, et une fois comme arn:aws:s3:::restic/* pour les objets qu’il contient. Dans S3, un bucket et ses objets sont des ressources distinctes. Une policy qui n’en mentionne qu’une seule échoue d’une manière qui peut faire croire à un problème du client.

Testez la restriction avant de lui faire confiance.

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

Le premier ls réussit et le second échoue avec Access Denied. Une policy que vous n’avez pas testée n’est qu’une supposition.

Configurez maintenant restic pour utiliser le bucket. restic lit les identifiants S3 dans les variables d’environnement AWS standard. Aucun fichier d’identifiants spécifique à restic n’est donc nécessaire.

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 demande un mot de passe de repository. Ce mot de passe chiffre le repository. MinIO ne stocke donc que du ciphertext, et la perte du mot de passe entraîne la perte de la sauvegarde. Une exécution lancée par un timer systemd ne dispose d’aucun terminal dans lequel saisir ce mot de passe. Définissez donc RESTIC_PASSWORD_FILE sur un fichier en mode 600 pour les sauvegardes planifiées.

Une règle d’emplacement est plus importante que toutes les commandes précédentes. Un repository restic placé sur le même VPS que les données qu’il protège vous protège d’un mauvais rm, et de rien d’autre. Le nœud MinIO doit se trouver sur une autre machine, idéalement dans une autre région. sauvegardes restic sur un VPS explique comment ajouter la planification et la rétention à cette configuration.

Terminer TLS avec nginx

MinIO écoute sur localhost, nginx constitue donc la surface publique. Émettez d'abord le certificat, comme indiqué dans Certificats Let's Encrypt avec certbot et nginx, puis utilisez ce 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;
    }
}

Plusieurs de ces lignes sont essentielles. client_max_body_size 0 supprime la limite par défaut de 1 MB pour le corps des requêtes. Sans cela, tout upload plus volumineux est rejeté avec 413 Request Entity Too Large avant même que MinIO ne reçoive la requête. proxy_request_buffering off transmet directement l'upload, car le comportement par défaut écrit d'abord toute la requête dans un fichier temporaire. Un objet volumineux nécessite alors deux fois plus d'espace disque. proxy_set_header Host $http_host est le point subtil : une signature S3 couvre l'en-tête Host. Un proxy qui le réécrit fait donc échouer chaque requête avec SignatureDoesNotMatch, alors que l'access log indique qu'une requête normale est bien arrivée.

Indiquez également à MinIO son nom public. Les liens qu'il génère pointeront ainsi vers le proxy, et non vers localhost.

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

La configuration du firewall reste limitée. Autorisez SSH et HTTPS. Ne créez aucune règle pour les ports 9000 et 9001, car une adresse liée à 127.0.0.1 est inaccessible depuis une autre machine, quelle que soit la configuration du firewall. Bases d'ufw sur un VPS contient les commandes.

Quand MinIO sur un seul nœud suffit et quand vous avez besoin d’un véritable S3

Un seul nœud signifie ici un seul disque, sans parité. La documentation de MinIO décrit cette configuration comme adaptée aux tests et aux petites charges de travail sans exigence de disponibilité. Le déploiement ne contient aucune seconde copie. La durabilité de chaque objet dépend donc de celle du disque du VPS. Les fonctionnalités qui supposent un backend distribué avec codage d’effacement, notamment la réplication des buckets et le verrouillage des objets, sont réservées aux déploiements à plusieurs disques. Ne promettez donc pas de politique de conservation immuable avec cette configuration.

Cette configuration convient bien comme cible restic sur un second VPS situé dans une autre région, ainsi que comme endpoint S3 pour le développement et les artefacts de CI. Dans ces cas, la perte d’un bucket vous impose seulement de le recréer. Elle convient aussi aux téléversements d’utilisateurs dans une petite application, à condition de gérer vous-même le plan de récupération et d’avoir réellement testé une restauration.

Choisissez un S3 managé lorsqu’un contrat ou un organisme de réglementation exige le verrouillage des objets ou une durabilité multi-région. Faites de même si vous préférez ne pas être la personne appelée à 03:00 parce qu’un disque est plein. Le build figé est l’autre raison objective. En juillet 2026, le binaire communautaire précompilé date de septembre 2025 et ne reçoit aucun correctif. L’exécuter signifie accepter cette situation, ou bien compiler depuis les sources et assurer vous-même le suivi du projet.

Une limite mérite d’être précisée, car elle revient souvent. Le stockage objet n’est pas une base de données. Chaque écriture remplace l’objet entier. Placer un fichier SQL actif dans un bucket S3 est donc lent et peu sûr. Conservez la base de données sur le disque local et sauvegardez-la dans le bucket à la place : exécuter SQLite en production sur un VPS décrit cette séparation.

Modes d’échec et messages affichés

L’unité échoue juste après systemctl enable --now. Lisez journalctl -u minio -n 30 --no-pager. Failed to load environment files: No such file or directory signifie que /etc/default/minio est absent ou que son chemin est mal orthographié dans l’unité. Un message qui se termine par permission denied signifie que le compte de service ne peut pas écrire dans le répertoire de données. Vérifiez donc que stat -c '%U' /var/lib/minio/data affiche minio-user.

minioadmin:minioadmin se connecte toujours. Le fichier d’environnement n’a jamais été transmis au processus. Vérifiez que l’unité contient EnvironmentFile=/etc/default/minio, exécutez sudo systemctl daemon-reload, puis redémarrez le service. MinIO ne lit ses identifiants root qu’au démarrage. Modifier ce fichier sans redémarrer ne change donc rien.

Address already in use au démarrage. Un autre processus utilise le port 9000. Trouvez-le avec sudo ss -ltnp | grep :9000 avant de modifier le port de MinIO.

Les transferts de plus de 1 MB échouent via le proxy. nginx a renvoyé 413 Request Entity Too Large et MinIO n’a jamais reçu la requête. Définissez client_max_body_size 0 dans le server block.

SignatureDoesNotMatch. La secret key est incorrecte, ou un élément situé entre le client et MinIO a réécrit l’en-tête Host, qui est couvert par la signature.

RequestTimeTooSkewed. L’horloge du client ou du serveur est incorrecte. Chaque requête S3 contient un horodatage et est rejetée si elle se situe en dehors d’une fenêtre de 15 minutes. Vérifiez timedatectl et confirmez que la synchronisation de l’heure est active.

Access Denied sur un bucket dont vous savez qu’il existe. La key est limitée à un autre bucket. Affichez ce que la policy autorise réellement avec mc admin policy info local restic-rw, puis comparez le nom du bucket dans les lignes de resource.

FAQ

Un nœud MinIO suffit-il pour de vraies sauvegardes ?

Il suffit comme cible restic exécutée sur une machine distincte des données qu’elle protège. Il ne suffit pas comme copie unique. Un déploiement sur un seul disque n’a aucune parité. Il n’existe donc aucune seconde copie dans MinIO. Si le disque de ce VPS perd des données, les objets sont perdus. Conservez une seconde cible ailleurs et effectuez au moins une restauration depuis chacune des deux cibles pour vérifier que le processus fonctionne.

Pourquoi sha256sum -c échoue-t-il avec le fichier de somme de contrôle de MinIO ?

Parce que le libellé placé après le hash dans ce fichier désigne la release, minio.RELEASE.2025-09-07T16-13-09Z, tandis que le fichier téléchargé s’appelle normalement minio. sha256sum -c recherche un fichier portant le nom indiqué dans le fichier de somme de contrôle. Il ne le trouve pas et signale No such file or directory et WARNING: 1 listed file could not be read. Le téléchargement est correct. Comparez directement les chaînes de hash et ignorez le libellé. Celui-ci n’a aucune signification en matière de sécurité.

Où est passée la console web d’administration de MinIO ?

MinIO a supprimé les fonctions d’administration de la console de l’édition communautaire en mai 2025. L’interface web ne contient plus qu’un navigateur d’objets. Les buckets et les utilisateurs se gèrent désormais avec le client mc, à l’aide de commandes telles que mc admin user add et mc admin policy attach. Il s’agit de la méthode prise en charge dans l’édition communautaire, et non d’un contournement. C’est pourquoi ce guide effectue toutes les opérations depuis la ligne de commande.

Comment configurer restic pour utiliser MinIO comme backend S3 ?

Définissez AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY avec une clé d’accès MinIO et son secret, puis utilisez une chaîne de dépôt de la forme s3:https://s3.example.com/restic, où le dernier élément du chemin est le nom du bucket. Créez d’abord le bucket avec mc mb, car une clé limitée à un bucket n’a pas l’autorisation de créer des buckets. restic chiffre toutes les données avec le mot de passe de son propre dépôt avant l’envoi. MinIO ne stocke donc que le texte chiffré et n’accède jamais à vos fichiers.

Dois-je exécuter MinIO derrière nginx ?

Vous avez besoin de TLS (sécurité de la couche transport) dès qu’un client se trouve sur une autre machine, car les identifiants S3 et les données des objets transitent tous deux dans la requête. Un proxy sur le port 443 avec un certificat fourni par certbot est la méthode la plus simple. Le renouvellement du certificat reste ainsi indépendant de MinIO. MinIO peut aussi terminer lui-même TLS si vous définissez --certs-dir sur un répertoire contenant public.crt et private.key. Le compte de service doit alors disposer d’un accès en lecture à la clé privée renouvelée. Cela demande davantage de configuration pour obtenir le même résultat.