Esta documentación es para la versión actual de GKE on AWS, lanzada en noviembre de 2021. Consulta las notas de la versión para obtener más información.

Crea un balanceador de cargas de red

En esta página, se describe cómo configurar un balanceador de cargas L4 con un extremo de Elastic Load Balancer (ELB) de AWS o un extremo de balanceador de cargas de red (NLB).

Para obtener más información sobre los otros tipos de balanceadores de cargas que puedes usar con GKE on AWS, consulta Descripción general del balanceador de cargas.

Antes de comenzar

Crea un clúster y configura kubectl para conectarte a él.
Etiqueta las subredes del balanceador de cargas de servicio. Esto es necesario para la detección automática de subredes.
Decide si necesitas un ELB de tipo clásico o de red.
Decide si necesitas un balanceador de cargas interno o uno orientado a Internet.

Elige un tipo de balanceador de cargas

GKE on AWS crea un balanceador de cargas de Service como un AWS Classic Elastic Load Balancer (Classic ELB) o NLB. De forma predeterminada, GKE en AWS crea un ELB clásico. Para crear un NLB, configura la anotación service.beta.kubernetes.io/aws-load-balancer-type como nlb. Para obtener más información sobre las diferencias entre los tipos de balanceadores de cargas, consulta Tipos de balanceadores de cargas en la documentación de AWS.

Elige un balanceador de cargas interno o uno orientado a Internet

Los balanceadores de cargas de servicio pueden ser orientados a Internet (con un nombre de DNS que se puede resolver de forma pública) o internos (solo accesibles dentro de tu VPC).

De forma predeterminada, los balanceadores de cargas nuevos están orientados a Internet. Para crear un balanceador de cargas interno, establece la anotación service.beta.kubernetes.io/aws-load-balancer-internal en "true" en tu manifiesto.

Nota: No puedes aplicar la anotación aws-load-balancer-internal a un Service existente. Para cambiar entre la configuración interna y orientada a Internet, debes borrar y volver a crear el balanceador de cargas existente.

Elige tus subredes

Cuando se crean balanceadores de cargas, AWS necesita saber en qué subredes colocarlos. De forma predeterminada, estas subredes se detectan automáticamente entre las subredes de la VPC. Esto requiere que las subredes tengan etiquetas específicas. Para obtener detalles sobre el descubrimiento automático y el etiquetado de subredes, consulta Subredes del balanceador de cargas.

Como alternativa, puedes especificar subredes del balanceador de cargas con una anotación si agregas la anotación service.beta.kubernetes.io/aws-load-balancer-subnets al servicio. El valor de esta anotación es una lista separada por comas de ID de subredes o nombres de subredes, por ejemplo, subnet-012345678abcdef,subnet-abcdef123456789,subnet-123456789abcdef.

Crea un balanceador de cargas de ejemplo

Para crear un servicio de tipo LoadBalancer, crea una implementación y expón esa implementación con un servicio. En el siguiente ejemplo, se crea un balanceador de cargas de muestra.

Crea la implementación. Los contenedores de este objeto Deployment escuchan en el puerto 50001. Guarda el siguiente YAML en un archivo llamado my-deployment-50001.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment-50001
spec:
  selector:
    matchLabels:
      app: products
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: products
        department: sales
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50001"

Crea el Deployment con kubectl apply:

kubectl apply -f my-deployment-50001.yaml

Verifica que los tres Pods estén en ejecución:
```
kubectl get pods --selector=app=products
```
Crea un Service de tipo LoadBalancer para la implementación.

Decide qué tipo de balanceador de cargas necesitas:

Un ELB clásico orientado a Internet
Un NLB orientado a Internet
Un ELB clásico interno
Un NLB interno

Elige la pestaña que coincida con tus requisitos y copia el manifiesto que contiene en un archivo llamado my-lb-service.yaml.

Orientado a Internet versión clásica

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

NLB orientado a Internet

Para crear un NLB, configura la anotación service.beta.kubernetes.io/aws-load-balancer-type como nlb. En el siguiente YAML, se incluye esta anotación.

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

Interno clásico

Crea un LoadBalancer interno configurando la anotación service.beta.kubernetes.io/aws-load-balancer-internal como "true". En el siguiente YAML, se incluye esta anotación.

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-internal: "true"
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

NLB interno

Para crear un NLB interno, configura las anotaciones de la siguiente manera:

De service.beta.kubernetes.io/aws-load-balancer-internal a "true"
Configura service.beta.kubernetes.io/aws-load-balancer-type como nlb.

En el siguiente YAML, se incluyen ambas anotaciones.

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-internal: "true"
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

Crea el Service con kubectl apply:
```
kubectl apply -f my-lb-service.yaml
```
Nota: La configuración del balanceador de cargas y la dirección IP puede llevar varios minutos.
Visualiza la dirección de host del Service con kubectl get service.
```
kubectl get service my-lb-service
```
El resultado incluirá una columna EXTERNAL-IP con una dirección del balanceador de cargas (público o privado según cómo se creó el balanceador de cargas).
Si creaste un balanceador de cargas orientado a Internet, puedes conectarte a él con curl mediante el siguiente comando:
```
curl http://EXTERNAL_IP:60000
```
Reemplaza EXTERNAL_IP por la dirección de la columna EXTERNAL-IP del paso anterior.

El resultado se parece al siguiente:

```none
Hello, world!
Version: 2.0.0
Hostname: my-deployment-50001-84b6dc5555-zmk7q
```

Realice una limpieza

Para quitar el Service y la implementación, usa el comando kubectl delete:

kubectl delete -f my-lb-service.yaml
kubectl delete -f my-deployment-50001.yaml

Próximos pasos

Configura un balanceador de cargas HTTP.
Obtén más información sobre GKE en la documentación de Google Cloud sobre la exposición de aplicaciones mediante servicios.
Consulta la lista completa de anotaciones admitidas.