Crea un balanceador de cargas interno en las redes de VPC


En esta página, se explica cómo crear un balanceador de cargas de red interno en Google Kubernetes Engine (GKE) en redes de VPC. Antes de leer esta página, debes familiarizarte con los siguientes conceptos:

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.

Crea un balanceador de cargas interno con Private Service Connect

Como productor de servicios, puedes usar adjuntos de servicio a fin de que tus servicios estén disponibles para los consumidores de servicios en otras redes de VPC mediante Private Service Connect. Puedes crear, administrar y borrar adjuntos de servicio mediante un recurso personalizado ServiceAttachment.

Requisitos y limitaciones

  • Se aplican las limitaciones para Private Service Connect.
  • Puedes crear un adjunto de servicio en las versiones 1.21.4-gke.300 y posteriores de GKE.
  • No puedes usar la misma subred para múltiples parámetros de configuración de adjuntos de servicio.
  • Debes crear un servicio de GKE que use un balanceador de cargas de red de transferencia interno.
  • No puedes especificar una subred en un proyecto diferente (VPC compartida) para versiones de GKE anteriores a la 1.22.4-gke.100. Para la VPC compartida, asegúrate de que se cumplan todos los requisitos de la VPC compartida.

Crea una ServiceAttachment

  1. Crea una subred.

    Debes crear una subred nueva 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
    

    Reemplaza lo siguiente:

    • SUBNET_NAME: es el nombre de la subred nueva. En las versiones de GKE 1.22.4-gke.100 y posteriores, puedes especificar una subred en un proyecto diferente mediante la URL de recurso completamente calificada para este campo. Puedes obtener la URL del recurso completamente calificado mediante el comando gcloud compute networks subnets describe.
    • PROJECT_ID es el ID de tu proyecto de Google Cloud.
    • NETWORK_NAME: es el nombre de la red de VPC para la subred.
    • REGION: Es la región de la subred nueva. Debes usar la misma región que el servicio que creas.
    • SUBNET_RANGE: El rango de direcciones IP que se usará para la subred.
  2. Implementar una carga de trabajo.

    En el siguiente manifiesto, se describe una implementación que ejecuta una imagen de contenedor de aplicación web de muestra. Guarda el manifiesto 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.2.19
            ports:
              - name: http
                containerPort: 8080
            readinessProbe:
              httpGet:
                path: /healthz
                port: 8080
                scheme: HTTP
              initialDelaySeconds: 5
              timeoutSeconds: 1
    
  3. Aplica el manifiesto al clúster:

    kubectl apply -f my-deployment.yaml
    
  4. Cómo crear un servicio En el siguiente manifiesto, se describe un servicio que crea un balanceador de cargas de red de transferencia interno en el puerto TCP 8080. Guarda el manifiesto 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
    

    Reemplaza lo siguiente:

    • SERVICE_NAME: Nombre del servicio nuevo.
  5. Aplica el manifiesto al clúster:

    kubectl apply -f my-service.yaml
    
  6. Crea ServiceAttachment.

    En el siguiente manifiesto, se describe un ServiceAttachment que expone el servicio que creaste a los consumidores de servicios. Guarda el manifiesto 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
    

    Reemplaza lo siguiente:

    • SERVICE_ATTACHMENT_NAME: Nombre del adjunto de servicio nuevo.
    • SUBNET_NAME: es el nombre de la subred nueva. En las versiones de GKE 1.22.4-gke.100 y posteriores, puedes especificar una subred en un proyecto diferente mediante la URL de recurso completamente calificada para este campo. Puedes obtener la URL del recurso completamente calificado mediante el comando gcloud compute networks subnets describe. Para una configuración de VPC compartida, usa el siguiente formato: projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNET_NAME.

    Para obtener más información sobre los campos del manifiesto, consulta los campos de adjuntos de servicio.

  7. Aplica el manifiesto al clúster:

    kubectl apply -f my-psc.yaml
    
  8. Verifica que el controlador de Private Service Connect haya creado el adjunto de servicio:

    gcloud beta compute service-attachments list
    

    El resultado muestra un adjunto de servicio con un nombre generado automáticamente:

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

Ve un ServiceAttachment

Puedes ver los detalles de un ServiceAttachment con el siguiente comando:

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

