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, debes familiarizarte con los siguientes conceptos:

Balanceador de cargas de red de transferencia externo basado en servicios de backend

Como administrador del clúster, puedes crear un objeto Service LoadBalancer externo para que los clientes fuera del clúster puedan enviar paquetes a los Pods del Service. En el siguiente diagrama, se ilustran dos balanceadores de cargas de red de transferencia externos basados en servicios de backend basados en servicios de backend creados para dos objetos Service LoadBalancer externos (store-v1-lb-svc y store-v2-lb-svc). Ambos balanceadores de cargas distribuyen paquetes a los nodos del clúster, y los nodos enrutan paquetes a los pods de entrega.

Objetos Service LoadBalancer externos con la tecnología de balanceadores de cargas de red de transferencia externos basados en servicios de backend basados en servicios regionales

En esta guía, se muestra cómo configurar un objeto Service LoadBalancer externo llamado store-v1-lb-svc con los siguientes pasos:

Crea un clúster con el complemento HttpLoadBalancing habilitado.
Crea un Service que incluya la anotación cloud.google.com/l4-rbs. Esta anotación indica a GKE que cree un Balanceador de cargas de red de transferencia externo basado en servicios de backend que use el servicio de backend regional.
Verifica que el balanceador de cargas entregue paquetes de forma correcta a los Pods del Service store-v1-lb-svc. Verifica también que GKE haya creado los componentes del balanceador de cargas de red de transferencia externo basado en servicios de backend:
- Regla de reenvío
- Servicio de backend regional
- Grupo de instancias
- Verificación de estado
- Reglas de firewall de VPC
Borra el objeto Service LoadBalancer externo de store-v1-lb-svc.

Antes de comenzar

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

Habilita la API de Kubernetes Engine de Google.

Habilitar la API de Kubernetes Engine de Google

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.

Configura tu clúster

Crea un clúster

Usa la CLI de gcloud para crear un clúster nuevo que admita la creación de balanceadores de cargas de red de transferencia externos basadoa en servicios de backend:

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: la versión de GKE para el clúster, que debe ser 1.24.9 o posterior.
COMPUTE_LOCATION: la región de Compute Engine del clúster.

El clúster nuevo tiene el complemento HttpLoadBalancing habilitado de forma predeterminada. Este complemento es necesario para que el plano de control pueda crear y administrar los balanceadores de cargas de red de transferencia externos basados en servicios de backend.

Actualiza un clúster existente:

Usa la CLI de gcloud para actualizar un clúster existente a fin de que admita la creación de balanceadores de cargas de red de transferencia externos basadoa en servicios de backend.

Actualiza tu plano de control a la versión 1.24.9 o posterior de GKE:
```
gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre de tu clúster.
- VERSION: la versión de GKE, que debe ser 1.24.9 o posterior. La versión debe ser una versión secundaria válida en el canal de versiones de tu clúster. Para obtener más información, consulta Actualiza el plano de control de forma manual.
- COMPUTE_LOCATION: la ubicación de Compute Engine para el clúster nuevo.

Crea el objeto Service LoadBalancer externo

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 2
  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 dos Pods de entrega para el 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

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
  externalTrafficPolicy: Cluster
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080
```
Este objeto Service LoadBalancer externo usa el externalTrafficPolicy predeterminado de 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 el procesamiento de paquetes, consulta Conceptos del objeto Service LoadBalancer.

