Configurar un equilibrador de carga de capa 7 para Milvus en GCP

En comparación con un equilibrador de carga de capa 4, un equilibrador de carga de capa 7 ofrece capacidades inteligentes de equilibrio de carga y almacenamiento en caché y es una gran opción para los servicios nativos de la nube.

Esta guía le guía a través de la configuración de un equilibrador de carga de capa 7 para un cluster Milvus que ya se está ejecutando detrás de un equilibrador de carga de capa 4.

Antes de empezar

• Ya existe un proyecto en su cuenta GCP.

  Para crear un proyecto, consulte Creación y gestión de proyectos. El nombre del proyecto utilizado en esta guía es milvus-testing-nonprod.

• Ha instalado localmente gcloud CLI, kubectl y Helm, o ha decidido utilizar en su lugar Cloud Shell basado en navegador.

• Ha inicializado gcloud CLI con las credenciales de su cuenta GCP.

• Ha desplegado un clúster Milvus detrás de un equilibrador de carga Layer-4 en GCP.

Ajustar las configuraciones de Milvus

Esta guía asume que ya ha desplegado un clúster Milvus detrás de un equilibrador de carga de Capa 4 en GCP.

Antes de configurar un equilibrador de carga de Capa-7 para este clúster Milvus, ejecute el siguiente comando para eliminar el equilibrador de carga de Capa-4.

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

Como servicio backend del equilibrador de carga Layer-7, Milvus tiene que cumplir ciertos requisitos de encriptación para que pueda entender las peticiones HTTP/2 del equilibrador de carga. Por lo tanto, necesita habilitar TLS en su cluster Milvus como se indica a continuación.

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

el contenido de tls.yaml:

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

Configurar un punto final de comprobación de estado

Para garantizar la disponibilidad del servicio, el equilibrio de carga de Capa 7 en GCP requiere sondear las condiciones de salud del servicio backend. Por lo tanto, necesitamos configurar una BackendConfig para envolver el punto final de comprobación de salud y asociar la BackendConfig con el servicio Milvus mediante anotaciones.

El siguiente fragmento es la configuración de BackendConfig. Guárdelo como backendconfig.yaml para su uso posterior.

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

A continuación, ejecute el siguiente comando para crear el punto final de comprobación de estado.

kubectl apply -f backendconfig.yaml

Por último, actualice las anotaciones del servicio Milvus para pedir al equilibrador de carga Layer-7 que crearemos más adelante que realice comprobaciones de salud utilizando el endpoint que acabamos de crear.

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

Preparar certificados TLS

TLS requiere certificados para funcionar. Existen dos formas de crear certificados: autogestionados y gestionados por Google.

En esta guía se utiliza my-release.milvus.io como nombre de dominio para acceder a nuestro servicio Milvus.

Crear certificados autogestionados

Ejecute los siguientes comandos para crear un certificado.

# 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

A continuación, cree un secreto en su clúster GKE con estos archivos para su uso posterior.

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

Crear certificados gestionados por Google

El siguiente fragmento es una configuración de ManagedCertificate. Guárdalo como managed-crt.yaml para su uso posterior.

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

Crea un certificado gestionado aplicando la configuración a tu clúster de GKE como se indica a continuación:

kubectl apply -f ./managed-crt.yaml

Esto puede durar un rato. Puede comprobar el progreso ejecutando

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

El resultado debería ser similar al siguiente:

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

Una vez que certificateStatus cambie a Active, estará listo para configurar el equilibrador de carga.

Crear un Ingress para generar un equilibrador de carga de capa 7

Cree un archivo YAML con uno de los siguientes fragmentos.

• Uso de certificados autogestionados

  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
  

• Usando certificados gestionados por 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
  

A continuación, puede crear el Ingress aplicando el archivo a su clúster GKE.

kubectl apply -f ingress.yaml

Ahora, espere a que Google configure el equilibrador de carga de capa 7. Puede comprobar el progreso ejecutando

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

El resultado debería ser similar al siguiente:

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

Una vez que aparezca una dirección IP en el campo DIRECCIÓN, el equilibrador de carga Layer-7 estará listo para su uso. Tanto el puerto 80 como el 443 se muestran en la salida anterior. Recuerde que siempre debe utilizar el puerto 443 por su propio bien.

Verificar la conexión a través del equilibrador de carga Layer-7

Esta guía utiliza PyMilvus para verificar la conexión al servicio Milvus detrás del equilibrador de carga Layer-7 que acabamos de crear. Para pasos detallados, lea esto.

Observe que los parámetros de conexión varían según la forma que elija para gestionar los certificados en Preparar certificados TLS.

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