Creación de un balanceador de carga

Este tema le muestra cómo configurar un AWS Elastic Load Balancer (ELB) con GKE en AWS.

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

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

Antes de empezar

Antes de comenzar a usar GKE en AWS, asegúrese de haber realizado las siguientes tareas:

  • Instalar un servicio de gestión .
  • Crear un clúster de usuarios .
  • Desde su directorio anthos-aws , use anthos-gke para cambiar el contexto a su clúster de usuarios.
    cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
     Reemplace CLUSTER_NAME con el nombre de su clúster de usuarios.
  • Tenga instalada la herramienta de línea de comandos curl o una herramienta similar.

Seleccionar un balanceador de carga externo o interno

GKE en AWS crea un balanceador de carga externo (en su subred pública) o interno (en su subred privada) según una anotación en el recurso LoadBalancer.

Si selecciona un balanceador de carga externo, será accesible a través de las direcciones IP permitidas en los grupos de seguridad del grupo de nodos y las listas de control de acceso a la red (ACL) de la subred.

Cómo elegir un tipo de balanceador de carga

Elija si desea crear un balanceador de carga clásico (ELB clásico) o un balanceador de carga de red (NLB). Para obtener más información sobre las diferencias entre los tipos de balanceadores de carga, consulte Tipos de balanceadores de carga en la documentación de AWS.

Creación de un balanceador de carga

Para crear un equilibrador de carga, cree una implementación y exponga esa implementación con un servicio.

  1. Crea tu implementación. Los contenedores de esta implementación 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"

  2. Cree la implementación con kubectl apply :

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

  3. Verifique que se estén ejecutando tres Pods:

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

  4. Cree un servicio de tipo LoadBalancer para su implementación. Puede crear un ELB clásico o de red en su subred pública o privada. Elija una de las siguientes opciones:

    • Un ELB clásico en la subred pública
    • Un NLB en la subred pública
    • Un ELB clásico en la subred privada
    • Un NLB en la subred privada

    Luego, copie el siguiente manifiesto a un archivo llamado my-lb-service.yaml .

    Público Clásico 

    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 Público

    Para crear un balanceador de carga de red (NLB), configure la anotación service.beta.kubernetes.io/aws-load-balancer-type aws-load-balancer-type` como nlb . El siguiente 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

    Clásico privado

    Para crear un LoadBalancer privado, configure la anotación service.beta.kubernetes.io/aws-load-balancer-internal como "true" . El siguiente 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

    Puedes crear un NLB privado configurando las anotaciones:

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

    El siguiente 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. Cree el servicio con kubectl apply :

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

  6. Vea 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 elb-id .elb. aws-region .amazonaws.com .

  7. Si ha creado un balanceador de carga externo y tiene acceso a la subred pública de la VPC, puede conectarse a él con curl . Reemplace external-ip con la IP del resultado de kubectl get service del paso anterior. 

    curl external-ip:60000

    La salida se parece a la siguiente: 

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

Limpiando

Para eliminar el servicio y la implementación, use 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 puede acceder a un punto final del balanceador de carga, intente etiquetar sus subredes .

¿Qué sigue?