MinIO : stockage objet S3-compatible

MinIO est un serveur de stockage objet haute performance, compatible avec l’API Amazon S3. Il permet de stocker des fichiers (objets) dans des buckets, accessibles via HTTP. Ce guide vous accompagne de l’installation à la configuration avancée.

Qu’est-ce que MinIO ?

MinIO est un système de stockage objet conçu pour être :

Compatible S3 : toute application utilisant l’API Amazon S3 fonctionne avec MinIO
Performant : écrit en Go, optimisé pour du matériel moderne (NVMe, 100GbE)
Simple : un seul binaire, déploiement en quelques minutes
Sécurisé : chiffrement, TLS, gestion fine des accès

Les cas d’usage typiques incluent :

Usage	Description
Backend Terraform	Stocker les états `.tfstate` de manière centralisée
Sauvegardes	Cible S3 pour Restic, Velero, Duplicati
Artefacts CI/CD	Cache de builds, images Docker, packages
Data Lake	Stockage de données brutes pour analytics

Alternatives à MinIO

Si vous démarrez un nouveau projet, considérez ces alternatives :

Solution	Type	Licence	Points forts
AIStor Free	Officielle MinIO	Propriétaire gratuit	Support officiel, standalone
AIStor Enterprise	Officielle MinIO	Commercial	Fonctionnalités avancées, SLA
Ceph RGW	Open source	LGPL	Écosystème mature, object + block
SeaweedFS	Open source	Apache 2.0	Simple, performant, actif
Garage	Open source	AGPL v3	Léger, Rust, axé simplicité
RustFS	Fork MinIO	AGPL v3	Fork communautaire récent

Pour la majorité des usages (sauvegardes, états Terraform), MinIO reste fonctionnel. Pour des déploiements critiques, évaluez Ceph ou SeaweedFS.

Architecture et concepts clés

Avant l’installation, comprenez les concepts fondamentaux :

Buckets et objets

Bucket : conteneur logique pour regrouper des objets (similaire à un répertoire racine)
Objet : fichier stocké avec ses métadonnées (nom, taille, type MIME, version)

Erasure Coding

MinIO protège les données via l’Erasure Coding (codage par effacement) :

Les données sont divisées en blocs de données et blocs de parité
Permet de reconstruire les données en cas de perte de disques
Configuration typique : 4 données + 4 parité = 8 disques minimum

Mode distribué

Pour la haute disponibilité, MinIO supporte le mode distribué :

Plusieurs nœuds forment un cluster
Réplication automatique des données
Tolérance aux pannes de nœuds

Installation de MinIO

Trois méthodes sont disponibles. Choisissez selon votre contexte.

La méthode recommandée depuis le passage en mode maintenance. Nécessite Go 1.24+.

Vérifier Go
Fenêtre de terminal
```
go version
# go version go1.25.6 linux/amd64
```
Si Go n’est pas installé, utilisez votre gestionnaire de paquets ou mise.
Installer MinIO
Fenêtre de terminal
```
go install github.com/minio/minio@latest
```
Le binaire est installé dans ~/go/bin/minio.

Vérifier l’installation

~/go/bin/minio --version
# minio version DEVELOPMENT.GOGET
# Runtime: go1.25.6 linux/amd64
# License: GNU AGPLv3

Ajouter au PATH (optionnel)

echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Méthode simple pour les tests ou les déploiements conteneurisés.

docker run -d \
  --name minio \
  -p 9000:9000 \
  -p 9001:9001 \
  -e MINIO_ROOT_USER=admin \
  -e MINIO_ROOT_PASSWORD=motdepasse123 \
  -v /data/minio:/data \
  quay.io/minio/minio server /data --console-address ":9001"

Vérifiez que le conteneur est actif :

docker logs minio | head -20
curl http://127.0.0.1:9000/minio/health/live

Sur Debian/Ubuntu :

wget https://dl.min.io/server/minio/release/linux-amd64/minio_20231223071911.0.0_amd64.deb
sudo dpkg -i minio_20231223071911.0.0_amd64.deb

Sur RHEL/Fedora :

sudo dnf install https://dl.min.io/server/minio/release/linux-amd64/minio-20231223071911.0.0-1.x86_64.rpm

Premier démarrage

Une fois MinIO installé, configurez et démarrez le serveur.

Créer le répertoire de données

sudo mkdir -p /data/minio
sudo chown $USER:$USER /data/minio

Définir les identifiants

Les variables MINIO_ROOT_USER et MINIO_ROOT_PASSWORD définissent le compte administrateur :
Fenêtre de terminal
```
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=motdepasse123  # Minimum 8 caractères
```
Démarrer le serveur
Fenêtre de terminal
```
minio server /data/minio --console-address ":9001"
```
Le serveur écoute sur :
- Port 9000 : API S3
- Port 9001 : Console web

Vérifier le fonctionnement

curl http://127.0.0.1:9000/minio/health/live
# (réponse vide = OK)

Accéder à la console

Ouvrez http://127.0.0.1:9001 dans votre navigateur. Connectez-vous avec les identifiants définis.

Démarrage en tant que service

Pour un démarrage automatique, créez un fichier systemd :

sudo tee /etc/systemd/system/minio.service > /dev/null << 'EOF'
[Unit]
Description=MinIO Object Storage
After=network.target

[Service]
User=minio
Group=minio
Environment="MINIO_ROOT_USER=admin"
Environment="MINIO_ROOT_PASSWORD=motdepasse123"
ExecStart=/usr/local/bin/minio server /data/minio --console-address ":9001"
Restart=always

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now minio

mc : le client CLI

mc (MinIO Client) permet de gérer MinIO en ligne de commande.

go install github.com/minio/mc@latest

mise use -g mc@latest
# ou
asdf plugin add mc && asdf install mc latest && asdf global mc latest

