MinIO Docker : Guide de configuration pour le stockage d'objets compatible S3

Avez-vous besoin d'un stockage d'objets pour le développement, mais vous préférez éviter la configuration et les frais liés à AWS S3 ?

MinIO vous offre un stockage compatible S3 qui fonctionne partout : sur votre ordinateur portable, une machine virtuelle ou un cluster Kubernetes. Il s'agit d'un logiciel libre, ce qui signifie qu'il est indépendant de tout fournisseur et que vous n'aurez pas de factures inattendues à la fin du mois. De plus, grâce à Docker, l'exécution de MinIO est simplifiée, car il est possible de démarrer un serveur de stockage en quelques secondes sans avoir à installer quoi que ce soit directement sur votre machine.

Les conteneurs Docker isolent MinIO de votre système tout en vous offrant un contrôle total sur la configuration et la persistance des données. Vous pouvez tester les API S3 localement, simuler des configurations de stockage de production ou exécuter un stockage d'objets léger pour les petits projets.

Dans cet article, je vais vous expliquer comment exécuter MinIO avec Docker, vérifier son bon fonctionnement et configurer les options les plus courantes.

Si vous débutez avec Docker, consacrez un samedi après-midi à la maîtrise des principes fondamentaux - Introduction à Docker de DataCamp. Introduction à Docker de DataCamp vous permettra d'acquérir les connaissances nécessaires.

Conditions préalables

Trois éléments sont nécessaires pour exécuter MinIO avec Docker.

Docker est installé et exécute sur votre machine. Vous pouvez vérifier cela en exécutant la commande « docker --version » dans votre terminal. Si vous obtenez un numéro de version, vous pouvez continuer.

Connaissance de base des commandes Docker commandes Docker. Il est important de savoir comment démarrer et arrêter des conteneurs, consulter les journaux et utiliser les images Docker. Si vous avez déjà utilisé docker run ou travaillé avec Docker Compose auparavant, vous n'aurez aucune difficulté.

Répertoire local pour le stockage persistant. MinIO nécessite un emplacement pour stocker vos données en dehors du conteneur. Veuillez créer un répertoire vide sur votre ordinateur hôte. Par exemple, ~/minio/data convient parfaitement.

C'est tout. La liste est concise et simple, mais veuillez vous assurer de cocher toutes les cases avant de poursuivre.

Comment exécuter MinIO avec Docker (configuration à nœud unique)

Une configuration MinIO à nœud unique exécute une instance de MinIO dans un conteneur Docker et stocke toutes vos données à un seul emplacement.

Cette configuration convient aux charges de travail de développement, de test et de production à petite échelle qui ne nécessitent pas de haute disponibilité ni de stockage distribué. Vous bénéficiez d'une compatibilité API S3 totale sans la complexité liée à l'exécution de plusieurs nœuds.

Exécution de MinIO avec Docker Run

La commande ` docker run ` lance MinIO dans un nouveau conteneur avec toutes les configurations définies en une seule ligne.

Voici la commande de base :

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

Exécution de MinIO avec docker run

Analysons le rôle de chaque partie.

• Le port 9000 est le point de terminaison API auquel vos applications se connectent pour télécharger et envoyer des fichiers. C'est ici que les clients compatibles S3 transmettent leurs requêtes.

• Le port 9001 héberge la console Web à partir de laquelle vous pouvez gérer les compartiments, définir les autorisations et surveiller le stockage. Vous utiliserez ceci pour vérifier que MinIO fonctionne correctement.

• Le drapeau ` -v ~/minio/data:/data ` mappe votre répertoire local à l'emplacement de stockage du conteneur. Tout ce que MinIO stocke est placé dans le répertoire ~/minio/data sur votre machine hôte. Lorsque vous arrêtez ou supprimez le conteneur, vos données restent en sécurité dans ce répertoire.

• Les variables d'environnement permettent de définir vos identifiants d'accès. MINIO_ROOT_USER correspond à votre nom d'utilisateur administrateur et MINIO_ROOT_PASSWORD correspond au mot de passe. Ce sont les identifiants que vous utiliserez pour vous connecter à la console Web et configurer l'accès à l'API.

