Crea un balanceador de cargas externo basado en servicios de backend

Autopilot estándar

En esta página, se muestra cómo implementar un objeto Service LoadBalancer externo que compila un balanceador de cargas de red de transferencia externo basado en servicios de backend. Antes de leer esta página, asegúrate de estar familiarizado con lo siguiente:

• Acerca de los Services LoadBalancer
• Parámetros de objeto Service LoadBalancer de GKE

Para obtener más información sobre los balanceadores de cargas de red de transferencia externos en general, consulta Balanceador de cargas de red de transferencia externo basado en servicios de backend.

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 la gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de la gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.
  Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Requisitos

• En este instructivo, se usa spec.loadBalancerClass para crear un balanceador de cargas de red de transferencia externo basado en servicios de backend con backends de NEG GCE_VM_IP. Este instructivo requiere la versión 1.33.1-gke.1779000 de GKE o una posterior, ya que spec.loadBalancerClass requiere la versión 1.33.1-gke.1779000 de GKE o una posterior. La versión 1.33.1-gke.1779000 o posterior también supera los requisitos mínimos de la versión de GKE para los backends de NEG o la función de balanceador de cargas ponderado.

• Si tu clúster está en una versión anterior a la 1.36, el complemento HttpLoadBalancing debe estar habilitado en tu clúster. Este complemento está habilitado de forma predeterminada. Para obtener más información, consulta Requisito previo de HttpLoadBalancing.

• Para habilitar Cloud Logging en un Service LoadBalancer externo, tu clúster de GKE debe usar la versión 1.36.0-gke.2459000 o una posterior.

Elige un clúster

Puedes crear un clúster nuevo o elegir uno existente que cumpla con los requisitos.

Crea un clúster nuevo

Autopilot

Para crear un clúster de Autopilot nuevo, sigue estos pasos:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Reemplaza lo siguiente:

• CLUSTER_NAME es el nombre del clúster nuevo.
• RELEASE_CHANNEL: el nombre del canal de versiones de GKE para el clúster.
• VERSION: Es la versión de GKE para el clúster.
• COMPUTE_LOCATION: la región de Compute Engine del clúster.

Para inhabilitar la creación automática de reglas de firewall de VPC para los servicios de LoadBalancer, incluye la marca --disable-l4-lb-firewall-reconciliation. Para obtener más información, consulta Reglas de firewall administradas por el usuario para los servicios de LoadBalancer de GKE.

Standard

Para crear un clúster estándar nuevo, sigue estos pasos:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Reemplaza lo siguiente:

• CLUSTER_NAME es el nombre del clúster nuevo.
• RELEASE_CHANNEL: el nombre del canal de versiones de GKE para el clúster.
• VERSION: Es la versión de GKE para el clúster.
• COMPUTE_LOCATION: la región de Compute Engine del clúster.

Para inhabilitar la creación automática de reglas de firewall de VPC para los servicios de LoadBalancer, incluye la marca --disable-l4-lb-firewall-reconciliation. Para obtener más información, consulta Reglas de firewall administradas por el usuario para los servicios de LoadBalancer de GKE.

Actualiza un clúster existente:

Usa gcloud CLI para actualizar un clúster existente:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Reemplaza lo siguiente:

• CLUSTER_NAME: es el nombre del clúster existente.
• VERSION: Es la versión específica de GKE a la que deseas actualizar tu clúster. Para obtener más información, consulta Actualiza el plano de control de forma manual.
• COMPUTE_LOCATION: La región de Compute Engine del clúster.

Para inhabilitar la creación automática de reglas de firewall de VPC para los servicios de LoadBalancer, incluye la marca --disable-l4-lb-firewall-reconciliation. Para obtener más información, consulta Reglas de firewall administradas por el usuario para los servicios de LoadBalancer de GKE.

Implementa una carga de trabajo de muestra

Implementa la siguiente carga de trabajo de muestra que proporciona los Pods de entrega para el servicio LoadBalancer externo.

1. Guarda el siguiente Deployment de muestra como store-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store
   spec:
     replicas: 20
     selector:
       matchLabels:
         app: store
     template:
       metadata:
         labels:
           app: store
       spec:
         containers:
         - image: registry.k8s.io/echoserver:1.10
           imagePullPolicy: Always
           name: echoserver
           ports:
             - name: http
               containerPort: 8080
           readinessProbe:
             httpGet:
               path: /healthz
               port: 8080
               scheme: HTTP
   

