MinIO est un serveur de stockage objet compatible S3 simple, mais plutôt complet. Il permet notamment de répartir vos données sur plusieurs périphériques de stockage et plusieurs serveurs pour limiter les pannes. Mais il faut pour cela en passer par un peu de configuration. On vous explique comment procéder.

En juin dernier, nous vous présentions un serveur de stockage objet compatible avec l'API S3 d'Amazon Web Services : MinIO. Une solution open source, facile à mettre en place sur différentes plateformes. L'entreprise est aussi à l'origine d'un client disposant des mêmes avantages, nommé sobrement MinIO Client.

Outre sa simplicité de mise en œuvre, son serveur permet différents niveaux de redondances. Tout d'abord multipliant les périphériques de stockage dans un même serveur (scale-in), avec gestion des codes d'effacement (erasure code via Reed-Solomon) et protection contre la dégradation des données (Bit Rot) via HighwayHash.

Mais aussi en multipliant les instances (scale-out) afin de répartir la charge, limiter les risques de perte de données et autres indisponibilités. La procédure est facile à suivre tout en ouvrant la voie à des fonctionnalités avancées pour ceux qui souhaitent aller plus loin ou passer en production.

Dans ce tutoriel, nous vous expliquerons comment installer MinIO sur différents serveurs, différents périphériques de stockage et surtout comment unifier tout cela à travers une unique adresse IP d'accès (et donc un domaine).

• MinIO Client : gérez du stockage compatible S3 en ligne de commandes (ou dans des scripts)
• MinIO : créez simplement votre propre service de stockage objet, compatible S3 et distribué
• Stockage objet distribué : installez MinIO via plusieurs serveurs et volumes de stockage

Installer MinIO sur un premier serveur

Dans la précédente partie de ce dossier, nous vous avions expliqué comment installer MinIO sous Windows 10. Cette fois nous utiliserons des instances Scaleway (DEV1-S) sous Ubuntu 20.04 LTS, dotées de 20 Go de stockage. Il est possible de leur adjoindre des volumes de type Block Storage.

MinIO nécessitant au moins quatre périphériques de stockage pour mettre en place une redondance, nous avons ajouté 4x 25 Go pour un coût total de 0,0219 euro HT de l'heure, soit 0,5256 euro HT par jour et par instance :

Une fois l'instance créée, on s'y connecte via OpenSSH et l'IP publique fournie. On arrive sur le système qu'il faut tout d'abord mettre à jour. Comme l'utilisateur courant est root, on peut s'éviter la commande sudo :

apt update && apt full-upgrade -y && apt autoremove -y

On télécharge ensuite MinIO, on le rend exécutable et on le déplace dans le dossier des binaires :

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
mv minio /usr/local/bin
minio

Si tout s'est bien passé, la dernière ligne devrait vous afficher l'aide de MinIO et sa version. On crée ensuite un utilisateur dédié, qui ne pourra pas de connecter à la machine (shell /sbin/nologin). Il sera uniquement utilisé pour l'accès aux données par MinIO. On lui donne la propriété de l'exécutable que l'on vient de déplacer :

useradd -r minio -s /sbin/nologin
chown minio:minio /usr/local/bin/minio

On créé alors un espace de travail pour tester MinIO. On le place dans le dossier partagé par les utilisateurs du système. Là aussi on transfère la propriété à celui que l'on vient de créer :

mkdir /usr/local/share/minio
chown minio:minio /usr/local/share/minio

Votre serveur MinIO est prêt à être lancé :

minio server /usr/local/share/minio/

Pour y accéder, tapez l'URL suivante dans la barre d'adresse de votre navigateur :

http://IP.de.votre.serveur:9000

Les identifiants par défaut sont minioadmin/minioadmin. Si cela ne fonctionne pas, pensez  à vérifier que le port 9000 de votre machine est ouvert et accessible depuis l'extérieur (non bloqué par votre hébergeur).

Redondance sur plusieurs volumes de stockage

Passons maintenant à la configuration des 4x 25 Go de stockage accessibles depuis notre serveur. On commence tout d'abord par couper MinIO (CTRL+C) et supprimer le dossier créé pour ce premier essai :

rm -rf /usr/local/share/minio

On liste ensuite les périphériques de stockage liés à notre serveur :

lsblk

