Creando un balanceador de carga

En este tema se explica cómo configurar un balanceador de carga elástico (ELB) de AWS con GKE en AWS.

Cuando creas un servicio de tipo LoadBalancer, un controlador de GKE en AWS configura un ELB clásico o de red en AWS.

También puedes seguir la guía de inicio rápido para crear un ELB clásico orientado al exterior desde la consola de Google Cloud o crear un balanceador de carga de aplicaciones (ALB) de AWS.

Antes de empezar

Antes de empezar a usar GKE en AWS, asegúrate de haber completado las siguientes tareas:

  • Instala un servicio de gestión.
  • Crea un clúster de usuarios.
  • En tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuarios. 
    cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
     Sustituye CLUSTER_NAME por el nombre de tu clúster de usuario.
  • Tener instalada la herramienta de línea de comandos curl u otra similar.

Seleccionar un balanceador de carga externo o interno

GKE on AWS crea un balanceador de carga externo (en tu subred pública) o interno (en tu subred privada) en función de una anotación del recurso LoadBalancer.

Si seleccionas un balanceador de carga externo, se podrá acceder a él mediante las direcciones IP permitidas en los grupos de seguridad del grupo de nodos y en las listas de control de acceso (ACLs) de la red de la subred.

Elegir un tipo de balanceador de carga

Elige si quieres crear un balanceador de carga clásico (Classic ELB) o un balanceador de carga de red (NLB). Para obtener más información sobre las diferencias entre los tipos de balanceadores de carga, consulta la sección Tipos de balanceadores de carga de la documentación de AWS.

Crear un LoadBalancer

Para crear un balanceador de carga, crea un despliegue y expónlo con un servicio.

  1. Crea tu implementación. Los contenedores de esta implementación escuchan en el puerto 50001. Guarda el siguiente archivo YAML con el nombre 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"

  2. Crea el despliegue con kubectl apply:

    env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f my-deployment-50001.yaml

  3. Verifica que se estén ejecutando tres pods:

    env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods --selector=app=products

  4. Crea un servicio de tipo LoadBalancer para tu implementación. Puede crear un ELB clásico o de red en su subred pública o privada. Elige una de estas opciones:

    • Un ELB clásico en la subred pública
    • Un balanceador de carga de red en la subred pública
    • Un ELB clásico en la subred privada
    • Un balanceador de carga de red en la subred privada

    A continuación, copia el siguiente manifiesto en un archivo llamado my-lb-service.yaml.

    Classic Public

    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 Public

    Para crear un balanceador de carga de red, define la anotación service.beta.kubernetes.io/aws-load-balancer-type en nlb. El siguiente archivo YAML 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

    Classic Private

    Para crear un balanceador de carga privado, define la anotación service.beta.kubernetes.io/aws-load-balancer-internal en "true". El siguiente archivo YAML 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 Private

    Para crear un balanceador de carga de red privado, define las anotaciones:

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

    El siguiente archivo YAML incluye 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

  5. Crea el servicio con kubectl apply:

    env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f my-lb-service.yaml

  6. Consulta el nombre de host del servicio con kubectl get service.

    env HTTPS_PROXY=http://localhost:8118 \
  kubectl get service my-lb-service \
  --output jsonpath="{.status.loadBalancer.ingress..hostname}{'\n'}"

    La salida se parece a elb-id.elb.aws-region.amazonaws.com.

  7. Si has creado un balanceador de carga orientado hacia el exterior y tienes acceso a la subred de VPC pública, puedes conectarte al balanceador de carga con curl. Sustituye external-ip por la IP del resultado de kubectl get service del paso anterior.

    curl external-ip:60000

    La salida es similar a la siguiente:

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

Eliminar los recursos utilizados

Para quitar el servicio y la implementación, usa kubectl delete.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f my-lb-service.yaml

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f my-deployment-50001.yaml

Solución de problemas

Si no puedes acceder a un endpoint de balanceador de carga, prueba a etiquetar tus subredes.

Siguientes pasos