Configurar um balanceador de carga de camada 7 para Milvus no GCP

Quando comparado a um balanceador de carga de camada 4, um balanceador de carga de camada 7 oferece recursos inteligentes de balanceamento de carga e armazenamento em cache e é uma ótima opção para serviços nativos da nuvem.

Este guia orienta-o na configuração de um balanceador de carga de camada 7 para um cluster Milvus já em execução atrás de um balanceador de carga de camada 4.

Antes de começar

• Já existe um projeto na sua conta do GCP.

  Para criar um projeto, consulte Criar e gerenciar projetos. O nome do projeto utilizado neste guia é milvus-testing-nonprod.

• Você instalou localmente a CLI do gcloud, o kubectl e o Helm ou decidiu usar o Cloud Shell baseado em navegador.

• Você inicializou a CLI do gcloud com as credenciais da sua conta do GCP.

• Implantou um cluster do Milvus atrás de um balanceador de carga de camada 4 no GCP.

Ajustar as configurações do Milvus

Este guia pressupõe que você já implantou um cluster do Milvus por trás de um balanceador de carga de Camada 4 no GCP.

Antes de configurar um balanceador de carga da Camada 7 para esse cluster do Milvus, execute o seguinte comando para remover o balanceador de carga da Camada 4.

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

Como serviço de back-end do balanceador de carga de camada 7, o Milvus tem de cumprir determinados requisitos de encriptação para que possa compreender os pedidos HTTP/2 do balanceador de carga. Portanto, é necessário habilitar o TLS no cluster do Milvus da seguinte forma.

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

o conteúdo de tls.yaml:

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

Configurar um ponto de extremidade de verificação de integridade

Para garantir a disponibilidade do serviço, o balanceamento de carga da camada 7 no GCP requer a sondagem das condições de saúde do serviço de back-end. Portanto, precisamos configurar um BackendConfig para envolver o ponto de extremidade de verificação de integridade e associar o BackendConfig ao serviço Milvus por meio de anotações.

O snippet a seguir é a configuração do BackendConfig. Guarde-o como backendconfig.yaml para utilização posterior.

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

Em seguida, execute o seguinte comando para criar o ponto de extremidade de verificação de integridade.

kubectl apply -f backendconfig.yaml

Por fim, atualize as anotações do serviço Milvus para solicitar ao balanceador de carga Layer-7 que criaremos mais tarde que realize verificações de integridade usando o endpoint que acabamos de criar.

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

O TLS requer certificados para funcionar. Há duas maneiras de criar certificados: autogerenciados e gerenciados pelo Google.

Este guia utiliza my-release.milvus.io como nome de domínio para aceder ao nosso serviço Milvus.

Criar certificados autogeridos

Execute os seguintes comandos para criar um 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

Em seguida, crie um segredo no seu cluster GKE com estes ficheiros para utilização posterior.

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

Criar certificados geridos pelo Google

O seguinte snippet é uma configuração ManagedCertificate. Guarde-o como managed-crt.yaml para utilização posterior.

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

Crie um certificado gerido aplicando a definição ao seu cluster GKE da seguinte forma:

kubectl apply -f ./managed-crt.yaml

Isto pode demorar algum tempo. Pode verificar o progresso executando

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

O resultado deve ser semelhante ao seguinte:

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

Quando certificateStatus mudar para Active, estará pronto para configurar o balanceador de carga.

Criar um Ingress para gerar um balanceador de carga da camada 7

Crie um arquivo YAML com um dos seguintes snippets.

• Usando certificados autogerenciados

  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 gerenciados pelo 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
  

Em seguida, pode criar o Ingress aplicando o ficheiro ao seu cluster GKE.

kubectl apply -f ingress.yaml

Agora, aguarde que o Google configure o balanceador de carga da camada 7. Pode verificar o progresso executando

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

A saída deve ser semelhante à seguinte:

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

Assim que for apresentado um endereço IP no campo ENDEREÇO, o balanceador de carga da camada 7 está pronto a ser utilizado. Tanto a porta 80 quanto a porta 443 são exibidas na saída acima. Lembre-se de que você deve sempre usar a porta 443 para seu próprio bem.

Verificar a conexão através do balanceador de carga Layer-7

Este guia usa o PyMilvus para verificar a conexão com o serviço Milvus por trás do balanceador de carga Layer-7 que acabamos de criar. Para obter etapas detalhadas, leia isto.

Observe que os parâmetros de conexão variam de acordo com a maneira escolhida para gerenciar os certificados em 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")