Se usó la API de Cloud Translation para traducir esta página.

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:

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.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Requisitos

Para crear un Service LoadBalancer externo, tu clúster de GKE debe usar la versión 1.25.5 o una posterior. Para usar el balanceo de cargas ponderado, tu clúster debe usar la versión 1.31.0-gke.1506000 o una posterior.
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.

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.

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.

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 el 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.

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.

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

Aplica el manifiesto al clúster:
```
kubectl apply -f store-deployment.yaml
```

Verifica que haya 20 Pods de entrega para la Deployment:

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

Para exponer la carga de trabajo de ejemplo, crea un servicio LoadBalancer externo.

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

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.
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.

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

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

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.

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-

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
                          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 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.
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 región de Google Cloud 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 región de Google Cloud 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 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 región de Google Cloud 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.

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.

Soluciona problemas del servicio LoadBalancer externo

Si no configuras externalTrafficPolicy: Local, 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.