2. Aplica el manifiesto al clúster:

   kubectl apply -f store-deployment.yaml
   

3. Verifica que haya 20 Pods de entrega para el Deployment:

   kubectl get pods
   

   El resultado es similar a lo siguiente:

   NAME                     READY   STATUS    RESTARTS   AGE
   store-cdb9bb4d6-s25vw      1/1     Running   0          10s
   store-cdb9bb4d6-vck6s      1/1     Running   0          10s
   ....
   

Crea el objeto Service LoadBalancer externo

1. Expón la carga de trabajo de muestra creando un servicio LoadBalancer externo.

   1. Guarda el siguiente manifiesto de Service como store-v1-lb-svc.yaml:

      apiVersion: v1
      kind: Service
      metadata:
        name: store-v1-lb-svc
      spec:
        type: LoadBalancer
        loadBalancerClass: networking.gke.io/l4-regional-external
        selector:
          app: store
        ports:
        - name: tcp-port
          protocol: TCP
          port: 8080
          targetPort: 8080
      

   2. Aplica el manifiesto al clúster:

      kubectl apply -f store-v1-lb-svc.yaml
      

   Ten en cuenta los siguientes puntos sobre este manifiesto de muestra:

   • Debes establecer el campo spec.loadBalancerClass en el valor networking.gke.io/l4-regional-external en el momento en que se aplica el manifiesto por primera vez al clúster. Este campo indica a GKE que cree un balanceador de cargas de red de transferencia externo basado en servicios de backend. Los balanceadores de cargas de red de transferencia externos basados en servicios de backend son obligatorios para admitir funciones como IPv6 y el balanceo de cargas ponderado.

   • GKE usa backends de NEG GCE_VM_IP o backends de grupos de instancias no administrados, según la versión del clúster. En los clústeres con la versión 1.32.2-gke.1652000, el balanceador de cargas de red de transferencia externo basado en servicios de backend usa NEG GCE_VM_IP. En versiones anteriores, el balanceador de cargas de red de transferencia externo basado en servicios de backend usa grupos de instancias no administrados.

   • Este campo spec.loadBalancerClass es inmutable y se debe establecer cuando creas el servicio. Como este campo es inmutable, no puedes agregarlo ni modificarlo en el manifiesto de un servicio LoadBalancer existente. Cualquier intento de hacerlo generará un error y la actualización del servicio fallará.

Habilita el balanceo de cargas ponderado

Para distribuir las conexiones nuevas de forma proporcional a los nodos según la cantidad de Pods de entrega, listos y no finalizables que hay en cada nodo, habilita el balanceo de cargas ponderado agregando la anotación networking.gke.io/weighted-load-balancing: "pods-per-node" al manifiesto del Service.

1. Agrega la anotación networking.gke.io/weighted-load-balancing: "pods-per-node" al manifiesto del servicio store-v1-lb-svc.yaml y asegúrate de establecer también el valor externalTrafficPolicy: Local para que se vea de la siguiente manera:

   apiVersion: v1
   kind: Service
   metadata:
     name: store-v1-lb-svc
     annotations:
       networking.gke.io/weighted-load-balancing: "pods-per-node"
   spec:
     type: LoadBalancer
     loadBalancerClass: networking.gke.io/l4-regional-external
     externalTrafficPolicy: Local
     selector:
       app: store
     ports:
     - name: tcp-port
       protocol: TCP
       port: 8080
       targetPort: 8080
   

2. Aplica el manifiesto al clúster:

   kubectl apply -f store-v1-lb-svc.yaml
   

Ten en cuenta lo siguiente sobre este ejemplo de balanceo de cargas ponderado:

• El manifiesto de servicio usa externalTrafficPolicy: Local. Si no necesitas habilitar el balanceo de cargas ponderado, también puedes usar externalTrafficPolicy: Cluster. Para obtener detalles sobre cómo externalTrafficPolicy define la agrupación de nodos, qué nodos pasan sus verificaciones de estado del balanceador de cargas y cómo se procesan los paquetes, consulta Conceptos del objeto Service LoadBalancer.

• Si habilitas el balanceo de cargas ponderado, GKE no te impedirá usar externalTrafficPolicy: Cluster, pero externalTrafficPolicy: Cluster inhabilita de manera efectiva el balanceo de cargas ponderado porque el paquete podría enrutarse, después del balanceador de cargas, a un nodo diferente.

