présentation officielle

MinIO est un service de stockage d'objets basé sur le protocole open source Apache License v2.0. Il est compatible avec l'interface de service de stockage en nuage Amazon S3 et convient parfaitement au stockage de données non structurées de grande capacité , telles que des images, des vidéos, des fichiers journaux, des données de sauvegarde et des images de conteneur/machine virtuelle, etc., et un fichier objet. peut être de n'importe quelle taille, de plusieurs ko à 5T maximum

MinIO peut être déployé en un seul point, déploiement de cluster distribué, facile à utiliser et à déployer, et peut prendre en charge l'expansion. Le SDK est similaire à Ali OSS, ce qui répond juste à mes besoins. Le seul défaut est qu'il ne prend pas en charge l'expansion dynamique.

Déploiement Docker à nœud unique

Tirez d'abord le miroir et téléchargez la dernière version du miroir

docker pull minio/minio

Démarrez le conteneur, le port de démarrage est 9000 "-v /mnt/data:/data", spécifiez l'adresse de stockage de l'hôte pointant vers le conteneur, le fichier téléchargé est stocké ici, la commande pour démarrer "server /data", spécifiez l'adresse de stockage interne du conteneur en tant que / data

docker run -p 9000:9000 --name minio1 \
 --restart=always \
 --net=host \
  -e MINIO_ACCESS_KEY=minioadmin \
   -e MINIO_SECRET_KEY=minioadmin \
  -v /mnt/data:/data \
  -v /mnt/config:/root/.minio \
  minio/minio server /data

Une fois le démarrage réussi, le navigateur visite http://{ip}:9000, accessKey et secretKey sont requis pour la connexion, et le conteneur docker commence par "minioadmin" par défaut, qui sera affiché après le démarrage

Déploiement binaire Linux à nœud unique

télécharger

mkdir /home/minio/{app,config,data,logs} -p
cd /home/minio/app
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio

Créer un répertoire de données

mkdir /minio_data

script de démarrage

min_server_start.sh

chmod 755 min_server_single.sh

#!/bin/bash
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app	
nohup ${MINIO_HOME}/minio server /minio_data  --address :9000 --console-address :8000 > ${MINIO_HOME}/minio.log 2>&1 &

script de démarrage

bash min_server_single.sh

Une fois le démarrage réussi, le navigateur visite http://{ip}:9000, accessKey et secretKey sont requis pour la connexion, qui sont respectivement admin/12345678 dans le script

Déploiement distribué Linux

Introduction officielle : Distributed Minio nécessite au moins 4 disques durs , et l'utilisation de Distributed Minio introduit automatiquement la fonction de code d'effacement.

Avantages du Minio distribué

Protection des données
Distributed Minio utilise des codes d'effacement pour empêcher l'indisponibilité de plusieurs nœuds et la pourriture des bits.
Le Minio distribué nécessite au moins 4 disques durs, et l'utilisation du Minio distribué introduit automatiquement la fonction de code d'effacement.

Il existe un point de défaillance unique dans le service Minio autonome hautement disponible
, au contraire, s'il s'agit d'un Minio distribué avec N disques durs, tant qu'il y a N/2 disques durs en ligne, vos données sont en sécurité. Mais vous avez besoin d'au moins N/2+1 disques durs pour créer de nouveaux objets .
Par exemple, un cluster Minio à 16 nœuds avec 16 disques durs par nœud, même si 8 serveurs sont en panne, le cluster est toujours lisible, mais vous avez besoin de 9 serveurs pour écrire des données.

Cohérence
Minio en mode distribué et autonome, toutes les opérations de lecture et d'écriture respectent strictement le modèle de cohérence lecture après écriture

préparer l'environnement

192.168.10.159 minion-2
192.168.10.153 minion-1

4 disques durs par nœud

Remarque : Il doit y avoir quatre disques durs et le disque dur est vide, sinon une erreur sera signalée.