• L'argument server /data indique à MinIO de fonctionner en mode serveur et d'utiliser /data comme répertoire de stockage. Le drapeau ` --console-address ":9001" ` indique le port sur lequel la console Web est à l'écoute.

Il existe une autre méthode pour exécuter MinIO, particulièrement utile si vous n'appréciez pas les commandes longues et multi-lignes du terminal.

Remarque: MinIO ne met plus à jour ses images Docker Hub et Quay (depuis octobre 2025). Le code présenté dans cet article fonctionne toujours pour le développement local, mais pour une utilisation en production, il est recommandé d'envisager des alternatives maintenues telles que l'image MinIO de Chainguard (cgr.dev/chainguard/minio:latest).

Exécution de MinIO avec Docker Compose

Docker Compose vous permet de définir votre configuration MinIO dans un fichier YAML au lieu de saisir de longues commandes.

Cela rend votre configuration reproductible et soumise à un contrôle de version. Vous pouvez partager le fichier avec votre équipe, le valider dans Git et redémarrer MinIO avec exactement les mêmes paramètres à chaque fois.

Veuillez créer un fichier docker-compose.yml:

services:
  minio:
    image: quay.io/minio/minio
    container_name: minio
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./minio/data:/data
    command: server /data --console-address ":9001"

La structure reflète la commande docker run, mais organise tout en sections nommées. Les ports, les variables d'environnement et les volumes disposent chacun de leur propre bloc.

Le mappage de volume fonctionne de la même manière : ./minio/data:/data crée un répertoire dans votre dossier actuel et le monte dans le conteneur. Le chemin d'accès ./ fait référence à l'emplacement du fichier docker-compose.yml.

Vous pouvez maintenant démarrer MinIO avec :

docker-compose up -d

Exécution de MinIO avec Docker Compose

Le drapeau ` -d ` exécute le conteneur en arrière-plan. Votre terminal ne sera pas bloqué par les journaux MinIO, et le conteneur continuera de fonctionner après la fermeture du terminal.

Veuillez cesser de :

docker-compose down

Compose est plus adapté au développement, car il permet d'ajouter des contrôles de santé, des politiques de redémarrage et plusieurs services dans le même fichier. Si vous avez besoin d'ajouter une base de données ou d'autres services à MinIO ultérieurement, il vous suffit d'ajouter d'autres entrées sous services:.

Comment accéder à MinIO et vérifier qu'il est opérationnel

Maintenant que MinIO est opérationnel, il est recommandé de vérifier qu'il a démarré correctement avant de l'utiliser pour le stockage.

Il existe deux méthodes pour vérifier votre configuration : la console Web pour une confirmation visuelle et le client MinIO pour une vérification en ligne de commande.

Utilisation de la console Web MinIO

Veuillez ouvrir votre navigateur et vous rendre sur http://localhost:9001.

Vous verrez apparaître un écran de connexion vous demandant vos identifiants :

Interface utilisateur Web MinIO

Vous pouvez vous connecter à l'aide des identifiants que vous avez fournis en tant que variables d'environnement - admin/password123 dans mon cas.

Une fois connecté, vous serez redirigé vers le tableau de bord MinIO. La page principale affiche l'utilisation du stockage, le nombre de compartiments et l'état du système. La barre latérale gauche propose des options pour créer des compartiments, gérer les utilisateurs et afficher les métriques.

Création d'un compartiment via l'interface utilisateur Web MinIO

Veuillez créer un compartiment de test afin de vérifier que tout fonctionne correctement. Veuillez cliquer sur « Compartiments » dans la barre latérale, puis sur « Créer un compartiment ». Veuillez lui attribuer un nom tel que « test-bucket » et cliquer sur « Create ». Si le compartiment apparaît dans votre liste, MinIO fonctionne correctement et stocke les données.

Création d'un compartiment via l'interface utilisateur Web MinIO

Utilisation du client MinIO (mc)

Le client MinIO est un outil en ligne de commande qui vous permet d'interagir avec MinIO de la même manière que vous le feriez avec l'interface CLI AWS.

Veuillez exécuter l'une des commandes suivantes pour procéder à l'installation :

# macOS
brew install minio/stable/mc

# Linux
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/

