Einrichten eines Layer-7-Load-Balancers für Milvus auf GCP

Im Vergleich zu einem Layer-4-Load Balancer bietet ein Layer-7-Load Balancer intelligente Load Balancing- und Caching-Funktionen und ist eine gute Wahl für Cloud-native Dienste.

Diese Anleitung führt Sie durch die Einrichtung eines Layer-7 Load Balancers für einen Milvus-Cluster, der bereits hinter einem Layer-4 Load Balancer läuft.

Bevor Sie beginnen

• In Ihrem GCP-Konto ist bereits ein Projekt vorhanden.

  Wie Sie ein Projekt erstellen, erfahren Sie unter Erstellen und Verwalten von Projekten. Der Name des in diesem Leitfaden verwendeten Projekts ist milvus-testing-nonprod.

• Sie haben gcloud CLI, kubectl und Helm lokal installiert oder sich entschieden, stattdessen die browserbasierte Cloud Shell zu verwenden.

• Sie haben die gcloud CLI mit Ihren GCP-Kontoanmeldeinformationen initialisiert.

• Sie haben einen Milvus-Cluster hinter einem Layer-4-Loadbalancer auf GCP bereitgestellt.

Anpassen der Milvus-Konfigurationen

In dieser Anleitung wird davon ausgegangen, dass Sie bereits einen Milvus-Cluster hinter einem Layer-4-Loadbalancer auf GCP bereitgestellt haben.

Bevor Sie einen Layer-7-Loadbalancer für diesen Milvus-Cluster einrichten, führen Sie den folgenden Befehl aus, um den Layer-4-Loadbalancer zu entfernen.

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

Als Backend-Dienst des Layer-7-Loadbalancers muss Milvus bestimmte Verschlüsselungsanforderungen erfüllen, damit es die HTTP/2-Anfragen vom Loadbalancer verstehen kann. Daher müssen Sie TLS auf Ihrem Milvus-Cluster wie folgt aktivieren.

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

den tls.yaml-Inhalt:

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

Einrichten eines Gesundheitsprüfungs-Endpunkts

Um die Verfügbarkeit des Dienstes zu gewährleisten, erfordert der Layer-7-Lastenausgleich auf GCP die Überprüfung des Zustands des Backend-Dienstes. Daher müssen wir eine BackendConfig einrichten, um den Gesundheitsprüfungs-Endpunkt zu verpacken und die BackendConfig mit dem Milvus-Dienst durch Anmerkungen zu verknüpfen.

Das folgende Snippet zeigt die BackendConfig-Einstellungen. Speichern Sie ihn als backendconfig.yaml zur späteren Verwendung.

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

Führen Sie dann den folgenden Befehl aus, um den Gesundheitsprüfungsendpunkt zu erstellen.

kubectl apply -f backendconfig.yaml

Aktualisieren Sie schließlich die Anmerkungen des Milvus-Dienstes, um den Layer-7-Loadbalancer, den wir später erstellen werden, aufzufordern, Gesundheitsprüfungen über den soeben erstellten Endpunkt durchzuführen.

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

Vorbereiten von TLS-Zertifikaten

TLS erfordert Zertifikate, um zu funktionieren. Es gibt zwei Möglichkeiten, Zertifikate zu erstellen, nämlich selbstverwaltete und von Google verwaltete.

In dieser Anleitung wird my-release.milvus.io als Domainname für den Zugriff auf unseren Milvus-Dienst verwendet.

Selbstverwaltete Zertifikate erstellen

Führen Sie die folgenden Befehle aus, um ein Zertifikat zu erstellen.

# 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

Erstellen Sie dann ein Geheimnis in Ihrem GKE-Cluster mit diesen Dateien zur späteren Verwendung.

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

Google-verwaltete Zertifikate erstellen

Das folgende Snippet ist eine ManagedCertificate-Einstellung. Speichern Sie sie als managed-crt.yaml für die spätere Verwendung.

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

Erstellen Sie ein verwaltetes Zertifikat, indem Sie die Einstellung wie folgt auf Ihren GKE-Cluster anwenden:

kubectl apply -f ./managed-crt.yaml

Dies kann eine Weile dauern. Sie können den Fortschritt überprüfen, indem Sie

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

Die Ausgabe sollte in etwa so aussehen wie die folgende:

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

Sobald certificateStatus auf Active wechselt, können Sie den Load Balancer einrichten.

Erstellen Sie einen Ingress, um einen Layer-7 Load Balancer zu generieren

Erstellen Sie eine YAML-Datei mit einem der folgenden Snippets.

• Selbst verwaltete Zertifikate verwenden

  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
  

• Verwendung von Google-verwalteten Zertifikaten

  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
  

Anschließend können Sie den Ingress erstellen, indem Sie die Datei auf Ihren GKE-Cluster anwenden.

kubectl apply -f ingress.yaml

Warten Sie nun darauf, dass Google den Layer-7-Loadbalancer einrichtet. Sie können den Fortschritt überprüfen, indem Sie

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

Die Ausgabe sollte in etwa so aussehen wie die folgende:

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

Sobald eine IP-Adresse im Feld ADDRESS angezeigt wird, ist der Layer-7-Load-Balancer einsatzbereit. In der obigen Ausgabe werden sowohl Port 80 als auch Port 443 angezeigt. Denken Sie daran, dass Sie zu Ihrem eigenen Wohl immer Port 443 verwenden sollten.

Überprüfen Sie die Verbindung durch den Layer-7-Load-Balancer

In dieser Anleitung wird PyMilvus verwendet, um die Verbindung zum Milvus-Dienst hinter dem soeben erstellten Layer-7-Load-Balancer zu überprüfen. Für detaillierte Schritte, lesen Sie dies.

Beachten Sie, dass die Verbindungsparameter von der Art und Weise abhängen, wie Sie die Zertifikate in Prepare TLS certificates verwalten.

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")