Crie um balanceador de carga interno em redes VPC

Esta página explica como criar um balanceador de carga de rede de encaminhamento interno no Google Kubernetes Engine (GKE) em redes VPC.

Antes de ler esta página, certifique-se de que conhece os seguintes conceitos:

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ative a API Google Kubernetes Engine
  • Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.

Crie um balanceador de carga interno com o Private Service Connect

Enquanto produtor de serviços, pode usar anexos de serviços para disponibilizar os seus serviços aos consumidores de serviços noutras redes VPC através do Private Service Connect. Pode criar, gerir e eliminar associações de serviços através de um ServiceAttachmentrecurso personalizado.

Requisitos e limitações

  • Aplicam-se limitações ao Private Service Connect.
  • Pode criar uma associação de serviço nas versões do GKE 1.21.4-gke.300 e posteriores.
  • O seu cluster tem de ter o suplemento HttpLoadBalancing ativado. Os novos clusters do GKE têm o suplemento HttpLoadBalancing ativado por predefinição.
  • Não pode usar a mesma sub-rede em várias configurações de anexos de serviços.
  • Tem de criar um serviço do GKE que use um equilibrador de carga de rede de passagem interno.
  • Não pode especificar uma sub-rede num projeto diferente (VPC partilhada) para versões do GKE anteriores a 1.22.4-gke.100. Para a VPC partilhada, certifique-se de que cumpre todos os requisitos da VPC partilhada.
  • Depois de criar uma associação de serviço, não pode atualizar o equilibrador de carga interno. Para alterar as configurações do equilibrador de carga, tem de eliminar e recriar a associação de serviço.

Crie um ServiceAttachment

  1. Crie uma sub-rede.

    Tem de criar uma nova sub-rede para cada ServiceAttachment.

    gcloud beta compute networks subnets create SUBNET_NAME \
    --project PROJECT_ID \
    --network NETWORK_NAME \
    --region REGION \
    --range SUBNET_RANGE \
    --purpose PRIVATE_SERVICE_CONNECT

    Substitua o seguinte:

    • SUBNET_NAME: o nome da nova sub-rede. Nas versões 1.22.4-gke.100 e posteriores do GKE, pode especificar uma sub-rede num projeto diferente através do URL do recurso totalmente qualificado para este campo. Pode obter o URL do recurso totalmente qualificado através do comando gcloud compute networks subnets describe.
    • PROJECT_ID: o ID do seu projeto Google Cloud.
    • NETWORK_NAME: o nome da rede VPC para a sub-rede.
    • REGION: a região da nova sub-rede. Tem de usar a mesma região que o serviço que criar.
    • SUBNET_RANGE: o intervalo de endereços IP a usar para a sub-rede.

  2. Implemente uma carga de trabalho.

    O manifesto seguinte descreve uma implementação que executa uma imagem de contentor de aplicação Web de exemplo. Guarde o manifesto como my-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: psc-ilb
spec:
  replicas: 3
  selector:
    matchLabels:
      app: psc-ilb
  template:
    metadata:
      labels:
        app: psc-ilb
    spec:
      containers:
      - name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 5
          timeoutSeconds: 1

  3. Aplique o manifesto ao cluster:

    kubectl apply -f my-deployment.yaml

  4. Crie um serviço. O manifesto seguinte descreve um serviço que cria um balanceador de carga de rede de encaminhamento direto interno na porta TCP 8080. Guarde o manifesto como my-service.yaml:

     apiVersion: v1
 kind: Service
 metadata:
   name: SERVICE_NAME
   annotations:
     networking.gke.io/load-balancer-type: "Internal"
 spec:
   type: LoadBalancer
   selector:
     app: psc-ilb
   ports:
   - port: 80
     targetPort: 8080
     protocol: TCP

    Substitua o seguinte:

    • SERVICE_NAME: o nome do novo serviço.

  5. Aplique o manifesto ao cluster:

    kubectl apply -f my-service.yaml

  6. Criar ServiceAttachment.

    O manifesto seguinte descreve um ServiceAttachment que expõe o serviço que criou aos consumidores de serviços. Guarde o manifesto como my-psc.yaml:

    apiVersion: networking.gke.io/v1
kind: ServiceAttachment
metadata:
 name: SERVICE_ATTACHMENT_NAME
 namespace: default
