Crea un balanceador de cargas externo basado en servicios de backend

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 servicios de 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 gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.

Requisitos

• El complemento HttpLoadBalancing debe estar habilitado en tu clúster. Este complemento está habilitado de forma predeterminada. Permite que el clúster administre los balanceadores de cargas que usan servicios de backend.

• Para crear un Service LoadBalancer externo que use un balanceador de cargas de red de transferencia externo basado en servicios de backend, tu clúster de GKE debe usar la versión 1.25.5 o una posterior.

• Para crear un Service LoadBalancer externo que use el balanceo de cargas ponderado, tu clúster de GKE debe usar la versión 1.31.0-gke.1506000 o una posterior.

• Para crear un Service LoadBalancer externo que use backends de grupo de extremos de red (NEG) GCE_VM_IP, tu clúster de GKE debe usar la versión 1.32.2-gke.1652000 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, haz lo siguiente:

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 que se usa 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 que se usa 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 la CLI de gcloud 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 publicación 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: gcr.io/google_containers/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 la implementación:

   kubectl get pods
   

   El resultado es similar a este:

   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. Para exponer la carga de trabajo de ejemplo, crea 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
        annotations:
          cloud.google.com/l4-rbs: "enabled"
      spec:
        type: LoadBalancer
        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 ejemplo:

   • El manifiesto de servicio debe incluir la anotación cloud.google.com/l4-rbs: "enabled" cuando se aplica por primera vez al clúster. Esto le 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 de 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.

   • Si agregas la anotación cloud.google.com/l4-rbs: "enabled" al manifiesto de un servicio LoadBalancer externo existente (es decir, después de crear el balanceador de cargas), GKE ignora la anotación. Los servicios LoadBalancer externos creados sin esta anotación en sus manifiestos usan balanceadores de cargas de red de transferencia externos basados en grupos de destino. No se recomienda usar balanceadores de cargas de red de transferencia externos basados en grupos de destino.

Habilita el balanceo de cargas ponderado

Para distribuir 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 de Service.

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

   apiVersion: v1
   kind: Service
   metadata:
     name: store-v1-lb-svc
     annotations:
       cloud.google.com/l4-rbs: "enabled"
       networking.gke.io/weighted-load-balancing: "pods-per-node"
   spec:
     type: LoadBalancer
     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 impide 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 servicio de 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 servicio 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 servicio LoadBalancer externo existente debe haber incluido la anotación cloud.google.com/l4-rbs: "enabled" 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 servicio de LoadBalancer externo existente que usa un balanceador de cargas de red de transferencia externo basado en grupos de destino no tiene efecto.

• Cuando actualices el manifiesto existente del Service LoadBalancer externo, asegúrate de configurar 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 conexiones nuevas a los nodos, independientemente de la cantidad de Pods de publicación 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 de servicio.

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.

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 este:

   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 este:

   Name:                     my-service-external
   Namespace:                default
   Labels:                   <none>
   Annotations:              cloud.google.com/l4-rbs: enabled
                             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 Google Cloud recursos 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 recursoGoogle 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 Services LoadBalancer, consulta las Reglas de firewall y la lista de direcciones IP de origen permitidas.
     • 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 los NEG que usa el balanceador de cargas y 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.
       • La anotación cloud.google.com/l4-rbs: "enabled" 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. En el caso de 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 mediante 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 mediante 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: 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 mediante 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 mediante 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 usa el balanceador de cargas. En el caso de los clústeres zonales, esta anotación contiene información sobre un NEG. En el caso de 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: Es la Google Cloud zona que contiene el NEG.

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 servicios de LoadBalancer externos 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 grupo de extremos de red GCE_VM_IP o de grupo de instancias, según la versión de GKE del clúster:

• Si el manifiesto de servicio se aplicó a un clúster que ejecuta GKE versión 1.32.2-gke.1652000 o posterior, 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 de 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 servicio LoadBalancer externo con la tecnología de un balanceador de cargas de red de transferencia externo basado en servicios de backend que use backends de NEG GCE_VM_IP si tu servicio 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

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 de GKE o una posterior.

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 de LoadBalancer externo existente.

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

   En el resultado del comando, anota la dirección IPv4 externa que usa el balanceador de cargas existente en la columna EXTERNAL-IP.

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

   • Es mejor que tengas el manifiesto de Service original que aplicaste al clúster en el pasado. Por ejemplo, puedes tener esto en un repositorio de control de código fuente.

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

     • Ejecuta el siguiente comando para obtener una copia en 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 YAML del manifiesto 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 la anotación cloud.google.com/l4-rbs: "enabled". Si migras desde un balanceador de cargas de red de transferencia externo basado en grupos de destino, debes agregar la anotación.

   Anota la ruta de acceso local que contiene el archivo de manifiesto del servicio. En el resto de este procedimiento, se hace referencia a la ruta de acceso como MANIFEST_FILE_PATH.

4. Configura un recurso de dirección IPv4 externa estática para contener 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: 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. Libera el recurso de dirección IPv4 estática (opcional).

   gcloud compute addresses delete IP_ADDRESS_NAME --region=CLUSTER_REGION
   

Solucionar problemas

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

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

Si no configuras 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 eficaz el balanceo de cargas ponderado, debes configurar 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.