Veuillez maintenant exécuter cette commande pour connecter le client à votre instance MinIO locale :

mc alias set local http://localhost:9000 admin password123

Cela crée un alias nommé local qui pointe vers votre serveur MinIO. Vous pouvez désormais exécuter des commandes sur celui-ci.

Veuillez énumérer vos catégories :

mc ls local

Liste des compartiments

Si vous avez créé le compartiment de test précédemment, il apparaîtra dans la sortie. Si la commande renvoie un résultat vide ou affiche vos compartiments, MinIO fonctionne correctement.

Vous pouvez désormais télécharger un fichier test dans le compartiment :

echo "test" > test.txt
mc cp test.txt local/test-bucket/

Veuillez ensuite vérifier qu'il est bien présent :

mc ls local/test-bucket

Si vous voyez « test.txt » dans la sortie, cela signifie que vous avez tout configuré correctement.

Répertorier les fichiers dans un compartiment

Voici quelques dépannage si vous rencontrez des difficultés :

• Veuillez vérifier si le conteneur est en cours d'exécution à l'aide de la commande ` docker ps`. Si vous ne voyez pas de conteneur nommé minio, cela signifie qu'il n'a pas démarré ou qu'il a rencontré un problème.

• Veuillez consulter les journaux à l'adresse suivante : docker logs minio. Veuillez vérifier s'il existe des erreurs concernant les ports déjà utilisés ou des problèmes d'autorisation sur le répertoire de données.

• Si vous rencontrez des difficultés pour accéder à la console Web, veuillez vérifier que les ports ne sont pas bloqués en consultant docker port minio. Vous devriez voir les numéros 9000 et 9001 correctement attribués.

• Si vous rencontrez des erreurs d'autorisation dans le répertoire de données, veuillez exécuter chmod -R 755 ~/minio/data pour résoudre les problèmes d'accès.

Stockage persistant et volumes de données

Les conteneurs sont éphémères par défaut : lorsque vous supprimez un conteneur, tout son contenu disparaît.

MinIO stocke des objets, des métadonnées et des fichiers de configuration. Si vous ne configurez pas correctement le stockage persistant, vous perdrez toutes vos données dès que vous redémarrerez ou supprimerez le conteneur.

Utilisation de volumes locaux avec Docker

Les volumes Docker et les montages liés garantissent la sécurité de vos données en dehors du conteneur.

Lorsque vous utilisez -v ~/minio/data:/data ou mappez un volume dans Docker Compose, MinIO enregistre toutes les données sur votre machine hôte. Le conteneur lit et écrit des fichiers dans /data, mais ces fichiers se trouvent en réalité dans ~/minio/data sur votre hôte.

Lorsque vous arrêtez le conteneur, le supprimez ou même effacez l'image, vos données restent dans l'~/minio/data. Veuillez démarrer un nouveau conteneur MinIO pointant vers le même répertoire et tous vos compartiments, objets et paramètres seront rétablis exactement comme vous les aviez laissés.

Si vous ne mappez pas de volume, MinIO utilise le système de fichiers interne du conteneur. Tout fonctionne correctement jusqu'à ce que vous arrêtiez le conteneur. Lorsque vous le redémarrez, MinIO démarre à zéro, sans buckets, sans objets et sans configuration.

L'exemple de composition que j'ai présenté précédemment crée un dossier minio/data à l'emplacement exact de votre fichier de composition :

Dossier de données MinIO

Erreurs courantes en matière de stockage

L'exécution sans volume est l'erreur la plus courante.

Vous lancez MinIO, téléchargez des fichiers, créez des compartiments, et tout semble fonctionner correctement. Ensuite, veuillez redémarrer le conteneur pour effectuer une mise à jour ou modifier la configuration. Toutes vos données ont été perdues car elles étaient stockées dans le conteneur et non sur votre hôte.

Veuillez toujours vérifier si votre commande Docker ou votre fichier Compose comporte un mappage de volume avant d'introduire des données réelles dans MinIO.

Des problèmes d'autorisation peuvent survenir lorsque Docker ne parvient pas à écrire dans votre répertoire monté. surviennent lorsque Docker ne parvient pas à écrire dans votre répertoire monté.

