milvus-logo
LFAI
Home
  • Guía de administración

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

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
  • En cuanto a la primera anotación,

    Milvus es nativo de gRPC, que se basa en HTTP/2. Por lo tanto, podemos utilizar HTTP/2 como protocolo de comunicación entre el equilibrador de carga Layer-7 y Milvus.

  • En cuanto a la segunda anotación,

    Milvus sólo ofrece el punto final de comprobación de salud a través de gRPC y HTTP/1. Tenemos que configurar un BackendConfig para envolver el punto final de comprobación de salud y asociarlo con el servicio Milvus para que el equilibrador de carga Layer-7 sondee este punto final para conocer el estado de salud de Milvus.

  • En cuanto a la tercera anotación,

    Solicita la creación de un grupo de extremos de red (NEG) después de crear un Ingress. Cuando se utilizan NEG con GKE Ingress, el controlador Ingress facilita la creación de todos los aspectos del equilibrador de carga. Esto incluye la creación de la dirección IP virtual, las reglas de reenvío, las comprobaciones de estado, las reglas de cortafuegos, etc. Para obtener más información, consulte los documentos de Google Cloud.

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")
  • La dirección IP y el número de puerto en host y port deben coincidir con los que se indican al final de Crear una entrada para generar un equilibrador de carga de capa 7.
  • Si ha configurado un registro DNS para asignar el nombre de dominio a la dirección IP del host, sustituya la dirección IP en host por el nombre de dominio y omita server_name.

Traducido porDeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

¿Fue útil esta página?