Vérifiez l’installation :

mc --version
# mc version DEVELOPMENT.GOGET
# Runtime: go1.25.6 linux/amd64

Configuration d’un alias

Un alias associe un nom à un serveur MinIO :

mc alias set local http://127.0.0.1:9000 admin motdepasse123
# Added `local` successfully.

Listez les alias configurés :

mc alias list

Opérations sur les buckets

Créez un bucket :

mc mb local/mon-bucket
# Bucket created successfully `local/mon-bucket`.

Listez les buckets :

mc ls local/
# [2026-02-10 09:45:18 CET]     0B mon-bucket/

Opérations sur les objets

Uploadez un fichier :

echo "Contenu de test" > test.txt
mc cp test.txt local/mon-bucket/
# test.txt: 16 B / 16 B

Listez les objets d’un bucket :

mc ls local/mon-bucket/
# [2026-02-10 10:00:00 CET]    16B STANDARD test.txt

Téléchargez un objet :

mc cp local/mon-bucket/test.txt downloaded.txt
cat downloaded.txt
# Contenu de test

Supprimez un objet :

mc rm local/mon-bucket/test.txt

Gestion des utilisateurs et politiques

MinIO supporte une gestion fine des accès via des utilisateurs et des politiques.

Créer un utilisateur

mc admin user add local alice motdepasse456
# Added user `alice` successfully.

Listez les utilisateurs :

mc admin user list local
# enabled    alice

Appliquer une politique

Les politiques prédéfinies incluent :

Politique	Permissions
`readonly`	Lecture seule sur tous les buckets
`readwrite`	Lecture et écriture
`writeonly`	Écriture seule
`diagnostics`	Accès aux métriques

Attachez une politique à un utilisateur :

mc admin policy attach local readwrite --user alice
# Attached Policies: [readwrite]
# To User: alice

Vérifiez les politiques d’un utilisateur :

mc admin user info local alice
# AccessKey: alice
# Status: enabled
# PolicyName: readwrite

Versioning des objets

Le versioning conserve l’historique des modifications d’un objet.

Activez le versioning sur un bucket :

mc version enable local/mon-bucket
# local/mon-bucket versioning is enabled

Vérifiez le statut :

mc version info local/mon-bucket
# local/mon-bucket versioning is enabled

Chaque mise à jour d’un objet crée une nouvelle version. Listez les versions :

mc ls --versions local/mon-bucket/

Configuration TLS/SSL

Pour sécuriser les communications, activez TLS.

Générer les certificats

Avec mkcert pour un environnement local :
Fenêtre de terminal
```
mkcert -key-file private.key -cert-file public.crt minio.local
```

Placer les certificats

mkdir -p ~/.minio/certs
mv private.key public.crt ~/.minio/certs/

Redémarrer MinIO

MinIO détecte automatiquement les certificats au démarrage :
Fenêtre de terminal
```
minio server /data/minio --console-address ":9001"
```
Vérifier

Accédez à https://minio.local:9001. Le navigateur doit afficher une connexion sécurisée.

Cas d’usage

Backend Terraform

Stockez les états Terraform dans MinIO :

terraform {
  backend "s3" {
    endpoints = {
      s3 = "http://127.0.0.1:9000"
    }
    bucket = "terraform-states"
    key    = "mon-projet/terraform.tfstate"
    region = "main"

    access_key = "admin"
    secret_key = "motdepasse123"

    skip_credentials_validation = true
    skip_metadata_api_check     = true
    skip_region_validation      = true
    skip_requesting_account_id  = true
    use_path_style              = true
  }
}

Créez le bucket au préalable :

mc mb local/terraform-states

Cible de sauvegarde

Configurez Restic pour sauvegarder vers MinIO :

export AWS_ACCESS_KEY_ID=admin
export AWS_SECRET_ACCESS_KEY=motdepasse123
restic -r s3:http://127.0.0.1:9000/backups init
restic -r s3:http://127.0.0.1:9000/backups backup /home/user/documents

Informations du serveur

Obtenez des détails sur l’état du serveur :

mc admin info local
# ●  127.0.0.1:9000
#    Uptime: 1 hour
#    Version: DEVELOPMENT.GOGET
#    Network: 1/1 OK
#    Drives: 1/1 OK

Dépannage

Le serveur ne démarre pas

Vérifiez que le port 9000 n’est pas déjà utilisé :

ss -tlnp | grep 9000

Vérifiez les permissions sur le répertoire de données :

ls -la /data/minio

Erreur “Access Denied”

Vérifiez que l’alias mc utilise les bons identifiants :

mc alias list local

Recréez l’alias si nécessaire :

mc alias set local http://127.0.0.1:9000 admin motdepasse123

Health check échoue

Testez la connectivité réseau :

curl -v http://127.0.0.1:9000/minio/health/live

Vérifiez les logs du serveur pour identifier l’erreur.

À retenir

MinIO est un serveur de stockage objet compatible S3, simple et performant
Depuis fin 2025, l’édition Community est en mode maintenance (source uniquement)
Pour de nouveaux projets critiques, évaluez AIStor, Ceph ou SeaweedFS
mc est le client CLI pour gérer buckets, objets et utilisateurs
Les variables MINIO_ROOT_USER et MINIO_ROOT_PASSWORD définissent l’administrateur
Le versioning conserve l’historique des objets
MinIO s’intègre comme backend Terraform ou cible de sauvegarde

Prochaines étapes

Sauvegardes avec Restic

Configurez des sauvegardes incrémentales vers MinIO. Lire le guide

Alternative : SeaweedFS

Découvrez cette alternative active à MinIO. Voir la documentation

Outscale Object Storage

Stockage objet S3 managé chez Outscale. Lire le guide