Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Introduction au cluster minio

Documentation officielle :https://min.io/docs/minio/linux/operations/install-deploy-manage/deploy-minio-multi-node-multi-drive.html

Cette solution utilise MinIO déployé dans une configuration multi-nœuds multi-pilotes (MNMD) ou « distribuée ». Les déploiements MNMD offrent des performances, une disponibilité et une évolutivité de niveau entreprise et constituent la topologie recommandée pour toutes les charges de travail de production.

Les déploiements MNMD prennent en charge les configurations de codage d'effacement qui peuvent tolérer la perte jusqu'à la moitié des nœuds ou des lecteurs du déploiement tout en continuant à assurer les opérations de lecture.

Exigences de déploiement de cluster

• La configuration minimale officiellement recommandée est de 4 serveurs, chaque serveur dispose de 4 disques, afin que minio puisse être hautement disponible.
• Il est recommandé d'utiliser une partition distincte comme répertoire de stockage de données de minio. Vous ne pouvez pas utiliser le répertoire de la partition racine comme répertoire de stockage de données de minio. Cependant, vous pouvez créer quatre répertoires standards avec un seul disque indépendant par nœud.
• MinIO ne prend pas en charge les noms d'hôte ou les adresses IP non contigus pour les déploiements distribués. Vous pouvez utiliser /etc/hosts sur chaque nœud pour configurer un schéma DNS simple prenant en charge la notation étendue.
• Les systèmes multi-nœuds doivent maintenir l’heure et la date synchronisées pour maintenir un fonctionnement et une interaction stables entre les nœuds.

Déployer le cluster minio sur Ubuntu

La planification des nœuds et la planification des disques sont les suivantes. Chaque nœud prépare quatre disques :

Description : L'adresse VIP est résolue enminio.example.comLe nom de domaine sert d'entrée unifiée.

• L'adresse d'accès à l'API minio est :http://minio.example.com
• L'adresse d'accès à la console minio est :http://minio.example.com/minio/ui

L'architecture du cluster est la suivante :

Préparer le nœud

Tous les nœuds minio sont configurés respectivement avec des noms d'hôte.

hostnamectl set-hostname minio1.example.com
hostnamectl set-hostname minio2.example.com
hostnamectl set-hostname minio3.example.com
hostnamectl set-hostname minio4.example.com
1
2
3
4

Tous les nœuds minio sont configurés séparément avec la résolution des hôtes.

cat >/etc/hosts<<EOF
192.168.72.51 minio1.example.com
192.168.72.52 minio2.example.com
192.168.72.53 minio3.example.com
192.168.72.54 minio4.example.com
EOF
1
2
3
4
5
6

Toutes les heures de configuration du nœud minio sont synchronisées.
Les systèmes multi-nœuds Minio doivent maintenir l'heure et la date synchronisées pour maintenir un fonctionnement et une interaction stables entre les nœuds.

apt install -y chrony
systemctl enable --now chrony
timedatectl set-timezone Asia/Shanghai
1
2
3

Préparer le disque

Chaque nœud monte 4 disques, dont sda est le disque système :

root@minio1:~# lsblk -d -n -o NAME | grep '^sd'
sda
sdb
sdc
sdd
sde
1
2
3
4
5
6

Sur chaque nœud, créez quatre répertoires pour monter les quatre lecteurs :

sudo mkdir -p /var/lib/minio/data1
sudo mkdir -p /var/lib/minio/data2
sudo mkdir -p /var/lib/minio/data3
sudo mkdir -p /var/lib/minio/data4
1
2
3
4

Sur chaque nœud séparément, formatez le disque selon le système de fichiers XFS :

sudo mkfs.xfs /dev/sdb -L DISK1
sudo mkfs.xfs /dev/sdc -L DISK2
sudo mkfs.xfs /dev/sdd -L DISK3
sudo mkfs.xfs /dev/sde -L DISK4
1
2
3
4

Configurer le montage automatique

cat >>/etc/fstab<<EOF
LABEL=DISK1      /var/lib/minio/data1     xfs     defaults,noatime  0       2
LABEL=DISK2      /var/lib/minio/data2     xfs     defaults,noatime  0       2
LABEL=DISK3      /var/lib/minio/data3     xfs     defaults,noatime  0       2
LABEL=DISK4      /var/lib/minio/data4     xfs     defaults,noatime  0       2
EOF
1
2
3
4
5
6