Si usas un clúster de pila doble de IPv4/IPv6, agrega spec.ipFamilyPolicy y ipFamilies para definir cómo GKE asigna direcciones IP al servicio. Ten en cuenta las siguientes condiciones cuando uses las especificaciones ipFamilyPolicy y ipFamilies:
- Cuando creas un balanceador de cargas de red de transferencia externo basado en servicios de backend, GKE agrega de forma automática la anotación cloud.google.com/l4-rbs a los servicios nuevos creados en los clústeres de pila doble IPv4/IPv6. Sin embargo, si agregas la anotación cloud.google.com/l4-rbs: "enabled" a los manifiestos de Services existentes, los objetos Services LoadBalancer que ya existen en el clúster continúan usando balanceadores de cargas de red de transferencia externos basados en grupos de destino, que solo son IPv4. Para obtener información adicional, consulta Agrupación de nodos.
- GKE puede asignar Services de LoadBalancer de pila única (solo IPv4 o solo IPv6) o de pila doble. Un objeto Service LoadBalancer de doble pila se implementa con dos reglas de reenvío del balanceador de cargas de red de transferencia externo separadas: una para manejar el tráfico de TCP mediante IPv4 y otra para controlar el tráfico de TCP a través de IPv6. Para obtener más información, consulta Services.
Aplica el manifiesto al clúster:
```
kubectl apply -f store-v1-lb-svc.yaml
```
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 externo y sus componentes

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

kubectl describe svc store-v1-lb-svc

El resultado es similar a este:

Name:                     store-v1-lb-svc
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          service.kubernetes.io/backend-service: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-c086604n-l4-shared-hc-fw
                          service.kubernetes.io/healthcheck: k8s2-c086604n-l4-shared-hc
                          service.kubernetes.io/tcp-forwarding-rule: a683373f85bfe433ba929a50ca8d72e2
Selector:                 app=store
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.44.196.160
IPs:                      10.44.196.160
LoadBalancer Ingress:     35.193.28.231
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  32466/TCP
Endpoints:                10.48.0.5:8080,10.48.2.8:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason                Age                   From                     Message
  ----    ------                ----                  ----                     -------
  Normal  ADD                   2m42s                 loadbalancer-controller  default/store-v1-lb-svc
  Normal  EnsuringLoadBalancer  102s (x2 over 2m42s)  service-controller       Ensuring load balancer
  Normal  Annotations           102s                  loadbalancer-controller  map[cloud.google.com/l4-rbs:enabled kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":"Service","metadata":{"annotations":
{"cloud.google.com/l4-rbs":"enabled"},"name":"store-v1-lb-svc","namespace":"default"}
,"spec":{"externalTrafficPolicy":"Cluster","ports":
[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort":8080}],
"selector":{"app":"store"},"type":"LoadBalancer"}}
] -> map[cloud.google.com/l4-rbs:enabled
kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":
"Service","metadata":{"annotations":{"cloud.google.com/l4-rbs":"enabled"},
"name":"store-v1-lb-svc","namespace":"default"},"spec":{"externalTrafficPolicy"
:"Cluster","ports":[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort"
:8080}],"selector":{"app":"store"},"type":"LoadBalancer"}}
service.kubernetes.io/backend-service:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule-for-hc:k8s2-c086604n-l4-shared-hc-fw
service.kubernetes.io/healthcheck:k8s2-c086604n-l4-shared-hc
service.kubernetes.io/tcp-forwarding-rule:a683373f85bfe433ba929a50ca8d72e2]
Normal  SyncLoadBalancerSuccessful  16s (x3 over 102s)  loadbalancer-controller  Successfully ensured L4 External LoadBalancer resources

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 de Google Cloud creado como parte del balanceador de cargas o para admitirlo.
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.

Verifique 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: 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: 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: 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 service.kubernetes.io/healthcheck de solo lectura. Para verificar esta anotación de solo lectura, ejecuta kubectl describe svc SERVICE_NAME.
- REGION_NAME: 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: 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 y sus componentes

Borra el objeto Service LoadBalancer externo de store-v1-lb-svc.

kubectl delete service store-v1-lb-svc

GKE borra los siguientes recursos:

La regla de reenvío del balanceador de cargas.
El servicio de backend del balanceador de cargas.
La verificación de estado del balanceador de cargas.
Las reglas de firewall de VPC necesarias para el balanceador de cargas y el tráfico de verificación de estado.
Los backends de grupos de instancias no administrados zonales, solo si GKE no necesita usarlos como backends para otros balanceadores de cargas creados por el clúster.

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