spec:
 connectionPreference: ACCEPT_AUTOMATIC
 natSubnets:
 - SUBNET_NAME
 proxyProtocol: false
 resourceRef:
   kind: Service
   name: SERVICE_NAME

    Substitua o seguinte:

    • SERVICE_ATTACHMENT_NAME: o nome do novo anexo do serviço.
    • SUBNET_NAME: o nome da nova sub-rede. Nas versões 1.22.4-gke.100 e posteriores do GKE, pode especificar uma sub-rede num projeto diferente através do URL do recurso totalmente qualificado para este campo. Pode obter o URL do recurso totalmente qualificado através do comando gcloud compute networks subnets describe. Para uma configuração de VPC partilhada, use o seguinte formato: projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNET_NAME.

    Para mais informações sobre os campos do manifesto, consulte os campos de associação de serviços.

  7. Aplique o manifesto ao cluster:

    kubectl apply -f my-psc.yaml

  8. Verifique se o controlador do Private Service Connect criou a associação do serviço:

    gcloud beta compute service-attachments list

    A saída mostra uma associação de serviço com um nome gerado automaticamente:

    NAME        REGION       PRODUCER_FORWARDING_RULE          CONNECTION_PREFERENCE
k8s1-sa-... REGION_NAME  a3fea439c870148bdba5e59c9ea9451a  ACCEPT_AUTOMATIC

Veja um ServiceAttachment

Pode ver os detalhes de um ServiceAttachment através do seguinte comando:

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

O resultado é semelhante ao seguinte:

Name:        <sa-name>
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1beta1
Kind:         ServiceAttachment
Metadata:
  ...
Status:
  Forwarding Rule URL:      https://www.googleapis.com/compute/beta/projects/<project>/regions/<region>/forwardingRules/<fr-name>
  Last Modified Timestamp:  2021-07-08T01:32:39Z
  Service Attachment URL:   https://www.googleapis.com/compute/beta/projects/<projects>/regions/<region>/serviceAttachments/<gce-service-attachment-name>
Events:                     <none>

Consuma um ServiceAttachment

Para consumir o seu serviço a partir de outro projeto, siga estes passos:

  1. Obtenha o URL do ServiceAttachment:

    kubectl get serviceattachment SERVICE_ATTACHMENT_NAME -o=jsonpath="{.status.serviceAttachmentURL}"

    O resultado é semelhante ao seguinte:

      serviceAttachmentURL: https://www.googleapis.com/compute/alpha/projects/<project>/region/<region>/serviceAttachments/k8s1-...my-sa

  2. Crie um ponto final do Private Service Connect com o URL do ServiceAttachment.

  3. Verifique se consegue estabelecer ligação ao serviço implementado no projeto do produtor através de um comando curl a partir de uma VM no projeto do consumidor:

    curl PSC_IP_ADDRESS

    Substitua PSC_IP_ADDRESS pelo endereço IP da regra de encaminhamento no projeto do consumidor.

    O resultado é semelhante ao seguinte:

    {
  "cluster_name":"cluster",
  "host_header":"10.128.15.200",
  "node_name":"gke-psc-default-pool-be9b6e0e-dvxg.c.gke_project.internal",
  "pod_name":"foo-7bf648dcfd-l5jf8",
  "pod_name_emoji":"👚",
  "project_id":"gke_project",
  "timestamp":"2021-06-29T21:32:03",
  "zone":"ZONE_NAME"
}

Atualize um ServiceAttachment

Pode atualizar um ServiceAttachment através dos seguintes passos:

  1. Edite o manifesto ServiceAttachment em my-psc.yaml:

    apiVersion: networking.gke.io/v1
kind: ServiceAttachment
metadata:
  name: my-sa
  namespace: default
spec:
  connectionPreference: ACCEPT_AUTOMATIC
  natSubnets:
  - my-nat-subnet
  proxyProtocol: false
  resourceRef:
    kind: Service
    name: ilb-service

  2. Aplique o manifesto ao cluster:

    kubectl apply -f my-psc.yaml

Elimine um ServiceAttachment

Não é possível eliminar um balanceador de carga de encaminhamento interno que esteja ligado a uma associação de serviço. Tem de eliminar a associação de serviço e o GKE Service separadamente.

  1. Elimine a associação de serviços:

    kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false

    Este comando marca a associação de serviço para eliminação, mas o recurso continua a existir. Também pode aguardar que a eliminação termine omitindo a flag --wait.

  2. Elimine o serviço:

    kubectl delete svc SERVICE_NAME

  3. Elimine a sub-rede:

    gcloud compute networks subnets delete SUBNET_NAME