También puedes habilitar el balanceo de cargas ponderado en un Service LoadBalancer externo existente con kubectl edit svc service-name. El comando kubectl edit abre el manifiesto del servicio del balanceador de cargas existente en el editor de texto configurado, donde puedes modificar el manifiesto y guardar los cambios. Cuando edites un Service LoadBalancer externo existente, ten en cuenta los siguientes puntos:

• El objeto Service LoadBalancer externo existente debe haber generado la creación de un balanceador de cargas de red de transferencia externo basado en servicios de backend. Esto significa que el objeto Service LoadBalancer externo existente debe tener el campo spec.loadBalancerClass establecido en networking.gke.io/l4-regional-external cuando se aplicó el manifiesto por primera vez al clúster.

  Agregar la anotación networking.gke.io/weighted-load-balancing: "pods-per-node" a un objeto Service LoadBalancer externo existente que usa un balanceador de cargas de red de transferencia externo basado en grupos de destino no tiene ningún efecto.

• Cuando actualices el manifiesto del Service LoadBalancer externo existente, asegúrate de establecer el valor externalTrafficPolicy: Local. El uso de externalTrafficPolicy: Cluster inhabilita de manera eficaz el balanceo de cargas ponderado, ya que el paquete podría enrutarse, después del balanceador de cargas, a un nodo diferente.

Inhabilita el balanceo de cargas ponderado

Para distribuir las conexiones nuevas a los nodos, independientemente de la cantidad de Pods de procesamiento que haya en cada nodo, inhabilita el balanceo de cargas ponderado quitando la anotación networking.gke.io/weighted-load-balancing: "pods-per-node" del manifiesto del Service.

Nota: Habilitar o inhabilitar el balanceo de cargas ponderado borra la tabla de seguimiento de conexiones del balanceador de cargas. Las conexiones existentes se pueden enrutar a diferentes nodos, lo que provoca que esos nodos envíen paquetes de restablecimiento de TCP. Como práctica recomendada, habilita o inhabilita el balanceo de cargas ponderado cuando se pueda tolerar un breve período de interrupciones de conexión.

Habilita el registro para los servicios de backend

Puedes habilitar, inhabilitar y ver registros para un balanceador de cargas de red de transferencia externo basado en servicios de backend.

Para configurar Cloud Logging, crea un recurso personalizado L4LBConfig que especifique tu configuración de registro. El recurso L4LBConfig está vinculado a un servicio de Kubernetes en el manifiesto de Service. Después de aplicar el manifiesto, el controlador de GKE configura el registro para el servicio de backend. Si no vinculas un recurso L4LBConfig al servicio, el controlador se asegura de que el registro esté inhabilitado y anula cualquier intento manual de habilitarlo.

Puedes configurar los siguientes campos:

• enabled: Si se configura como true, habilita el registro para este servicio, y los registros estarán disponibles en Cloud Logging. De lo contrario, se inhabilitará el registro para este servicio.
• sampleRate: Especifica un valor de 0 a 1,000,000 (predeterminado), en el que 0 significa que no se registran paquetes y 1,000,000 significa que se registra el 100% de los paquetes. El campo sampleRate es opcional y solo es relevante si el valor del campo enable se establece en true.
• optionalMode: Controla qué campos de metadatos opcionales se incluyen en los registros generados para el balanceador de cargas. El campo acepta uno de los siguientes valores de cadena:
  • EXCLUDE_ALL_OPTIONAL: Es el parámetro de configuración predeterminado si no se especifica optionalMode. Cuando se configura, no se incluyen campos opcionales en los registros, lo que proporciona el formato de registro más conciso.
  • INCLUDE_ALL_OPTIONAL: Habilita el registro para todos los campos opcionales disponibles, lo que proporciona las entradas de registro más detalladas.
  • CUSTOM: Especifica una lista personalizada de campos opcionales que se incluyen en los registros. Con el modo CUSTOM, también debes usar el parámetro optionalFields para proporcionar una lista separada por comas de los campos que deseas.
• optionalFields: Es una cadena separada por comas de nombres de campos. Define los campos de metadatos opcionales exactos que deseas incluir en los registros generados. Este campo solo se usa cuando optionalMode se establece en CUSTOM. De lo contrario, se ignoran los valores.

Para configurar Cloud Logging, crea el recurso L4LBConfig en el mismo espacio de nombres que tu recurso Service. En el siguiente manifiesto de ejemplo de L4LBConfig, se habilita Cloud Logging y se establece la tasa de muestreo en el 50% de las solicitudes para un servicio de balanceador de cargas determinado.