Le processus MinIO à l'intérieur du conteneur s'exécute en tant qu'utilisateur spécifique. Si cet utilisateur ne dispose pas des autorisations d'écriture sur le répertoire hôte, MinIO peut rencontrer des difficultés au démarrage ou échouer silencieusement lors de la tentative de stockage d'objets.

Vous pouvez résoudre ce problème en vous assurant que votre répertoire de données est accessible en écriture :

chmod -R 755 ~/minio/data

Ou exécutez le conteneur avec un utilisateur correspondant à votre utilisateur hôte :

docker run --user $(id -u):$(id -g) ...

En résumé, configurez correctement vos volumes une fois pour toutes et vous n'aurez plus à vous soucier de la perte de données.

Variables d'environnement et configuration de base

MinIO lit sa configuration à partir des variables d'environnement lors de son démarrage.

Cela signifie que vous pouvez modifier le comportement de MinIO sans avoir à modifier les fichiers de configuration ni à reconstruire les conteneurs. Veuillez définir ces variables dans votre commande ` docker run ` ou dans votre fichier Docker Compose.

Clés d'accès et identifiants

MinIO nécessite deux variables d'environnement pour l'authentification : MINIO_ROOT_USER et MINIO_ROOT_PASSWORD.

Ces éléments créent le compte administrateur racine qui dispose d'un contrôle total sur votre instance MinIO. L'utilisateur root peut créer des compartiments, gérer d'autres utilisateurs, définir des politiques et accéder à tous les objets stockés.

Veuillez les configurer de la manière suivante dans docker run:

-e "MINIO_ROOT_USER=admin" \
-e "MINIO_ROOT_PASSWORD=your-secure-password"

Ou dans Docker Compose :

environment:
  MINIO_ROOT_USER: admin
  MINIO_ROOT_PASSWORD: your-secure-password

Veuillez éviter d'utiliser les identifiants par défaut en production. Les exemples présentés dans cet article utilisent admin et password123 pour des raisons de simplicité, mais il s'agit de choix peu recommandables pour des déploiements réels.

Veuillez choisir un mot de passe sécurisé d'au moins 8 caractères. Il est préférable d'utiliser des identifiants générés de manière aléatoire et de les stocker dans un gestionnaire de mots de passe ou un système de gestion des secrets.

Veuillez éviter d'intégrer de manière statique les informations d'identification dans les fichiers Docker Compose que vous soumettez au contrôle de version. Veuillez utiliser des fichiers d'environnement à la place :

environment:
  MINIO_ROOT_USER: ${MINIO_ROOT_USER}
  MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}

Veuillez ensuite créer un fichier .env contenant vos informations d'identification réelles et l'ajouter à .gitignore.

Configuration des ports et mise en réseau

MinIO nécessite deux ports pour fonctionner correctement.

• Le port 9000 gère l'API S3. C'est ici que vos applications envoient des requêtes pour stocker et récupérer des objets. Tous les clients compatibles S3 se connectent à ce port.
• Le port 9001 est dédié à la console Web. Il s'agit de l'interface du navigateur à partir de laquelle vous gérez MinIO via une interface graphique.

Veuillez mapper ces ports dans votre commande Docker :

-p 9000:9000 -p 9001:9001

Les conflits de port surviennent lorsqu'un autre service utilise déjà les ports 9000 ou 9001 sur votre hôte.

Vous rencontrerez une erreur telle que « bind: address already in use » lors du démarrage du conteneur. Veuillez résoudre ce problème en effectuant le mappage vers différents ports hôtes :

-p 9090:9000 -p 9091:9001

L'API de MinIO est désormais accessible à l'adresse http://localhost:9090 et la console à l'adresse http://localhost:9091. Le conteneur utilise toujours les numéros 9000 et 9001 en interne, mais en externe, vous y accédez via des ports différents.

Ces commandes vous aideront à vérifier ce qui utilise un port avant de démarrer MinIO :

# Linux/macOS
lsof -i :9000
lsof -i :9001

# Windows
netstat -ano | findstr :9000
netstat -ano | findstr :9001

Vérifier ce qui utilise un port

Si vous exécutez plusieurs instances MinIO sur la même machine, veuillez attribuer à chacune d'elles des mappages de ports uniques afin d'éviter tout conflit entre elles.