#创建挂载点
mkdir /mnt/mongo1
mkdir /mnt/mongo2
mkdir /mnt/mongo3
mkdir /mnt/mongo4
#分区
fdisk /dev/sdc
fdisk /dev/sdd
fdisk /dev/sde
fdisk /dev/sdf
#格式化
mkfs.ext4 /dev/sdc1
mkfs.ext4 /dev/sdd1
mkfs.ext4 /dev/sde1
mkfs.ext4 /dev/sdf1
#加载
mount /dev/sdc1 /mnt/mongo2/
mount /dev/sdd1 /mnt/mongo3/
mount /dev/sde1 /mnt/mongo4/
mount /dev/sdf1 /mnt/mongo1/
#写入系统配置
echo "/dev/sdc1 /mnt/mongo2 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdd1 /mnt/mongo3 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sde1 /mnt/mongo4 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdf1 /mnt/mongo1 ext4 defaults 0 0" >> /etc/fstab

df-h

Assurez-vous que les horloges sont synchronisées

Synchronisation automatique de l'heure de réglage du serveur Centos

scénario de mise en page

Remarque : ignorez ici les méthodes de déploiement non évolutives et les méthodes de déploiement pseudo-distribué.

Démarrez d'abord le cluster à nœud unique minio-1 (vous devrez essayer d'étendre le cluster ultérieurement)

minio_cluster.sh

chmod 755 minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app
nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Démarrer le cluster

bash chmod 755 minio_cluster.sh

vérifier

Méthode d'expansion de cluster

expansion peer-to-peer

Tout d'abord, le concept de conception minimaliste de MinIO fait que le cluster distribué MinIO ne prend pas en charge la méthode d'expansion consistant à ajouter un seul nœud au cluster et à effectuer un ajustement automatique, car l'équilibre des données et la division des groupes d'effacement provoqués par l'ajout d'un seul nœud cause Il apporte des procédures complexes d'ordonnancement et de traitement à l'ensemble du cluster, ce qui n'est pas propice à la maintenance. Par conséquent, MinIO fournit une méthode d'expansion peer-to-peer, c'est-à-dire que le nombre de nœuds et de disques à augmenter doit être égal au cluster d'origine.

Remarque : chaque région ajoutée doit avoir le même nombre de disques (jeu de codes d'effacement) que la région d'origine afin de conserver le même SLA de redondance des données .
Par exemple, la première zone a 8 disques, vous pouvez étendre le cluster à des zones de 16, 32 ou 1024 disques, assurez-vous simplement que le SLA de déploiement est un multiple de la zone d'origine.

Le script de démarrage du nœud minio-1 ajoute la configuration

Pour l'extension de capacité, ajoutez le nœud étendu à la fin de la dernière ligne de la commande d'origine et redémarrez le cluster.

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app
nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} http://minio-2/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Script de démarrage de la synchronisation

Synchronisez le script de démarrage avec le nœud minio-2, puis les deux nœuds démarrent le service.

vérifier

Expansion de la fédération

MinIO fournit officiellement un autre mécanisme d'expansion - l'expansion fédérée, c'est-à-dire qu'en introduisant etcd, plusieurs clusters distribués MinIO sont logiquement formés dans une fédération, fournissant des services externes dans leur ensemble et fournissant un espace de noms unifié. L'architecture du cluster fédéré MinIO est illustrée à la Figure 3-1.

Avantages et inconvénients de l'expansion fédérée

Par rapport à l'expansion peer-to-peer, les avantages de l'expansion de la fédération sont : ① chaque cluster de la fédération ne nécessite pas que le nombre de nœuds et de disques soit égal ; ② la fédération peut être étendue indéfiniment et de nouveaux clusters sont continuellement ajoutés ; ③ si un cluster de la fédération échoue, l'échec n'affectera pas les autres clusters de la fédération pour fournir des services. L'inconvénient est qu'etcd doit être introduit en plus et que le processus de configuration est plus compliqué.

Il a été vérifié que le cluster fédéré présente un défaut. Lorsque le cluster A est plein, seul le cluster A peut être développé ; sinon, les compartiments associés à A ne peuvent pas être ajoutés. L'extension du cluster B n'est pas valide .

installer etcd

Lieu d'installation : 192.168.10.153