monter tout dedans /etc/fstab Système de fichiers défini dans le fichier mais pas encore monté

sudo mount -av
1

Confirmez que le système de fichiers est correctement monté

root@minio1:~# df -hT
......
/dev/sdb                     xfs    100G  746M  100G   1% /var/lib/minio/data1
/dev/sdc                     xfs    100G  746M  100G   1% /var/lib/minio/data2
/dev/sdd                     xfs    100G  746M  100G   1% /var/lib/minio/data3
/dev/sde                     xfs    100G  746M  100G   1% /var/lib/minio/data4
1
2
3
4
5
6

Installer Minio

Installez MinIO à l'aide du package deb sur chaque nœud séparément

wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio_20240704142545.0.0_amd64.deb -O minio.deb
sudo dpkg -i minio.deb
1
2

utiliser groupadd etuseradd Commandes pour créer des utilisateurs et des groupes

groupadd -r minio-user
useradd -M -r -g minio-user minio-user
chown -R minio-user:minio-user /var/lib/minio
1
2
3

Créer un fichier d'environnement de service

exister /etc/default/minio Créez des fichiers d'environnement. Le service MinIO utilise ce fichier comme MinIO etminio.service La source de toutes les variables d'environnement utilisées par le fichier.

cat >/etc/default/minio<<EOF
MINIO_VOLUMES="http://minio{1...4}.example.com:9000/var/lib/minio/data{1...4}/minio"
MINIO_OPTS="--console-address :9001"
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=Minio@123456
MINIO_BROWSER_REDIRECT_URL="http://minio.example.com/minio/ui"
EOF
1
2
3
4
5
6
7

Exécutez la commande suivante sur chaque nœud du déploiement pour démarrer le service MinIO. Plusieurs nœuds doivent être exécutés simultanément dans l'ordre.

sudo systemctl restart minio.service
1

Confirmez que le service est en ligne et fonctionne correctement à l'aide de la commande suivante :

sudo systemctl status minio.service
journalctl -f -u minio.service
1
2

Ouvrez la console MinIO

Ouvrez un navigateur et accédez au port :9001 n’importe quel nom d’hôte MinIO pour ouvrir la page de connexion de la console MinIO.Par exemple

http://minio1.example.com:9001
1

Utilisez le minio_root_user etminio_root_password Se connecter.

Vous pouvez utiliser la console MinIO pour effectuer des tâches de gestion générale telles que la gestion des identités et des accès, la surveillance des métriques et des journaux ou la configuration du serveur. Chaque serveur MinIO contient sa propre console MinIO intégrée.

Configurer l'équilibrage de charge

Documentation officielle :https://min.io/docs/minio/linux/integrations/configuration-du-proxy-nginx-avec-minio.html

utilisernginxetkeepalivedPour réaliser l'équilibrage de charge, préparez 2 serveurs en tant que nœuds d'équilibrage de charge.

Configurez respectivement le nom d'hôte sur le nœud lb.

hostnamectl set-hostname lb1.example.com
hostnamectl set-hostname lb2.example.com
1
2

Configurez la résolution des hôtes sur le nœud lb respectivement.

cat >/etc/hosts<<EOF
192.168.72.55 lb1.example.com
192.168.72.56 lb2.example.com
192.168.72.51 minio1.example.com
192.168.72.52 minio2.example.com
192.168.72.53 minio3.example.com
192.168.72.54 minio4.example.com
EOF
1
2
3
4
5
6
7
8

Installez nginx et keepalived sur 2 nœuds :

apt install -y nginx keepalived
1

Créez le fichier de configuration nginx, modifiez l'adresse du serveur et personnalisez le port d'écoute, faites attention aux modificationsserver_nameparamètre:

cat > /etc/nginx/conf.d/minio-lb.conf <<'EOF'
upstream minio_s3 {
   least_conn;
   server minio1.example.com:9000;
   server minio2.example.com:9000;
   server minio3.example.com:9000;
   server minio4.example.com:9000;
}

upstream minio_console {
   least_conn;
   server minio1.example.com:9001;
   server minio2.example.com:9001;
   server minio3.example.com:9001;
   server minio4.example.com:9001;
}