Exécution de MinIO en mode distribué avec Docker

Le mode distribué exécute MinIO sur plusieurs serveurs équipés de plusieurs disques afin d'assurer une haute disponibilité et la redondance des données.

Vous n'avez pas besoin de cela pour le développement ou les tests. Le mode à nœud unique convient parfaitement à la plupart des cas d'utilisation. Veuillez ignorer cette section à moins que vous ne planifiez un déploiement de production qui doit rester en ligne même en cas de défaillance des serveurs.

Quand la distribution MinIO est-elle pertinente ?

Veuillez utiliser le mode distribué lorsque vous avez besoin d'une tolérance aux pannes.

Si un serveur tombe en panne dans une configuration distribuée, MinIO continue de fonctionner et vos données restent accessibles. Le système utilise le codage d'effacement pour répartir les objets sur plusieurs disques et serveurs, ce qui vous permet de perdre des disques ou des nœuds entiers sans perdre de données.

Le mode distribué est également nécessaire pour le stockage à grande échelle. Si vous stockez des téraoctets ou des pétaoctets de données, les répartir sur plusieurs machines vous offre de meilleures performances et une plus grande capacité qu'un seul serveur ne pourrait le faire.

Le développement local n'a pas besoin de tout cela. Le mode distribué ajoute de la complexité : vous avez besoin de plusieurs machines ou machines virtuelles, d'un réseau coordonné et d'une configuration minutieuse des disques. Pour tester les API S3 ou exécuter le stockage d'objets sur votre ordinateur portable, le mode à nœud unique répond à tous vos besoins.

Les environnements de production utilisent le mode distribué lorsque les temps d'arrêt ne sont pas acceptables et que la perte de données serait préjudiciable. Pensez aux systèmes de sauvegarde, aux lacs de données ou aux applications où les utilisateurs dépendent d'une disponibilité constante du stockage.

Aperçu général de la configuration de haut niveau

MinIO distribué nécessite au moins quatre disques répartis sur plusieurs nœuds.

Chaque nœud exécute un conteneur MinIO, et tous les nœuds doivent présenter la même configuration de disque. Il n'est pas possible de combiner des nœuds à disque unique avec des nœuds à disques multiples, ni de modifier le nombre de disques après la configuration.

Une configuration distribuée de base se présente comme suit :

• Quatre serveurs (ou machines virtuelles) sur lesquels MinIO est installé
• Plusieurs disques sur chaque serveur dédié à MinIO
• Connectivité réseau entre tous les nœuds
• Chemins d'accès identiques sur chaque nœud

Vous pouvez gérer la coordination dans un seul fichier Compose, mais je vous préviens, il sera volumineux. Il est nécessaire de définir tous les nœuds, de configurer leurs chemins d'accès aux lecteurs et de les démarrer simultanément.

Voici un exemple complet pour quatre nœuds avec deux disques chacun :

version: "3.9"

services:
  minio1:
    image: quay.io/minio/minio:latest
    hostname: minio1
    container_name: minio1
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9001:9000"
      - "9091:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio1/data1:/data1
      - ./data/minio1/data2:/data2
    networks:
      - minio

  minio2:
    image: quay.io/minio/minio:latest
    hostname: minio2
    container_name: minio2
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9002:9000"
      - "9092:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio2/data1:/data1
      - ./data/minio2/data2:/data2
    networks:
      - minio

  minio3:
    image: quay.io/minio/minio:latest
    hostname: minio3
    container_name: minio3
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9003:9000"
      - "9093:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio3/data1:/data1
      - ./data/minio3/data2:/data2
    networks:
      - minio

  minio4:
    image: quay.io/minio/minio:latest
    hostname: minio4
    container_name: minio4
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9004:9000"
      - "9094:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio4/data1:/data1
      - ./data/minio4/data2:/data2
    networks:
      - minio

networks:
  minio:
    driver: bridge

La syntaxe ` {1...4} ` indique à MinIO de se connecter à quatre nœuds (minio1 à minio4) avec deux disques chacun (data1 et data2). Chaque nœud dispose d'un mappage de port unique, ce qui vous permet d'y accéder individuellement : le nœud 1 utilise 9001/9091, le nœud 2 utilise 9002/9092, et ainsi de suite.