yum install -y etcd

vi /etc/etcd/etcd.conf

#[Membre]
#ETCD_CORS=""
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#ETCD_WAL_DIR=""
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:3380"
ETCD_LISTEN_CLIENT_URLS="http://0.0. 0.0 :
3379" #ETCD_MAX_SNAPSHOTS="5"
#ETCD_MAX_WALS="5"
ETCD_NAME="etcd_minio"
#ETCD_SNAPSHOT_COUNT="100000"
#ETCD_HEARTBEAT_INTERVAL="100"
#ETCD_ELECTION_TIMEOUT="1000"
#ETCD_QUOTA_BACKEND_BYTES="0"
#ETCD_MAX_REQUEST_BYTES="157 2864"
# ETCD_GRPC_KEEPALIVE_MIN_TIME="5s"
#ETCD_GRPC_KEEPALIVE_INTERVAL="2h0m0s"
#ETCD_GRPC_KEEPALIVE_TIMEOUT="20s"
#
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.10.153:3380"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.10.153:3379"
#ETCD_DISCOVERY=""
#ETCD_DISCOVERY_FALLBACK="proxy"
#ETCD_DISCOVERY_PROXY=""
#ETCD_DISCOVERY_SRV=""
#ETCD_INITIAL_CLUSTER="default=http://localhost :2380"
#ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
#ETCD_INITIAL_CLUSTER_STATE="nouveau"
#ETCD_STRICT_RECONFIG_CHECK="true"
#ETCD_ENABLE_V2="true"
#
#[Proxy]
#ETCD_PROXY="off"
#ETCD_PROXY_FAILURE_WAIT="5000"
#ETCD_PROXY_REFRESH_INTER VAL="30000 "
#ETCD_PROXY_DIAL_TIMEOUT="1000"
#ETCD_PROXY_WRITE_TIMEOUT="5000"
#ETCD_PROXY_READ_TIMEOUT="0"
#
#[Sécurité]
#ETCD_CERT_FILE=""
#ETCD_KEY_FILE=""
#ETCD_CLIENT_CERT_AUTH="faux"
#ETCD_TRUSTED_CA_FILE=""
#ETCD_AUTO_TLS="faux" #ETCD_PEER_CERT_FILE=""
#
ETCD_PEER_KEY_FILE ="" #ETCD_PEER_CLIENT_CERT_AUTH="
faux " #ETCD_PEER_TRUSTED_CA_FILE
=""
#ETCD_PEER_AUT O_TLS="faux"
#
#[Logging]
#ETCD_DEBUG="false"
#ETCD_LOG_PACKAGE_LEVELS=""
#ETCD_LOG_OUTPUT="default"
#
#[Unsafe]
#ETCD_FORCE_NEW_CLUSTER="false"
#
#[Version]
#ETCD_VERSION="false"
#ETCD_AUTO_COMPACTION_RETENTION="0"
##[Profilage] #ETCD_ENABLE_PPROF="false" #ETCD_METRICS="basique" #

#[Authentification]
#ETCD_AUTH_TOKEN="simple"

Assurez-vous qu'etcd est installé avec succès. Vous pouvez vérifier l'état d'installation d'etcd avec la commande suivante :

rpm -qa | grep etcd

Si les informations de version d'etcd s'affichent dans la sortie, etcd est déjà installé.

Démarrez le service etcd. Démarrez etcd avec la commande suivante :

systemctl démarrer etcd

Cela démarre le service etcd et fonctionne.

Vérifiez que le service etcd a démarré avec succès. Vous pouvez utiliser la commande suivante pour vérifier l'état d'exécution du service etcd :

statut systemctl etcd