server {
   listen       80;
   listen  [::]:80;
   server_name  minio.example.com;

   # Allow special characters in headers
   ignore_invalid_headers off;
   # Allow any size file to be uploaded.
   # Set to a value such as 1000m; to restrict file size to a specific value
   client_max_body_size 0;
   # Disable buffering
   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;
      # Default is HTTP/1, keepalive is only enabled in HTTP/1.1
      proxy_http_version 1.1;
      proxy_set_header Connection "";
      chunked_transfer_encoding off;

      proxy_pass https://minio_s3; # This uses the upstream directive definition to load balance
   }
   
   location /minio/ui/ {
      rewrite ^/minio/ui/(.*) /$1 break;
      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_set_header X-NginX-Proxy true;

      # This is necessary to pass the correct IP to be hashed
      real_ip_header X-Real-IP;

      proxy_connect_timeout 300;

      # To support websockets in MinIO versions released after January 2023
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
      # Some environments may encounter CORS errors (Kubernetes + Nginx Ingress)
      # Uncomment the following line to set the Origin request to an empty string
      # proxy_set_header Origin '';

      chunked_transfer_encoding off;

      proxy_pass https://minio_console; # This uses the upstream directive definition to load balance
   }
}
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

Démarrer le service nginx

systemctl restart nginx
1

Créez un fichier de configuration keepalived et modifiez-le en fonction de l'environnement réelinterfaceetvirtual_ipaddressParamètres, les deux nœuds ont la même configuration :

cat > /etc/keepalived/keepalived.conf <<EOF
! Configuration File for keepalived

global_defs {
   router_id minio
   vrrp_version 2
   vrrp_garp_master_delay 1
   script_user root
   enable_script_security 
}

vrrp_script chk_nginx {
    script       "/usr/bin/killall -0 nginx"
    timeout 3
    interval 3   # check every 1 second
    fall 2       # require 2 failures for KO
    rise 2       # require 2 successes for OK
}

vrrp_instance lb-minio {
    state BACKUP
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    nopreempt
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.72.100
    }
    track_script {
        chk_nginx
    }
}
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

Démarrez le service keepalvied

systemctl restart keepalived
1

Afficher l'adresse VIP générée

root@lb1:~# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:50:56:9a:92:75 brd ff:ff:ff:ff:ff:ff
    altname enp2s1
    inet 192.168.72.55/24 brd 192.168.72.255 scope global ens33
       valid_lft forever preferred_lft forever
    inet 192.168.72.100/32 scope global ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::250:56ff:fe9a:9275/64 scope link 
       valid_lft forever preferred_lft forever
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

tester la connexion

Sur la machine qui doit accéder à minio, configurez la résolution des hôtes

echo "192.168.72.100 minio.example.com" >>/etc/hosts
1

Console minio d'accès au navigateur

http://minio.example.com/minio/ui/
1

Afficher les informations sur les métriques :

Installer le client minio sur n'importe quelle machine

wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
mv mc /usr/local/bin/
1
2
3

Configurer le client minio

mc alias set myminio http://minio.example.com minioadmin Minio@123456
1

Afficher l'état du cluster via l'interface API

root@ubuntu:~# mc admin info myminio
●  minio1.example.com:9000
   Uptime: 25 minutes 
   Version: 2024-07-04T14:25:45Z
   Network: 4/4 OK 
   Drives: 4/4 OK 
   Pool: 1

●  minio2.example.com:9000
   Uptime: 25 minutes 
   Version: 2024-07-04T14:25:45Z
   Network: 4/4 OK 
   Drives: 4/4 OK 
   Pool: 1

●  minio3.example.com:9000
   Uptime: 25 minutes 
   Version: 2024-07-04T14:25:45Z
   Network: 4/4 OK 
   Drives: 4/4 OK 
   Pool: 1

●  minio4.example.com:9000
   Uptime: 25 minutes 
   Version: 2024-07-04T14:25:45Z
   Network: 4/4 OK 
   Drives: 4/4 OK 
   Pool: 1

Pools:
   1st, Erasure sets: 1, Drives per erasure set: 16

16 drives online, 0 drives offline
root@ubuntu:~#  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

faire référence à:https://elma365.com/fr/aide/minio-cluster.html