Configura un balanceador de cargas de HTTP

En esta página, se muestra cómo configurar un balanceador de cargas de aplicaciones (ALB) de AWS.

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

Antes de comenzar

Antes de que GKE en AWS pueda crear un ALB, debes hacer lo siguiente:

Descripción general

La creación del primer ALB en un clúster implica los siguientes pasos:

  • Identificar y etiquetar o anotar las subredes dentro de tu VPC en la que deseas aprovisionar los ELB.
  • Crear una función de AWS que otorgue al controlador de ALB acceso a los recursos de AWS.
  • Instalar el código abierto aws-load-balancer-controller.
  • Crear e implementar una configuración de ALB

Para crear los ALB posteriores, solo necesitas crear e implementar otra configuración de ALB.

Crea un balanceador de cargas de aplicaciones

Etiqueta las subredes para tu ALB

Antes de crear un ALB, debes indicarle a AWS en qué subredes se debe ejecutar. El método habitual es etiquetar la subred con una etiqueta que la identifique como disponible para el proceso de descubrimiento automático. Como alternativa, puedes agregar una anotación al objeto Ingress a fin de enumerar de forma explícita las subredes en las que se ejecutará.

A fin de etiquetar las subredes seleccionadas como disponibles para la detección automática, consulta Etiqueta las subredes del balanceador de cargas de servicio.

Para anotar el objeto Ingress con una lista de subredes, agrega una anotación llamada alb.ingress.kubernetes.io/subnets al objeto Ingress de Kubernetes. Configura el valor de la anotación en una lista separada por comas de ID de subredes o nombres de subredes, por ejemplo, subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crea permisos de AWS IAM

Descarga la política de IAM para el controlador del balanceador de cargas de AWS. Esta política enumera los permisos que el controlador del balanceador de cargas necesita para funcionar. Puedes revisar la política en GitHub. Este comando guarda la política en un archivo llamado iam_policy.json.

  curl -Lo iam_policy.json \
    https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.4/docs/install/iam_policy.json
  1. Usa este archivo para crear una política de IAM llamada AWSLoadBalancerControllerIAMPolicy:

    aws iam create-policy \
      --policy-name AWSLoadBalancerControllerIAMPolicy \
      --policy-document file://iam_policy.json
    

Otorga acceso al balanceador de cargas

Crea una función de IAM de AWS para la cuenta de servicio del controlador si sigues las instrucciones en Crea una función de IAM de AWS. En estas instrucciones, reemplaza lo siguiente:

  • AWS_POLICY_ARN: El ARN de AWSLoadBalancerControllerIAPolicy creado en el paso anterior
  • KSA_NAME: "aws-load-balancer-controller"
  • K8S_NAMESPACE: "kube-system"
  • AWS_ROLE_NAME: "AWSLBControllerRole"

Para recuperar el ARN de la política, ejecuta este comando:

aws iam list-policies \
  --query 'Policies[?PolicyName==`AWSLoadBalancerControllerIAMPolicy`].Arn' \
  --output text