Si actif (en cours d'exécution) est affiché dans la sortie, le service etcd a démarré avec succès.

Script de démarrage du cluster 1

minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app

export MINIO_ETCD_ENDPOINTS="http://192.168.10.153:3379"
export MINIO_PUBLIC_IPS=192.168.10.153
export MINIO_DOMAIN=bo.test.com


nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Script de démarrage du cluster 2

minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app

export MINIO_ETCD_ENDPOINTS="http://192.168.10.153:3379"
export MINIO_PUBLIC_IPS=192.168.10.159
export MINIO_DOMAIN=bo.test.com

nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-2/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

explication de la configuration

Le paramètre MINIO_ETCD_ENDPOINTS doit correspondre aux adresses IP de tous les nœuds du cluster ETCD construit ;

Le paramètre MINIO_PUBLIC_IPS est l'adresse IP de tous les nœuds du cluster ;

Le paramètre MINIO_DOMAIN doit être configuré. Même si vous n'accédez pas au bucket via un nom de domaine, sinon la fédération ne prendra pas effet. Seuls les clusters avec la même valeur de paramètre MINIO_DOMAIN formeront une fédération.

vérifier

Créez un compartiment dans le cluster A, et s'il peut être vu immédiatement dans le cluster B, cela signifie que le cluster est construit avec succès.

déploiement de docker extension peer-to-peer

scène de la demande

La méthode de déploiement de cluster d'origine nécessite au moins 4 disques durs vides et nécessite beaucoup de ressources.Parfois, lorsque les ressources sont limitées, un cluster pouvant étendre les ressources de stockage est nécessaire , qui peut être déployé à la manière d'un docker.

Le cluster minio installé par docker peut utiliser un dossier au lieu d'un disque, et le répertoire de données du cluster minio d'installation d'origine doit utiliser un disque entier vide.
La version cluster utilise également des codes d'effacement pour conserver les données, assurant la sauvegarde des données (mais uniquement dans les dossiers), et la version autonome n'utilise pas de codes d'effacement.
Il est recommandé d'utiliser un répertoire de données et un disque dans l'environnement de production.

liste de serveurs

192.168.10.159,192.168.10.160

point important

1. Le réseau doit utiliser le mode --net-host Après avoir expérimenté le mode de mappage, il n'est pas disponible . L'hypothèse est que lors de l'utilisation du mode de mappage, lors du signalement de l'identité de chaque nœud au cluster, l'adresse IP obtenue est l'adresse IP du conteneur interne, ce qui est incohérent avec l'adresse IP des données sur les paramètres suivants.

2. Si les données doivent être conservées, le répertoire de données et le répertoire du fichier de configuration doivent être mappés sur l'hôte

3. Le port de service et le port de console peuvent être personnalisés à l'aide des paramètres --address, --console-address

4. Il est recommandé que le nombre de copies de tous les disques soit de 2 à la puissance n, supérieur ou égal à 4

Construire Dockerfile

FROM centos:centos7.9.2009
wget https://dl.min.io/server/minio/release/linux-amd64/minio
WORKDIR /opt
RUN  chmod +x minio
ENTRYPOINT ["./minio"]
CMD ["server", "--address :9000","--console-address :9999","http://10.22.1.27/data{1...4}"]

Si le fichier minio a été téléchargé, vous pouvez utiliser

FROM centos:centos7.9.2009
COPY ./minio /opt/
WORKDIR /opt
RUN  chmod +x minio
ENTRYPOINT ["./minio"]
CMD ["server", "--address :9000","--console-address :9999","http://10.22.1.27/data{1...4}"]

construire une image de construction

sudo docker build -t myminio .

script de démarrage

docker run   --name minio1   \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /data1:/data1 \
    -v /data2:/data2 \
	-v /data3:/data3 \
    -v /data4:/data4 \
    myminio server \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159/data{1...4} http://192.168.10.160/data{1...4}

Avis:

1. La raison pour laquelle wget obtient le fichier minio ci-dessus n'est pas l'image minio/minio par défaut. L'expérience a révélé que l'utilisation de la syntaxe {} pour l'image minio/minio signalera une erreur, de sorte que le dernier fichier binaire est utilisé directement.

2. Parfois, si le répertoire de mappage initial existe déjà, une erreur peut être signalée au démarrage. Le moyen le plus sûr est de s'assurer que le répertoire n'existe pas et de laisser docker le créer automatiquement au démarrage.

Fournir une idée d'expansion inverse

Montez d'abord autant de répertoires que possible, attendez que le répertoire de données soit presque plein, mv une partie du répertoire de données sur un nouveau disque dur vide, supprimez le conteneur, modifiez le chemin de montage dans le script de démarrage et redémarrez. Si 32 répertoires sont montés, il y a 5 opportunités d'extension, et si 16 répertoires sont montés, il y a 5 opportunités d'extension. S'il y a 8 répertoires, il y a 4 possibilités d'expansion. Enfin, s'il n'y a aucune possibilité d'étendre le répertoire mv, vous pouvez ajouter des nœuds de machine.

Par exemple, montez d'abord 16 répertoires

docker run   --name minio1  -d \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /mnt/mongo1/data1:/data1 \
    -v /mnt/mongo1/data2:/data2 \
	-v /mnt/mongo1/data3:/data3 \
    -v /mnt/mongo1/data4:/data4 \
	-v /mnt/mongo1/data5:/data5 \
    -v /mnt/mongo1/data6:/data6 \
	-v /mnt/mongo1/data7:/data7 \
    -v /mnt/mongo1/data8:/data8 \
	-v /mnt/mongo1/data9:/data9 \
    -v /mnt/mongo1/data10:/data10 \
	-v /mnt/mongo1/data11:/data11 \
    -v /mnt/mongo1/data12:/data12 \
	-v /mnt/mongo1/data13:/data13 \
    -v /mnt/mongo1/data14:/data14 \
	-v /mnt/mongo1/data15:/data15 \
    -v /mnt/mongo1/data16:/data16 \
    myminio server  \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159:29000/data{1...16}

Lorsque le disque dur où se trouve /mnt/mongo1 est presque plein, déplacez 9-16 vers un nouveau disque dur

mv /mnt/mongo1/data9 /total_min/
mv /mnt/mongo1/data10 /total_min/
mv /mnt/mongo1/data11 /total_min/
mv /mnt/mongo1/data12 /total_min/
mv /mnt/mongo1/data13 /total_min/
mv /mnt/mongo1/data14 /total_min/
mv /mnt/mongo1/data15 /total_min/
mv /mnt/mongo1/data16 /total_min/

Supprimez le conteneur, modifiez le script de démarrage et redémarrez le conteneur, afin que l'effet d'expansion soit activé et que la vérification expérimentale soit effective.

docker run   --name minio1  -d \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /mnt/mongo1/data1:/data1 \
    -v /mnt/mongo1/data2:/data2 \
	-v /mnt/mongo1/data3:/data3 \
    -v /mnt/mongo1/data4:/data4 \
	-v /mnt/mongo1/data5:/data5 \
    -v /mnt/mongo1/data6:/data6 \
	-v /mnt/mongo1/data7:/data7 \
    -v /mnt/mongo1/data8:/data8 \
	-v /total_min/data9:/data9 \
    -v /total_min/data10:/data10 \
	-v /total_min/data11:/data11 \
    -v /total_min/data12:/data12 \
	-v /total_min/data13:/data13 \
    -v /total_min/data14:/data14 \
	-v /total_min/data15:/data15 \
    -v /total_min/data16:/data16 \
    myminio server  \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159:29000/data{1...16}

Vous ne pouvez pas non plus supprimer le conteneur. Après avoir déplacé le fichier, utilisez ln pour créer un lien de fichier pointant vers l'emplacement d'origine.

 ln -s /mnt/mongo2/data9 /mnt/mongo1/data9
 ln -s /mnt/mongo2/data10 /mnt/mongo1/data10
 ln -s /mnt/mongo2/data11 /mnt/mongo1/data11
 ln -s /mnt/mongo2/data12 /mnt/mongo1/data12
 ln -s /mnt/mongo2/data13 /mnt/mongo1/data13
 ln -s /mnt/mongo2/data14 /mnt/mongo1/data14
 ln -s /mnt/mongo2/data15 /mnt/mongo1/data15
 ln -s /mnt/mongo2/data16 /mnt/mongo1/data16

Comme le montre la figure, vous pouvez redémarrer le conteneur sans modifier la commande docker startup.