[Installer Rabbitmq dans K8s] Installer Rabbitmq et créer un cluster miroir dans K8s

[Installer Rabbitmq dans K8s] Installez Rabbitmq et créez un cluster miroir dans K8s - version PVC

2024-07-12

Annuaire d'articles

Introduction

Le cluster Rabbitmq construit dans cet article est construit sous la forme de Rabbitmq_peer_discovery_k8s. Le plug-in lit automatiquement les informations sur les nœuds à partir de l'API K8s et construit le cluster Rabbitmq. La méthode de construction est un statefulset et trois copies, les données doivent donc être garanties. La persistance peut prendre la forme d'une affinité de chemin d'hôte + de nœud, ou elle peut prendre la forme de pvc. Cet article décrira l'utilisation de pvc pour conserver les données.

1. Conditions et description de l'environnement

La version k8s k8s-1.29.4 est construite sous forme de stockage partagé. Le stockage partagé se présente sous la forme d'un ceph racine auto-construit. S'il s'agit d'un cluster utilisant Alibaba Cloud, la persistance des données peut être obtenue en montant un disque dur. stockage sur disque, nas ou objet, l'inconvénient de l'utilisation du stockage partagé est le problème courant de mauvaises performances de lecture et d'écriture.

4.2. Créer une configuration de carte de configuration