Ce qui donne dans notre cas le résultat suivant :

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 23.3G 0 disk
sdb 8:16 0 23.3G 0 disk
sdc 8:32 0 23.3G 0 disk
sdd 8:48 0 23.3G 0 disk
vda 252:0 0 18.6G 0 disk
├─vda1 252:1 0 18.5G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi

Les périphériques qui nous intéressent sont nommés sda, sdb, sdc et sdd.  Nous les montons comme /mnt/minio1 à /mnt/minio4. Une séquence qui sera importante pour la suite puisqu'elle facilitera le lancement de MinIO. On pourrait aussi utiliser le stockage local avec un lien symbolique vers /mnt/minio5 par exemple.

mkdir /mnt/minio{1..4}

mkfs.ext4 /dev/sda
mkfs.ext4 /dev/sdb
mkfs.ext4 /dev/sdc
mkfs.ext4 /dev/sdd

echo "/dev/sda /mnt/minio1 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdb /mnt/minio2 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdc /mnt/minio3 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdd /mnt/minio4 ext4 defaults 0 0" >> /etc/fstab

reboot

La machine redémarre, on s'y reconnecte. Normalement vous devriez disposer de vos quatre dossiers accessibles dans /mnt/. On change leur propriétaire et on lance le serveur MinIO en les utilisant comme cible de stockage :

chown minio:minio /mnt/minio{1..4}
minio server /mnt/minio{1..4}

Et Voilà ! Vous disposez d'un serveur qui va disséminer ses données à travers quatre volumes de Block Storage. Vous pouvez changer les identifiants de connexion avec les deux commandes suivantes :

export MINIO_ACCESS_KEY=clé_d_accès
export MINIO_SECRET_KEY=clé_secrète

D'autres paramètres sont détaillés par ici. Pour activer un accès HTTPS, c'est par là.

Utilisation de MinIO comme un service

Maintenant que notre serveur fonctionne et peut être démarré manuellement, automatisons le processus à travers un service. Tout d'abord en créant un fichier de configuration des variables d'environnement et en l'éditant :

nano /etc/default/minio

Ajoutez-y les lignes suivantes :

MINIO_ACCESS_KEY="clé_d_accès"
MINIO_SECRET_KEY="clé_secrète"
MINIO_VOLUMES="/mnt/minio{1...4}"
MINIO_OPTS="-C /etc/minio --address IP.privée.du.serveur:9000"

Attention, ici il faut bien mettre l'IP privée du serveur sur son réseau local et non son IP publique (celle par laquelle vous y accédez). L'hébergeur vous communique les deux. Pensez à adapter les différentes valeurs à votre besoin et à utiliser des clés complexes et à les garder en sûreté. Enregistrez et quittez (CTRL+X).

Scaleway détaille les adresses IP de ses instances dans la liste des informations les concernant

On change ensuite le propriétaire du fichier :

chown minio:minio /etc/default/minio

MinIO fournit un fichier type pour déclarer son application comme un service On le modifie pour créer le nôtre :

nano minio.service

On y ajoute le contenu suivant :

[Unit]
Description=MinIO
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
WorkingDirectory=/usr/local/

EnvironmentFile=/etc/default/minio
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_VOLUMES}\" ]; then echo \"Variable MINIO_VOLUMES not set in /etc/default/minio\"; exit 1; fi"
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES

# Let systemd restart this service always
Restart=always

# Specifies the maximum file descriptor number that can be opened by this process
LimitNOFILE=65536

# Disable timeout logic and wait until process is stopped
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

On l'enregistre (CTRL+X), on le déplace dans le dossier de Systemd puis on l'active :

mv minio.service /etc/systemd/system
systemctl daemon-reload
systemctl enable minio

On lance le MinIO et on vérifie que tout se passe bien :

systemctl start minio
systemctl status minio

Si tout est au vert, vous pouvez redémarrer le serveur, tout est opérationnel.

Plusieurs serveurs pour un même pool de données

Nous allons maintenant faire fonctionner plusieurs serveurs MinIO ensemble. Il faut pour cela configurer une seconde instance comme on vient de le faire pour la première. Une fois la procédure terminée, vous avez deux serveurs MinIO qui ne sont pas (encore) capables de communiquer ensemble.

On commence par nettoyer les données de nos essais précédents :