Instala el controlador del balanceador de cargas de AWS

  1. Para completar estos pasos, extrae y guarda los siguientes valores. Los necesitarás más tarde.

    Encuentra el UID de tu clúster con la ejecución del siguiente comando:

      gcloud container aws clusters describe CLUSTER_NAME \
        --location GOOGLE_CLOUD_LOCATION \
        --format "value(uid)"
    

    Encuentra el ID de VPC de tu clúster con la ejecución del siguiente comando:

      gcloud container aws clusters describe CLUSTER_NAME \
        --location GOOGLE_CLOUD_LOCATION \
        --format "value(networking.vpcId)"
    

    Encuentra el ARN del rol llamado AWSLBControllerRole con la ejecución del siguiente comando:

    aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
    

    Encuentra la región de AWS de tu clúster con la ejecución del siguiente comando:

    gcloud container aws clusters describe CLUSTER_NAME \
      --location GOOGLE_CLOUD_LOCATION \
      --format "value(awsRegion)"
    

    Reemplaza lo siguiente:

    • GOOGLE_CLOUD_LOCATION por el nombre de la región de Google asociada con el clúster
    • CLUSTER_NAME por el nombre del clúster
  2. Instala cert-manager con el siguiente comando:

    kubectl apply \
      --validate=false \
      -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.yaml
    
  3. Descarga el manifiesto para aws-load-balancer-controller y guárdalo en el archivo local v2_4_4_full.yaml con el siguiente comando:

    curl -Lo v2_4_4_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.4/v2_4_4_full.yaml
    
  4. Edita el archivo v2_4_4_full.yaml y busca kind: Deployment. Reemplaza el objeto Deployment con esta versión modificada:

    kind: Deployment
    metadata:
      labels:
        app.kubernetes.io/component: controller
        app.kubernetes.io/name: aws-load-balancer-controller
      name: aws-load-balancer-controller
      namespace: kube-system
    spec:
      replicas: 1
      selector:
        matchLabels:
          app.kubernetes.io/component: controller
          app.kubernetes.io/name: aws-load-balancer-controller
      template:
        metadata:
          labels:
            app.kubernetes.io/component: controller
            app.kubernetes.io/name: aws-load-balancer-controller
        spec:
          containers:
          - args:
            - --cluster-name=CLUSTER_UID
            - --aws-region=AWS_REGION
            - --aws-vpc-id=AWS_VPC_ID
            - --ingress-class=alb
            - --disable-restricted-sg-rules=true
            image: amazon/aws-alb-ingress-controller:v2.4.4
            env:
            - name: AWS_ROLE_ARN
              value: AWS_ROLE_ARN
            - name: AWS_WEB_IDENTITY_TOKEN_FILE
              value: /var/run/secrets/aws-load-balancer-controller/serviceaccount/token
            livenessProbe:
              failureThreshold: 2
              httpGet:
                path: /healthz
                port: 61779
                scheme: HTTP
              initialDelaySeconds: 30
              timeoutSeconds: 10
            name: controller
            ports:
            - containerPort: 9443
              name: webhook-server
              protocol: TCP
            resources:
              limits:
                cpu: 200m
                memory: 500Mi
              requests:
                cpu: 100m
                memory: 200Mi
            securityContext:
              allowPrivilegeEscalation: false
              readOnlyRootFilesystem: true
              runAsNonRoot: true
            volumeMounts:
            - mountPath: /tmp/k8s-webhook-server/serving-certs
              name: cert
              readOnly: true
            - mountPath: /var/run/secrets/aws-load-balancer-controller/serviceaccount
              name: aws-iam-token
              readOnly: true
          priorityClassName: system-cluster-critical
          securityContext:
            fsGroup: 1337
          serviceAccountName: aws-load-balancer-controller
          terminationGracePeriodSeconds: 10
          volumes:
          - name: cert
            secret:
              defaultMode: 420
              secretName: aws-load-balancer-webhook-tls
          - name: aws-iam-token
            projected:
              defaultMode: 420
              sources:
              - serviceAccountToken:
                  audience: sts.amazonaws.com
                  expirationSeconds: 86400
                  path: token
    ---
    

    Reemplaza lo siguiente:

    • CLUSTER_UID: El UID del clúster, por ejemplo, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
    • AWS_VPC_ID: El ID de la VPC de AWS, por ejemplo, vpc-1234567890abc
    • AWS_ROLE_ARN: El ARN del rol llamado AWSLBControllerRole
    • AWS_REGION: La región de AWS de tu clúster, por ejemplo, us-east-1
  5. Aplica el manifiesto modificado a tu clúster con el siguiente comando:

    kubectl apply -f v2_4_4_full.yaml
    
  6. Confirma que el controlador del balanceador de cargas se ejecuta con el siguiente comando:

    kubectl get deployment -n kube-system aws-load-balancer-controller
    

    El resultado debería ser similar al siguiente, que muestra que la implementación aws-load-balancer-controller está disponible.

    NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
    aws-load-balancer-controller   1/1     1            1           51s
    

Crea un ALB de ejemplo

En esta sección, se muestra cómo crear un ALB de ejemplo que entregue una versión nueva del juego 2048.

  1. Copia la siguiente configuración de YAML en un archivo llamado 2048.yaml. La configuración crea un objeto Namespace, Service y Deployment de Kubernetes. La implementación se expone a través de un ALB de Ingress.

    apiVersion: v1
    kind: Namespace
    metadata:
      name: game-2048
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      namespace: game-2048
      name: deployment-2048
    spec:
      selector:
        matchLabels:
          app.kubernetes.io/name: app-2048
      replicas: 5
      template:
        metadata:
          labels:
            app.kubernetes.io/name: app-2048
        spec:
          containers:
          - image: alexwhen/docker-2048
            imagePullPolicy: Always
            name: app-2048
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      namespace: game-2048
      name: service-2048
    spec:
      ports:
        - port: 80
          targetPort: 80
          protocol: TCP
      type: NodePort
      selector:
        app.kubernetes.io/name: app-2048
    ---
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      namespace: game-2048
      name: ingress-2048
      annotations:
        alb.ingress.kubernetes.io/scheme: internet-facing
    spec:
      ingressClassName: alb
      rules:
        - http:
            paths:
              - path: /
                pathType: Prefix
                backend:
                  service:
                    name: service-2048
                    port:
                      number: 80
    
  2. Aplica la configuración a tu clúster con el siguiente comando:

    kubectl apply -f 2048.yaml
    
  3. Verifica el estado del recurso Ingress con el siguiente comando:

    kubectl get ingress -n game-2048 ingress-2048
    

    El resultado del comando es similar al siguiente. La columna ADDRESS contiene el extremo del recurso de Ingress.

     NAME           CLASS    HOSTS   ADDRESS                                                                   PORTS   AGE
     ingress-2048   <none>   *       k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com   80      2m19s
     ```
    
  4. Navega al extremo del ALB en un navegador, por ejemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Se muestra el juego 2048 que demuestra que implementaste y configuraste el balanceador de cargas ALB de forma correcta.

Realice una limpieza

Para quitar el ALB y la implementación de muestra que se crearon en el paso anterior, borra el manifiesto con el siguiente comando:

kubectl delete -f 2048.yaml

¿Qué sigue?