Configurer un équilibreur de charge de couche 7 pour Milvus sur GCP

Comparé à un équilibreur de charge de couche 4, un équilibreur de charge de couche 7 offre des capacités intelligentes d'équilibrage de charge et de mise en cache et constitue un excellent choix pour les services natifs du nuage.

Ce guide vous guide dans la configuration d'un équilibreur de charge de couche 7 pour un cluster Milvus fonctionnant déjà derrière un équilibreur de charge de couche 4.

Avant de commencer

• Un projet existe déjà dans votre compte GCP.

  Pour créer un projet, reportez-vous à la section Création et gestion de projets. Le nom du projet utilisé dans ce guide est milvus-testing-nonprod.

• Vous avez installé localement gcloud CLI, kubectl et Helm, ou vous avez décidé d'utiliser le Cloud Shell basé sur le navigateur à la place.

• Vous avez initialisé le CLI gcloud avec les informations d'identification de votre compte GCP.

• Vous avez déployé un cluster Milvus derrière un équilibreur de charge de couche 4 sur GCP.

Modifier les configurations Milvus

Ce guide suppose que vous avez déjà déployé un cluster Milvus derrière un équilibreur de charge de couche 4 sur GCP.

Avant de configurer un équilibreur de charge de couche 7 pour ce cluster Milvus, exécutez la commande suivante pour supprimer l'équilibreur de charge de couche 4.

helm upgrade my-release milvus/milvus --set service.type=ClusterIP

En tant que service backend de l'équilibreur de charge de couche 7, Milvus doit répondre à certaines exigences de cryptage afin de pouvoir comprendre les requêtes HTTP/2 de l'équilibreur de charge. Par conséquent, vous devez activer TLS sur votre cluster Milvus comme suit.

helm upgrade my-release milvus/milvus -f tls.yaml

Le contenu de tls.yaml :

extraConfigFiles:
  user.yaml: |+
    common:
      security:
        tlsMode: 1

Configurer un point d'extrémité de contrôle de santé

Pour assurer la disponibilité du service, l'équilibrage de charge de couche 7 sur GCP nécessite de sonder les conditions de santé du service backend. Par conséquent, nous devons configurer un BackendConfig pour envelopper le point final de contrôle de santé et associer le BackendConfig au service Milvus par le biais d'annotations.

L'extrait suivant représente les paramètres de BackendConfig. Enregistrez-le sous backendconfig.yaml pour une utilisation ultérieure.

apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  name: my-release-backendconfig
  namespace: default
spec:
  healthCheck:
    port: 9091
    requestPath: /healthz
    type: HTTP

Exécutez ensuite la commande suivante pour créer le point de terminaison du bilan de santé.

kubectl apply -f backendconfig.yaml

Enfin, mettez à jour les annotations du service Milvus pour demander à l'équilibreur de charge Layer-7 que nous créerons plus tard d'effectuer des contrôles de santé à l'aide du point de terminaison qui vient d'être créé.

kubectl annotate service my-release-milvus \
    cloud.google.com/app-protocols='{"milvus":"HTTP2"}' \
    cloud.google.com/backend-config='{"default": "my-release-backendconfig"}' \
    cloud.google.com/neg='{"ingress": true}' --overwrite

Préparer les certificats TLS

Le protocole TLS nécessite des certificats pour fonctionner. Il existe deux façons de créer des certificats, à savoir les certificats autogérés et les certificats gérés par Google.

Ce guide utilise my-release.milvus.io comme nom de domaine pour accéder à notre service Milvus.

Créer des certificats autogérés

Exécutez les commandes suivantes pour créer un certificat.

# Generates a tls.key.
openssl genrsa -out tls.key 2048

# Creates a certificate and signs it with the preceding key.
openssl req -new -key tls.key -out tls.csr \
    -subj "/CN=my-release.milvus.io"

openssl x509 -req -days 99999 -in tls.csr -signkey tls.key \
    -out tls.crt