1. Guarda el siguiente manifiesto como svc-l4lb-config.yaml:

   apiVersion: networking.gke.io/v1
   kind: L4LBConfig
   metadata:
     name: svc-l4lb-config
     namespace: default
   spec:
     logging:
       enabled: true # must be included
       sampleRate: 500000
       optionalMode: "INCLUDE_ALL_OPTIONAL"
   

2. Aplica el manifiesto de L4LBConfig a tu clúster:

   kubectl apply -f svc-l4lb-config.yaml
   

3. Agrega la anotación networking.gke.io/l4lb-config al manifiesto de servicio store-v1-lb-svc.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: store-v1-lb-svc
     annotations:
       cloud.google.com/l4-rbs: "enabled"
       networking.gke.io/l4lb-config: "svc-l4lb-config"
   spec:
     type: LoadBalancer
     selector:
       app: store
     ports:
       - name: tcp-port
         protocol: TCP
         port: 8080
         targetPort: 8080
   

4. Aplica el manifiesto de Service a tu clúster:

   kubectl apply -f store-v1-lb-svc.yaml
   

Verifica el objeto Service LoadBalancer externo y sus componentes

1. Verifica que el Service esté en ejecución:

   kubectl get svc store-v1-lb-svc
   

   El resultado es similar a este:

   NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
   store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
   

   GKE asignó un EXTERNAL_IP para el balanceador de cargas de red de transferencia externo.

   Nota: GKE puede tardar unos minutos en asignar una dirección IP externa antes de que el balanceador de cargas esté listo para entregar tu aplicación.