Le réseau de l'minio-distributed permet aux conteneurs de se connecter entre eux par nom d'hôte. Tous les nœuds doivent utiliser les mêmes informations d'identification et présenter la même configuration de disque.

Pour démarrer le cluster, veuillez d'abord créer les répertoires de données, puis exécuter le fichier compose.

mkdir -p data/minio{1..4}/data{1..2}
docker compose up -d

Exécution de MinIO en mode distribué

C'est tout ! Vous pouvez désormais visiter l'une des URL suivantes pour accéder à l'interface utilisateur Web :

• http://localhost:9091
• http://localhost:9092
• http://localhost:9093
• http://localhost:9094

Cependant, veuillez ne pas mettre cela en place à moins que cela ne soit réellement nécessaire - le mode distribué est destiné aux charges de travail de production où la disponibilité et la redondance justifient la complexité supplémentaire.

De plus, vous souhaiterez probablement disposer d'éléments tels que TLS, un point de terminaison à console unique, des volumes/disques externes pour un environnement de production complet.

Problèmes courants lors de l'exécution de MinIO dans Docker

La plupart des problèmes liés à MinIO Docker sont dus à une configuration incorrecte des volumes, des ports ou des informations d'identification.

Voici les problèmes que vous pourriez rencontrer et comment les résoudre rapidement.

Le conteneur démarre, mais l'interface utilisateur Web est inaccessible.

Vous exécutez docker ps et constatez que le conteneur est en cours d'exécution, mais http://localhost:9001 ne renvoie aucun résultat ou expire.

Pour résoudre ce problème, veuillez d'abord vérifier si le port de la console est correctement mappé :

docker port minio

Veuillez consulter le site 9001/tcp -> 0.0.0.0:9001. Si le port 9001 n'apparaît pas dans la liste, cela signifie que vous avez omis de le mapper dans votre commandedocker run d' ou dans votre fichier Compose.

Veuillez également vérifier les journaux MinIO :

docker logs minio

Recherchez la ligne indiquant « Console : http://... » ; celle-ci vous indique l'adresse sur laquelle MinIO est actuellement à l'écoute. Si vous constatez un port différent de celui attendu, il est possible que votre indicateur d' --console-address soit incorrect.

Erreurs d'autorisation sur les volumes montés

MinIO rencontre des difficultés au démarrage ou des messages d'erreur « permission refusée » apparaissent dans les journaux lorsqu'il tente d'écrire dans /data.

Le processus MinIO s'exécute en tant qu'utilisateur spécifique à l'intérieur du conteneur, et cet utilisateur doit disposer d'un accès en écriture à votre répertoire monté. Veuillez corriger ceci en utilisant :

chmod -R 755 ~/minio/data

Ou si vous utilisez Linux, veuillez exécuter le conteneur avec votre identifiant utilisateur :

docker run --user $(id -u):$(id -g) ...

Conflits de ports avec d'autres services

Vous obtenez le message « bind: address already in use » (liaison : adresse déjà utilisée) lors du démarrage du conteneur.

Cela signifie qu'un autre service utilise déjà le port 9000 ou 9001. Veuillez déterminer ce qui l'utilise :

# Linux/macOS
lsof -i :9000
lsof -i :9001

# Windows
netstat -ano | findstr :9000

Veuillez ensuite mapper MinIO à différents ports hôtes :

docker run -p 9090:9000 -p 9091:9001 ...

Veuillez accéder à l'API à l'adresse localhost:9090 et à la console à l'adresse localhost:9091.

Les identifiants ne fonctionnent pas comme prévu

Vous avez configuré MINIO_ROOT_USER et MINIO_ROOT_PASSWORD, mais vous ne parvenez pas à vous connecter ou le conteneur ne démarre pas.

Pour résoudre ce problème, veuillez vérifier si vous avez bien transmis les variables d'environnement :

docker inspect minio | grep -A 5 Env

Veuillez rechercher les termes « MINIO_ROOT_USER » et « MINIO_ROOT_PASSWORD » dans le résultat. Si ces éléments sont absents, il est possible que vous ayez omis les indicateurs d' -e ou la section environment: dans votre fichier Compose.