Créez ensuite un secret dans votre cluster GKE avec ces fichiers pour une utilisation ultérieure.

kubectl create secret tls my-release-milvus-tls --cert=./tls.crt --key=./tls.key

Créer des certificats gérés par Google

L'extrait suivant est un paramètre ManagedCertificate. Enregistrez-le sous managed-crt.yaml pour une utilisation ultérieure.

apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: my-release-milvus-tls
spec:
  domains:
    - my-release.milvus.io

Créez un certificat géré en appliquant le paramètre à votre cluster GKE comme suit :

kubectl apply -f ./managed-crt.yaml

Cette opération peut durer un certain temps. Vous pouvez vérifier la progression en exécutant

kubectl get -f ./managed-crt.yaml -o yaml -w

La sortie devrait être similaire à ce qui suit :

status:
  certificateName: mcrt-34446a53-d639-4764-8438-346d7871a76e
  certificateStatus: Provisioning
  domainStatus:
  - domain: my-release.milvus.io
    status: Provisioning

Une fois que certificateStatus devient actif, vous êtes prêt à configurer l'équilibreur de charge.

Créer un Ingress pour générer un équilibreur de charge de couche 7

Créez un fichier YAML avec l'un des extraits suivants.

• Utilisation de certificats autogérés

  apiVersion: networking.k8s.io/v1
  kind: Ingress
  metadata:
    name: my-release-milvus
    namespace: default
  spec:
    tls:
    - hosts:
      - my-release.milvus.io
      secretName: my-release-milvus-tls
    rules:
    - host: my-release.milvus.io
      http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: my-release-milvus
              port:
                number: 19530
  

• Utilisation de certificats gérés par Google

  apiVersion: networking.k8s.io/v1
  kind: Ingress
  metadata:
    name: my-release-milvus
    namespace: default
    annotations:
      networking.gke.io/managed-certificates: "my-release-milvus-tls"
  spec:
    rules:
    - host: my-release.milvus.io
      http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: my-release-milvus
              port:
                number: 19530
  

Vous pouvez ensuite créer l'Ingress en appliquant le fichier à votre cluster GKE.

kubectl apply -f ingress.yaml

Attendez maintenant que Google configure l'équilibreur de charge Layer-7. Vous pouvez vérifier la progression en exécutant

kubectl  -f ./config/samples/ingress.yaml get -w

La sortie devrait être similaire à ce qui suit :

NAME                CLASS    HOSTS                  ADDRESS   PORTS   AGE
my-release-milvus   <none>   my-release.milvus.io             80      4s
my-release-milvus   <none>   my-release.milvus.io   34.111.144.65   80, 443   41m

Une fois qu'une adresse IP s'affiche dans le champ ADDRESS, l'équilibreur de charge Layer-7 est prêt à être utilisé. Les ports 80 et 443 sont tous deux affichés dans la sortie ci-dessus. N'oubliez pas que vous devez toujours utiliser le port 443 pour votre propre bien.

Vérifier la connexion via l'équilibreur de charge Layer-7

Ce guide utilise PyMilvus pour vérifier la connexion au service Milvus derrière l'équilibreur de charge Layer-7 que nous venons de créer. Pour des étapes détaillées, lisez ceci.

Notez que les paramètres de connexion varient en fonction de la manière dont vous choisissez de gérer les certificats dans Prepare TLS certificates.

from pymilvus import (
    connections,
    utility,
    FieldSchema,
    CollectionSchema,
    DataType,
    Collection,
)

# For self-managed certificates, you need to include the certificate in the parameters used to set up the connection.
connections.connect("default", host="34.111.144.65", port="443", server_pem_path="tls.crt", secure=True, server_name="my-release.milvus.io")

# For Google-managed certificates, there is not need to do so.
connections.connect("default", host="34.111.144.65", port="443", secure=True, server_name="my-release.milvus.io")