2. Prueba la conexión al balanceador de cargas:

   curl EXTERNAL_IP:PORT
   

   Reemplaza lo siguiente:

   • EXTERNAL_IP: Es la dirección IP asignada para el Balanceador de cargas de red de transferencia externo.
   • PORT: el número de puerto asignado para el balanceador de cargas de red de transferencia externo.

   El resultado es similar a lo siguiente:

   Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd
   
   Pod Information:
     -no pod information available-
   
   Server values:
     server_version=nginx: 1.13.3 - lua: 10008
   
   Request Information:
     client_address=10.128.0.50
     method=GET
     real path=/
     query=
     request_version=1.1
     request_scheme=http
     request_uri=EXTERNAL_IP
   
   Request Headers:
     accept=*/*
     host=EXTERNAL_IP
     user-agent=curl/7.81.0
   
   Request Body:
     -no body in request-
   
   

3. Verifica el objeto Service LoadBalancer y su conjunto de anotaciones que describen sus recursos deGoogle Cloud :

   kubectl describe svc store-v1-lb-svc
   

   El resultado es similar a lo siguiente:

   Name:                     my-service-external
   Namespace:                default
   Labels:                   <none>
   Annotations:              cloud.google.com/neg-status: {"network_endpoint_groups":{"0":"k8s2-qvveq1d8-default-my-service-ext-5s55db85"},"zones":["us-central1-c"]} #This annotation appears in the output only if the service uses NEG backends.
                             networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                             service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                             service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
   Selector:                 app=my-app
   Type:                     LoadBalancer
   IP Family Policy:         SingleStack
   IP Families:              IPv4
   IP:                       10.18.102.23
   IPs:                      10.18.102.23
   LoadBalancer Ingress:     35.184.160.229
   Port:                     tcp-port  8080/TCP
   TargetPort:               8080/TCP
   NodePort:                 tcp-port  31864/TCP
   Endpoints:                10.20.1.28:8080,10.20.1.29:8080
   Session Affinity:         None
   External Traffic Policy:  Local
   HealthCheck NodePort:     30394
   
   Events:
     Type    Reason                Age                    From                     Message
     ----    ------                ----                   ----                     -------
     Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
   

   Hay varios campos que indican que un balanceador de cargas de red de transferencia externo basado en servicios de backend y sus recursos de Google Cloud se crearon correctamente:

   • Campo Events. Este campo está vacío cuando el Service LoadBalancer y sus recursos se crearon de forma correcta. Si se produjo un error, aparecerá aquí.

   • Lista de Annotations habilitada: GKE agrega la siguiente lista de anotaciones de solo lectura al manifiesto de Service. Cada anotación cuyo nombre comienza con service.kubernetes.io/ se usa para indicar el nombre de un recurso deGoogle Cloud creado como parte del balanceador de cargas o para admitirlo.

     • La anotación networking.gke.io/weighted-load-balancing: pods-per-node indica que se aplicó el balanceo de cargas ponderado y que el balanceador de cargas distribuye el tráfico a los Pods de backend según la cantidad de Pods que se ejecutan en cada nodo.
     • La anotación service.kubernetes.io/backend-service indica el nombre del servicio de backend del balanceador de cargas.
     • La anotación service.kubernetes.io/healthcheck indica el nombre de la verificación de estado del balanceador de cargas que usa el servicio de backend.
     • La anotación service.kubernetes.io/tcp-forwarding-rule o service.kubernetes.io/udp-forwarding-rule indica el nombre de la regla de reenvío del balanceador de cargas.
     • La anotación service.kubernetes.io/firewall-rule indica el nombre de la regla de firewall creada para permitir el tráfico hacia los nodos del clúster. Los rangos de origen para esta regla de firewall se pueden personalizar con spec.loadBalancerSourceRanges[]. Si deseas obtener detalles adicionales sobre las reglas de firewall para los servicios de LoadBalancer, consulta Reglas de firewall y lista de entidades permitidas de direcciones IP de origen.
     • La anotación service.kubernetes.io/firewall-rule-for-hc indica el nombre de la regla de firewall requerida para las verificaciones de estado del balanceador de cargas.

     • La anotación cloud.google.com/neg-status indica tanto los NEG que usa el balanceador de cargas como sus zonas. Esta anotación solo está presente cuando se cumplen las siguientes condiciones:

       • El clúster ejecutaba la versión 1.32.2-gke.1652000 de GKE o una posterior cuando se aplicó el manifiesto al clúster.
       • El campo spec.loadBalancerClass que se estableció en el valor networking.gke.io/l4-regional-external estaba presente en el manifiesto de Service cuando se aplicó al clúster.

4. Verifica que se hayan creado los recursos del balanceador de cargas y las reglas de firewall para el objeto Service LoadBalancer externo:

   • Para ver la regla de reenvío, ejecuta el siguiente comando:

       gcloud compute forwarding-rules describe FWD_RULE_NAME \
         --region=REGION_NAME
     

     Reemplaza lo siguiente:

     • FWD_RULE_NAME: El nombre de la regla de reenvío que proporcionan las anotaciones de solo lectura service.kubernetes.io/tcp-forwarding-rule o service.kubernetes.io/udp-forwarding-rule. Para verificar estas anotaciones, ejecuta kubectl describe svc SERVICE_NAME.
     • REGION_NAME: Es la Google Cloud región que contiene el clúster. Para los clústeres zonales, la región contiene la zona que usa el clúster.

   • Para ver el servicio de backend, ejecuta el siguiente comando:

     gcloud compute backend-services describe BACKEND_SERVICE_NAME \
       --region=REGION_NAME
     

     Reemplaza lo siguiente:

     • BACKEND_SERVICE_NAME: El nombre del servicio de backend que proporciona la anotación de solo lectura service.kubernetes.io/backend-service. Para verificar esta anotación de solo lectura, ejecuta kubectl describe svc SERVICE_NAME.
     • REGION_NAME: Es la Google Cloud región que contiene el clúster. Para los clústeres zonales, la región contiene la zona que usa el clúster.

   • Para ver la verificación de estado del balanceador de cargas, ejecuta el siguiente comando:

     gcloud compute health-checks describe HEALTH_CHECK_NAME \
       --region=REGION_NAME
     

     Reemplaza lo siguiente:

     • HEALTH_CHECK_NAME: Es el nombre de la verificación de estado del balanceador de cargas. El nombre de la verificación de estado se proporciona a través de la anotación de solo lectura service.kubernetes.io/healthcheck. Para verificar esta anotación de solo lectura, ejecuta kubectl describe svc SERVICE_NAME.
     • REGION_NAME: Es la Google Cloud región que contiene el clúster. Para los clústeres zonales, la región contiene la zona que usa el clúster.

   • Para ver las reglas de firewall, ejecuta los siguientes comandos:

     gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
     gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
     

     Reemplaza lo siguiente:

     • FIREWALL_RULE_NAME: Es el nombre de la regla de firewall que permite el tráfico al balanceador de cargas. El nombre de esta regla de firewall se proporciona a través de la anotación de solo lectura service.kubernetes.io/firewall-rule. Para verificar esta anotación de solo lectura, ejecuta kubectl describe svc SERVICE_NAME.
     • HEALTH_CHECK_FIREWALL_RULE_NAME: Es el nombre de la regla de firewall que permite las verificaciones de estado de los backends del balanceador de cargas (los nodos del clúster). El nombre de esta regla de firewall se proporciona a través de la anotación de solo lectura service.kubernetes.io/firewall-rule-for-hc. Para verificar esta anotación de solo lectura, ejecuta kubectl describe svc SERVICE_NAME.

   • Para ver los NEG del balanceador de cargas, ejecuta el siguiente comando:

     gcloud compute network-endpoint-groups describe NEG_NAME \
       --zone=ZONE_NAME
     

     Reemplaza lo siguiente:

     • NEG_NAME: Es el nombre del NEG del balanceador de cargas. El nombre del NEG se proporciona a través de la anotación de solo lectura cloud.google.com/neg-status. Para verificar esta anotación de solo lectura, ejecuta el comando kubectl describe svc SERVICE_NAME. La anotación contiene datos estructurados con información sobre los nombres y las zonas de NEG que utiliza el balanceador de cargas. En el caso de los clústeres zonales, esta anotación contiene información sobre un NEG. Para los clústeres regionales, esta anotación contiene información sobre un NEG en cada zona en la que se encuentra el clúster.
     • ZONE_NAME: La Google Cloud zona que contiene el NEG.

5. Verifica que Cloud Logging se haya habilitado para el servicio de backend:

   kubectl get svc SERVICE_NAME --output yaml
   

   Reemplaza lo siguiente:

   • SERVICE_NAME: el nombre del servicio de backend.

   En el resultado, asegúrate de que el campo Status.Conditions tenga Type: LoggingConfigManaged y Reason: Reconciled.

Borra el objeto Service LoadBalancer externo

Para borrar el objeto Service LoadBalancer externo de store-v1-lb-svc de muestra, usa el siguiente comando:

kubectl delete service store-v1-lb-svc

GKE quita automáticamente todos los recursos del balanceador de cargas que creó para el Service LoadBalancer externo.

Migra a backends de NEG GCE_VM_IP

Los objetos Service LoadBalancer externos con el campo spec.loadBalancerClass establecido en el valor networking.gke.io/l4-regional-external o con la anotación cloud.google.com/l4-rbs: "enabled" crean balanceadores de cargas de red de transferencia externos basados en servicios de backend que usan backends de grupos de instancias o grupos de extremos de red GCE_VM_IP, según la versión de GKE del clúster:

• Si el manifiesto de Service se aplicó a un clúster que ejecuta la versión 1.32.2-gke.1652000 o posterior de GKE, el balanceador de cargas de red de transferencia externo resultante usa backends de grupo de extremos de red (NEG) GCE_VM_IP.

• Si el manifiesto del objeto Service se aplicó a un clúster que ejecuta una versión anterior de GKE, el balanceador de cargas de red de transferencia externo resultante usa backends de grupos de instancias no administrados.

Para obtener más información, consulta Agrupación de nodos en Acerca de los servicios de LoadBalancer.

Puedes crear un nuevo Service LoadBalancer externo con un balanceador de cargas de red de transferencia externo basado en servicios de backend que use backends de NEG GCE_VM_IP si tu Service existente usa uno de los siguientes balanceadores de cargas:

• Un balanceador de cargas de red de transferencia externo basado en servicios de backend con backends de grupos de instancias
• Un balanceador de cargas de red de transferencia externo basado en grupos de destino

Nota: Cambiar a un balanceador de cargas de red de transferencia externo basado en servicios de backend que use backends de NEG GCE_VM_IP requiere unos minutos de inactividad para reemplazar el servicio.

Para cambiar a un balanceador de cargas de red de transferencia externo basado en servicios de backend con backends de NEG GCE_VM_IP, haz lo siguiente:

1. Si aún no lo hiciste, actualiza tu clúster a la versión 1.32.2-gke.1652000 o posterior de GKE.

2. Identifica el objeto Service LoadBalancer externo al que deseas cambiar a un balanceador de cargas de red de transferencia externo basado en servicios de backend con backends de NEG GCE_VM_IP. Describe el Service con el siguiente comando:

   kubectl describe svc SERVICE_NAME -n SERVICE_NAMESPACE
   

   Reemplaza lo siguiente:

   • SERVICE_NAME: Es el nombre del servicio LoadBalancer externo existente.

   • SERVICE_NAMESPACE: Es el espacio de nombres del objeto Service LoadBalancer externo existente.

   En el resultado del comando, anota la dirección IPv4 externa del balanceador de cargas que aparece después de LoadBalancer Ingress.

3. Recupera el manifiesto del servicio para el servicio LoadBalancer existente:

   • Lo mejor es que tengas el manifiesto de Service original que aplicaste al clúster en el pasado. Por ejemplo, podrías tenerlo en un repositorio de control de código fuente.

   • Si no tienes el manifiesto del servicio original, haz lo siguiente:

     • Ejecuta el siguiente comando para obtener una copia en formato YAML del manifiesto del servicio que representa la implementación actual del balanceador de cargas:

       kubectl get svc SERVICE_NAME -n SERVICE_NAMESPACE -o yaml
       

     • Copia el manifiesto YAML en un editor de texto. Quita el atributo status y los siguientes atributos metadata:

       • Todas las siguientes anotaciones:
         • La anotación kubectl.kubernetes.io/last-applied-configuration
         • Todas las anotaciones que comienzan con service.kubernetes.io
       • creationTimestamp
       • finalizers
       • resourceVersion
       • uid

   • Asegúrate de que el manifiesto incluya el campo spec.loadBalancerClass establecido en el valor networking.gke.io/l4-regional-external. Si migras desde un balanceador de cargas de red de transferencia externo basado en grupos de destino, se debe agregar el campo.

   Guarda el archivo de manifiesto y anota dónde lo guardaste. El resto de este procedimiento hace referencia a la ruta en la que guardaste el manifiesto como MANIFEST_FILE_PATH.

4. Configura un recurso de dirección IPv4 externa estática para que contenga la dirección IPv4 externa que usa el balanceador de cargas existente:

   gcloud compute addresses create IP_ADDRESS_NAME --region=CLUSTER_REGION --addresses LB_EXTERNAL_IP
   

   Reemplaza lo siguiente:

   • IP_ADDRESS_NAME: Es el nombre de la dirección IP externa estática. El nombre debe cumplir con las convenciones de nombres para los recursos de Compute Engine.

   • CLUSTER_REGION: Es la región que contiene el clúster. En el caso de los clústeres zonales, esta es la región que contiene la zona del clúster.

   • LB_EXTERNAL_IP: Es la dirección IPv4 externa que usa el balanceador de cargas actual, determinada en el segundo paso de este procedimiento.

5. Verifica que se haya creado el recurso de dirección IPv4 externa estática:

   gcloud compute addresses describe IP_ADDRESS_NAME --region=CLUSTER_REGION
   

   Reemplaza las variables como se indica en el paso anterior.

6. Borra el servicio existente:

   kubectl delete svc SERVICE_NAME -n SERVICE_NAMESPACE
   

7. Agrega la siguiente anotación al archivo de manifiesto del servicio MANIFEST_FILE_PATH:

   networking.gke.io/load-balancer-ip-addresses: IP_ADDRESS_NAME
   

   Para obtener más información sobre esta anotación, consulta Direcciones IP estáticas en los parámetros del objeto Service LoadBalancer.

8. Aplica el manifiesto de Service actualizado al clúster:

   kubectl apply -f MANIFEST_FILE_PATH
   

9. (Opcional) Libera el recurso de dirección IPv4 estática.

   gcloud compute addresses delete IP_ADDRESS_NAME --region=CLUSTER_REGION
   

Solucionar problemas

En esta sección, se describe un problema que podrías encontrar cuando configuras el balanceo de cargas ponderado.

Política de tráfico externo incorrecta para el balanceo de cargas ponderado

Si no configuras el valor de externalTrafficPolicy: Local cuando habilitas el balanceo de cargas ponderado, es posible que recibas un evento de advertencia cuando describas el servicio con el siguiente comando:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Para habilitar de manera efectiva el balanceo de cargas ponderado, debes establecer el valor de externalTrafficPolicy: Local.

¿Qué sigue?

• Para obtener una descripción general de estos objetos Service LoadBalancer, consulta objetos Service LoadBalancer.
• Para obtener una descripción de los parámetros de objetos Service LoadBalancer, consulta Parámetros de objetos Service LoadBalancer.
• Soluciona problemas de balanceo de cargas en GKE.