ServiceAttachment campos

O ServiceAttachment tem os seguintes campos:

  • connectionPreference: a preferência de ligação que determina como os clientes se ligam ao serviço. Pode usar a aprovação automática de projetos através de ACCEPT_AUTOMATIC ou a aprovação explícita de projetos através de ACCEPT_MANUAL. Para mais informações, consulte o artigo Publicar serviços através do Private Service Connect.
  • natSubnets: uma lista de nomes de recursos de sub-redes a usar para a associação do serviço.
  • proxyProtocol: quando definido como verdadeiro, o IP de origem do consumidor e o ID da ligação do Private Service Connect estão disponíveis nos pedidos. Este campo é opcional e reverte para a predefinição false se não for fornecido.
  • consumerAllowList: a lista de projetos de consumidor que têm autorização para se ligarem ao ServiceAttachment. Este campo só pode ser usado quando connectionPreference é ACCEPT_MANUAL. Para mais informações acerca deste campo, consulte o artigo Publicar serviços através do Private Service Connect.
    • project: o ID ou o número do projeto do consumidor.
    • connectionLimit: o limite de ligações para o projeto de consumidor. Este campo é opcional.
    • forceSendFields: os nomes dos campos a enviar para inclusão nos pedidos de API. Este campo é opcional.
    • nullFields: os nomes dos campos a incluir em pedidos de API com um valor nulo. Este campo é opcional.
  • consumerRejectList: a lista de IDs ou números de projetos de consumidor que não têm autorização para estabelecer ligação à ServiceAttachment. Este campo só pode ser usado quando connectionPreference é ACCEPT_MANUAL. Para mais informações acerca deste campo, consulte o artigo Publicar serviços através do Private Service Connect.

  • resourceRef: uma referência ao recurso do Kubernetes.

    • kind: o tipo de recurso do Kubernetes. Tem de usar o Service.
    • name: o nome do recurso do Kubernetes que tem de estar no mesmo espaço de nomes que o balanceador de carga de passagem interno da rede.

Resolução de problemas

Pode ver mensagens de erro através do seguinte comando:

kubectl get events -n NAMESPACE

Substitua NAMESPACE pelo espaço de nomes do Network Load Balancer de passagem interno.

Erro ao eliminar o balanceador de carga de passagem interno

Ocorre uma mensagem de erro semelhante à seguinte se tentar eliminar um Network Load Balancer de encaminhamento interno que está a ser usado por uma associação de serviço. Tem de eliminar o ServiceAttachment antes de poder eliminar o Network Load Balancer de encaminhamento interno.

Error syncing load balancer: failed to ensure load balancer: googleapi:
Error 400: The forwarding_rule resource '<fwd-rule-URL>' is already being used
by '<svc-attachment-URL>', resourceInUseByAnotherResource.

Erro ao ativar o acesso global

Pode ocorrer um erro quando ativa o acesso global para um balanceador de carga de rede de encaminhamento interno que usa uma associação de serviço do Private Service Connect.

Sintoma:

Quando ativa o acesso global atualizando o manifesto do serviço do GKE e definindo a anotação networking.gke.io/internal-load-balancer-allow-global-access: "true", a atualização falha quando aplica o manifesto. É apresentada a seguinte mensagem de erro quando executa o comando kubectl get events:

Error syncing load balancer: failed to ensure load balancer: googleapi: Error 400: The forwarding_rule resource '...' is already being used by '...', resourceInUseByAnotherResource

Motivo:

Este erro ocorre porque o plano de controlo do GKE tenta recriar a regra de encaminhamento do balanceador de carga para ativar o acesso global. No entanto, como a regra de encaminhamento está a ser usada por um ServiceAttachment, não é possível eliminar e recriar a regra, o que resulta no erro.

Solução alternativa:

Para ativar o acesso global no balanceador de carga e minimizar o tempo de inatividade, tem de atualizar a configuração do serviço do GKE e atualizar manualmente a regra de encaminhamento:

  1. Atualize o manifesto do serviço GKE: atualize o manifesto do serviço GKE para incluir a anotação networking.gke.io/internal-load-balancer-allow-global-access: "true".

  2. Ative manualmente o acesso global na regra de encaminhamento: siga os passos em Ativar acesso global para atualizar a regra de encaminhamento do equilibrador de carga através da Google Cloud consola, da CLI Google Cloud ou da API Compute Engine.

O que se segue?