MinIO exige également que les mots de passe comportent au moins 8 caractères. Si votre mot de passe est plus court, le conteneur pourrait le refuser ou utiliser un mot de passe par défaut à la place.

Si vous avez modifié les informations d'identification d'une configuration existante, veuillez arrêter et supprimer complètement le conteneur, puis recommencer à zéro :

docker stop minio
docker rm minio
docker run ...  # with new credentials

Les anciens fichiers d'identification peuvent persister dans votre répertoire de données et entraîner des conflits.

Meilleures pratiques pour l'exécution de MinIO avec Docker

Veuillez suivre ces pratiques pour éviter les erreurs courantes et garantir la maintenabilité de votre configuration MinIO.

• Veuillez utiliser Docker Compose pour assurer la répétabilité. Un fichier Compose documente votre configuration exacte : ports, volumes, variables d'environnement et commandes. Vous pouvez en contrôler les versions, le partager avec votre équipe et recréer des configurations identiques sur différentes machines. L'exécution de longues commandes docker run à partir de l'historique de votre shell peut entraîner des erreurs et des dérives de configuration.

• Veuillez toujours configurer un stockage persistant. Veuillez mapper un volume ou effectuer un montage lié avant de stocker des données réelles. Les conteneurs sont éphémères : si vous ignorez cette étape, vous perdrez toutes vos données lors du redémarrage du conteneur. Veuillez vérifier votre configuration à l'adresse docker inspect minio et vous assurer que le mappage des volumes est correct.

• Veuillez ne pas inclure vos identifiants dans l'historique des commandes. Veuillez ne pas inclure de mots de passe directement dans les commandes d' docker run s ou les enregistrer dans git dans vos fichiers Compose. Veuillez utiliser les fichiers d'environnement (.env) avec Docker Compose ou transmettre les informations d'identification via les variables d'environnement lors de l'exécution. Veuillez ajouter immédiatement .env à votre .gitignore.

• Veuillez utiliser le mode à nœud unique uniquement pour le développement. Le mode distribué est complexe et long à configurer. Il n'est pas nécessaire d'avoir une haute disponibilité ou un codage d'effacement sur votre ordinateur portable. Conservez les déploiements distribués pour la production, où les temps d'arrêt ont une incidence significative.

• Veuillez surveiller les journaux lors du démarrage. Veuillez exécuter docker logs -f minio lors du premier démarrage de MinIO. Les journaux affichent le point de terminaison API, l'URL de la console et les éventuelles erreurs de configuration. Si quelque chose ne fonctionne pas correctement, vous le remarquerez immédiatement au lieu de vous demander pourquoi rien ne fonctionne.

Veuillez suivre ces pratiques et votre configuration MinIO sera optimale dès le premier jour.

Conclusion

L'exécution de MinIO avec Docker vous permet de disposer d'un stockage d'objets compatible S3 sur votre machine en moins d'une minute.

Pour le développement, les tests et les projets à petite échelle, MinIO à nœud unique dans Docker vous offre tout ce dont vous avez besoin. Vous bénéficiez d'une compatibilité API S3 complète, d'une console Web pour la gestion et d'un contrôle total sur vos données sans dépendre des services cloud ni payer pour un stockage que vous n'utilisez pas.

Commencez par les bases : une simple commande ` docker run ` ou un fichier Docker Compose avec des volumes persistants et des identifiants sécurisés (préférez cette dernière option). Veuillez tester votre configuration, vérifier qu'elle fonctionne correctement et n'ajouter de la complexité que lorsque cela est réellement nécessaire.

Le mode distribué, la haute disponibilité et les configurations de niveau production existent pour une raison, mais cette raison n'est pas le développement local. Veuillez adopter ces configurations lorsque vous déployez en production, lorsque les temps d'arrêt entraînent des coûts financiers ou lorsque vous stockez des données qui ne doivent pas être perdues. En attendant, privilégiez la simplicité et concentrez-vous sur le développement de votre application plutôt que sur la gestion de l'infrastructure.

Lorsque vous serez prêt à vous plonger dans des sujets Docker plus complexes, veuillez consulter notre Containerisation et virtualisation avec Docker et Kubernetes .