rm -rf /mnt/minio1/.minio.sys
rm -rf /mnt/minio2/.minio.sys
rm -rf /mnt/minio3/.minio.sys
rm -rf /mnt/minio4/.minio.sys

Sans cela, les serveurs refuseraient de se lancer en accès unifié, puisqu'ils contiennent déjà des données issues de la configuration précédente. Il faut ensuite changer la façon de les lancer. Pour cela, vous devez noter les IP privées de chacun de vos serveurs et les ajouter à leur fichier host de manière à ce qu'ils soient accessibles par un nom itératif : minio-server1, minio-server2, etc. :

echo "IP.privée.serveur.1 minio-server1" >> /etc/hosts
echo "IP.privée.serveur.2 minio-server2" >> /etc/hosts

Notez que vous pouvez faire de même sur trois ou quatre serveurs ou plus si vous le désirez. Une fois la procédure terminée, il faut modifier le fichier de configuration pour préciser le nom des différences instances :

nano /etc/default/minio

Remplacez la valeur correspondant à la définition des volumes par la suivante :

MINIO_VOLUMES="http://minio-server{1...2}/mnt/minio{1...4}"

Ici on voit bien l'intérêt de nommer les machines et les volumes d'une manière particulière. Si l'on ne le faisait pas, il faudrait préciser chaque adresse de serveur, chaque nom de volume de manière différente, et donc avoir une liste à maintenir bien plus longue. Autre avantage, si vous remplacez un serveur, il suffit de modifier le fichier host.

Redémarrez les deux machines. Tout devrait fonctionner à merveille.

Bonus : on utilise nginx pour n'utiliser qu'une adresse IP

Désormais, que vous alliez sur la première ou la seconde IP, vous obtiendrez la même interface et les mêmes données. Mais laquelle communiquer à vos visiteurs, ou même pour la redirection d'un nom de domaine ?

Pour éviter ce problème, on utilise un serveur qui se chargera de renvoyer les visiteurs vers l'une ou l'autre des IP. Scaleway propose un répartisseur de charge (load balancer), mais un tel outil n'est pas nécessaire ici. On va se contenter d'une instance avec nginx configurée pour renvoyer aléatoirement sur l'un de nos deux serveurs.

Pour cela on configure une DEV1-S sous Ubuntu 20.04 LTS. On la met à jour et on installe nginx :

apt update && apt full-upgrade -y && apt autoremove -y
apt install nginx -y
systemctl start nginx
systemctl status nginx

Si vous tapez l'adresse IP publique de votre serveur dans un navigateur, la page par défaut devrait s'afficher :

On édite ensuite le fichier de configuration du serveur :

nano /etc/nginx/sites-enabled/default

On remplace son contenu par les lignes suivantes :

upstream minio {
    server IP.privée.serveur.1:9000;
    server IP.privée.serveur.2:9000;
}

server {
    server_name _;
    listen 80;
    listen [::]:80;

    access_log /var/log/nginx/reverse-access.log;
    error_log /var/log/nginx/reverse-error.log;

    location / {
        proxy_pass http://minio;
    }
}

Attention à bien utiliser là encore les IP privées de vos serveurs et non leurs IP publiques, toutes les machines étant hébergées au sein d'un même service, autant en profiter. Une fois le fichier enregistré et fermé (CTRL+X) on peut redémarrer le serveur nginx. Vous pourrez ensuite utiliser son IP pour accéder à vos instances MinIO :

systemctl restart nginx

Vous pouvez dès lors rediriger votre nom de domaine. Scaleway détaille la procédure à suivre pour activer un accès HTTPS via nginx. Vous pouvez également accéder à vos données via un client compatible S3 comme celui de MinIO, renforcer la sécurité de vos instances, limiter les accès depuis l'extérieur à vos serveurs exécutant MinIO, ajouter des logs, alertes et autres procédures. Pensez également à mettre en place des sauvegardes vers l'extérieur.

• Qu'est-ce que la stratégie de sauvegarde 3-2-1 ?

Notez enfin que MinIO propose des procédures de déploiement simplifiées via Docker Swarm ou Kubernetes si vous voulez aller un peu plus loin dans l'automatisation de la mise en place d'une architecture distribuée.

Nous avons mis placé les scripts et fichiers de configuration de ce tutoriel dans un Gist public.