Enregistrez la configuration suivante dans autotest-rabbitmq-config.yaml, configurez le vhost par défaut et le mot de passe utilisateur dans la configuration, et initialisez les informations du nœud de cluster [planifiez le nom du nœud avant l'installation].

apiVersion: v1
kind: ConfigMap
metadata:
  name: autozx-rabbitmq-config
  namespace: zx-app
  labels:
    appname: pcauto-zx
    app: autozx-rabbitmq-config 
data:
  enabled_plugins: |
    [rabbitmq_management,rabbitmq_peer_discovery_k8s].
  rabbitmq.conf: |
    cluster_name = autozx-rabbitmq
    listeners.tcp.default = 5672
    
    default_vhost = /
    default_user = admin
    default_pass = pconline

    default_user_tags.administrator = true
    default_user_tags.management = true
    default_user_tags.custom_tag = true

    channel_max = 1024
    tcp_listen_options.backlog = 2048

    cluster_formation.peer_discovery_backend = rabbit_peer_discovery_k8s
    cluster_formation.k8s.host = kubernetes.default.svc.cluster.local
    cluster_formation.k8s.address_type = hostname
    cluster_formation.node_cleanup.interval = 30
    cluster_formation.node_cleanup.only_log_warning = true

    cluster_partition_handling = autoheal

    queue_master_locator=min-masters
    loopback_users.guest = false
    cluster_formation.k8s.hostname_suffix = .autozx-rabbitmq.zx-app.svc.cluster.local
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

4.3. Créer des configurations sans tête d'ensemble d'état et de service

Prenez 3 exemplaires

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: autozx-rabbitmq 
  namespace: zx-app 
  labels:
    appname: pcauto-zx
    app: autozx-rabbitmq
spec:
  serviceName: "autozx-rabbitmq"
  replicas: 3
  selector:
    matchLabels:
      app: autozx-rabbitmq
  template:
    metadata:
      labels:
        app: autozx-rabbitmq
    spec:
      containers:
      - name: rabbitmq-server
        image: pcgroup-registry-vpc.cn-shenzhen.cr.aliyuncs.com/public/rabbitmq:3.12.14-management 
        imagePullPolicy: IfNotPresent
        env:
        - name: RABBITMQ_ERLANG_COOKIE
          value: "YZSDHWMFSMKEMBDHSGGZ"
        - name: K8S_SERVICE_NAME
          value: autozx-rabbitmq 
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: RABBITMQ_USE_LONGNAME
          value: "true"
        - name: RABBITMQ_NODENAME
          value: rabbit@$(POD_NAME).$(K8S_SERVICE_NAME).$(POD_NAMESPACE).svc.cluster.local
        ports:
        - name: http
          containerPort: 15672 
        - name: amqp
          containerPort: 5672 
        readinessProbe:
          exec:
            command:
            - rabbitmq-diagnostics
            - status
          initialDelaySeconds: 20
          periodSeconds: 60
          timeoutSeconds: 10
        volumeMounts:
        - name: rbmq-data
          mountPath: /var/lib/rabbitmq
        - name: rabbitmq-config-volume
          mountPath: /etc/rabbitmq/ 
      restartPolicy: Always 
      serviceAccountName: rabbitmq-cluster
      terminationGracePeriodSeconds: 30
      volumes:
        - name: rabbitmq-config-volume
          configMap:
            name: autozx-rabbitmq-config
  volumeClaimTemplates:
  - metadata:
      name: rbmq-data
    spec:
      accessModes:
      - ReadWriteMany
      storageClassName: example-storageclass
      resources:
        requests:
          storage: 20Gi
---
apiVersion: v1
kind: Service
metadata:
  name: autozx-rabbitmq
  namespace: zx-app
  labels:
    appname: pcauto-zx
    app: autozx-rabbitmq
spec:
  ports:
  - port: 5672
  clusterIP: None
  selector:
    app: autozx-rabbitmq
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

Remarque : Si vous souhaitez éviter d'attribuer le même pod au même nœud, vous pouvez ajouter la configuration suivante :

      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                      - autozx-rabbitmq
              topologyKey: "kubernetes.io/hostname"
1
2
3
4
5
6
7
8
9
10

4.4.Paramétrage des autorisations

Configurez serviceAccount, role et RoleBinding pour autoriser statefulset à lire les informations sur le nœud

apiVersion: v1
kind: Service
metadata:
  name: autozx-rabbitmq-manage
  namespace: zx-app
  labels:
    app: autozx-rabbitmq-manage
    appname: pcauto-zx
spec:
  ports:
  - port: 5672
    name: amqp
  - port: 15672
    name: http
  selector:
    app: autozx-rabbitmq
  type: LoadBalancer 
[root@autobbs-docker-240-213 rabbitmq]# cat rbac.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: rabbitmq-cluster
  namespace: zx-app
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rabbitmq-cluster
  namespace: zx-app
rules:
- apiGroups: [""]
  resources: ["endpoints"]
  verbs: ["get"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: rabbitmq-cluster
  namespace: zx-app
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: rabbitmq-cluster
subjects:
- kind: ServiceAccount
  name: rabbitmq-cluster
  namespace: zx-app
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

4.5. Créer une configuration de service

Configurez un service proxy pour le port amqp 5672 et le port de gestion 15672.

apiVersion: v1
kind: Service
metadata:
  name: autozx-rabbitmq-manage
  namespace: zx-app
  labels:
    app: autozx-rabbitmq-manage
    appname: pcauto-zx
spec:
  ports:
  - port: 5672
    name: amqp
  - port: 15672
    name: http
  selector:
    app: autozx-rabbitmq
  type: LoadBalancer 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5. Configuration après installation

Définissez le cluster Rabbitmq sur un cluster miroir à 3 nœuds. Après avoir terminé l'étape 4.4, vous pouvez vous connecter à la console via l'adresse IP de l'équilibreur de charge : http://ip:15672, et utiliser default_user et default_pass définis dans la carte de configuration pour se connecter.

Paramètres du mode miroir :

Après réglage :

Le mode miroir peut être défini avec la commande :
Définissez la commande d'exécution d'image de démo vhost :
rabbitmqctl set_policy -p demo ha-all "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'
Définir le mode de mise en miroir pour vhost/ par défaut :
rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'

6. Instructions d'installation

Avant d'utiliser la configuration, remplacez autozx dans la configuration par le nom dont vous avez besoin. L'espace de noms configuré est : zx-app, remplacez-le par votre propre espace de noms, le nom de l'application est pcauto-zx, remplacez-le par votre propre nom d'application, cette étiquette peut également être supprimé.
L'adresse du miroir dans la configuration utilise une adresse de miroir privée. Le miroir est Rabbitmq:3.12.14-management téléchargé depuis Dockerhub et mis en miroir sur l'entrepôt de miroir privé. S'il peut se connecter directement aux k8 sur le réseau externe, Rabbitmq:3.12.14. -La gestion peut être utilisée directement. Sinon, configurez une adresse miroir passable.
Le nom d'utilisateur et le mot de passe par défaut sont admin.
La classe de stockage dans le modèle pvc : example-storageclass est modifiée en votre propre classe de stockage
"5. Configuration après installation" Les méthodes de configuration étant les mêmes, la capture d'écran de l'article précédent est utilisée.

Partage de technologie