El resultado es similar a este:

 kubectl describe serviceattachment foo-sa
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>

Consume un ServiceAttachment

Para consumir tu servicio desde otro proyecto, realiza los siguientes pasos:

  1. Obtén la URL del ServiceAttachment:

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

    El resultado es similar a este:

      serviceAttachmentURL: https://www.googleapis.com/compute/alpha/projects/<project>/region/<region>/serviceAttachments/k8s1-...my-sa
    
  2. Crea un extremo de Private Service Connect con la URL de ServiceAttachment.

  3. Verifica que puedas conectarte al servicio que implementaste en el proyecto de productor mediante un comando curl desde una VM en el proyecto de consumidor:

    curl PSC_IP_ADDRESS
    

    Reemplaza PSC_IP_ADDRESS por la dirección IP de la regla de reenvío en el proyecto del consumidor.

    El resultado es similar a este:

    {
      "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"
    }
    

Actualiza una ServiceAttachment

Puedes actualizar un ServiceAttachment mediante los siguientes pasos:

  1. Edita el manifiesto ServiceAttachment en 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. Aplica el manifiesto al clúster:

    kubectl apply -f my-psc.yaml
    

Borra una ServiceAttachment

No puedes borrar un balanceador de cargas de red de transferencia interno que esté conectado a un adjunto de servicio. Debes borrar el adjunto de servicio y el servicio de GKE por separado.

  1. Borra el adjunto de servicio:

    kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false
    

    Con este comando, se marca el adjunto de servicio para su eliminación, pero el recurso continúa existiendo. También puedes esperar a que finalice la eliminación si omites la marca --wait.

  2. Borrar Service:

    kubectl delete svc SERVICE_NAME
    
  3. Borra la subred:

    gcloud compute networks subnets delete SUBNET_NAME
    

Campos ServiceAttachment

ServiceAttachment tiene los siguientes campos:

  • connectionPreference: es la preferencia de conexión que determina cómo los clientes se conectan al servicio. Puedes usar la aprobación automática del proyecto con ACCEPT_AUTOMATIC o la aprobación explícita del proyecto con ACCEPT_MANUAL. Para obtener más información, consulta Publica servicios mediante Private Service Connect.
  • natSubnets: una lista de nombres de recursos de subred para usar en el adjunto de servicio.
  • proxyProtocol: cuando se configura como verdadero, la IP de origen del consumidor y la ID de conexión de Private Service Connect están disponibles en las solicitudes. Este campo es opcional y su valor predeterminado es falso si no se proporciona.
  • consumerAllowList: es la lista de proyectos de consumidor que pueden conectarse a ServiceAttachment. Este campo solo se puede usar cuando connectionPreference es ACCEPT_MANUAL. Para obtener más información sobre este campo, consulta Publica servicios mediante Private Service Connect.
    • project: El número o ID del proyecto de consumidor.
    • connectionLimit: es el límite de conexión para el proyecto de consumidor. Este campo es opcional.
    • forceSendFields: son los nombres de campo que se enviarán a fin de incluir en las solicitudes a la API. Este campo es opcional.
    • nullFields: son los nombres de campo que se incluirán en las solicitudes a la API con un valor nulo. Este campo es opcional.
  • consumerRejectList: es la lista de ID o números de proyectos de consumidor que no pueden conectarse a ServiceAttachment. Este campo solo se puede usar cuando connectionPreference es ACCEPT_MANUAL. Para obtener más información sobre este campo, consulta Publica servicios mediante Private Service Connect.
  • resourceRef: Una referencia al recurso de Kubernetes.

    • kind: es el tipo de recurso de Kubernetes. Debes usar Service.
    • name: es el nombre del recurso de Kubernetes que debe estar en el mismo espacio de nombres que el balanceador de cargas de red de transferencia interno.

Soluciona problemas

Puedes ver los mensajes de error mediante el siguiente comando:

kubectl get events -n NAMESPACE

Reemplaza NAMESPACE por el espacio de nombres del balanceador de cargas de red de transferencia interno.

Aparece un mensaje de error similar al siguiente si intentas borrar un balanceador de cargas de red de transferencia interno que está usando un adjunto de servicio. Debes borrar ServiceAttachment para poder borrar el balanceador de cargas de red de transferencia 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.

¿Qué sigue?