Crear un balanceador de carga de aplicaciones (ALB)

En este tema se explica cómo configurar un Application Load Balancer (ALB) de AWS con GKE en AWS.

Antes de empezar

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

• Completa los requisitos previos.

• Tener permisos para crear políticas, roles y usuarios de gestión de identidades y accesos de AWS para el balanceador de carga.
• Instala un servicio de gestión.
• Crea un clúster de usuarios. Si usas Workload Identity, crea un clúster de usuarios con Workload Identity.
• 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.
• Instala la herramienta de línea de comandos curl u otra similar.

Etiquetar subredes

GKE on AWS requiere etiquetas en las subredes que contienen endpoints de ALB. GKE en AWS etiqueta automáticamente todas las subredes especificadas en el campo spec.Networking.ServiceLoadBalancerSubnetIDs del recurso AWSCluster.

Si has instalado GKE en AWS en una VPC o quieres usar subredes adicionales, aplica etiquetas a las subredes de dos o más zonas de disponibilidad de AWS.

Configurar ALB en GKE en AWS

Antes de crear un ALB, debes configurar GKE en AWS. Para ello, configura los permisos de IAM de AWS y proporciona las claves de acceso.

Crear permisos de gestión de identidades y accesos de AWS

Para crear un ALB para tu clúster de usuarios, debes configurar un usuario de AWS IAM con permisos para crear y operar el ALB.

1. Descarga una política de gestión de identidades y accesos para el controlador de entrada ALB. Puedes consultar la política en GitHub.

   curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.0/docs/install/iam_policy.json
   

2. Usa la herramienta de línea de comandos aws para crear una política de IAM llamada ALBIngressControllerIAMPolicy.

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

   La respuesta incluye el nombre de recurso de Amazon (ARN) de la política de gestión de identidades y accesos. Guarda el ARN para usarlo más adelante.

Conceder acceso al balanceador de carga

En esta sección, asociará la política de usuario con un usuario de gestión de identidades y accesos (IAM) de AWS o con un rol de IAM que tenga una identidad de carga de trabajo configurada.

Usuario de IAM

1. Usa la herramienta aws para crear un usuario de gestión de identidades y accesos para el controlador de Ingress de ALB.

   aws iam create-user \
   --user-name ALB_CONTROLLER_USER_NAME
   

   Sustituye ALB_CONTROLLER_USER_NAME por el nombre de usuario que quieras crear para tu controlador Ingress de ALB.

2. Adjunta el ALBIngressControllerIAMPolicy al nombre de usuario.

   aws iam attach-user-policy \
    --user-name ALB_CONTROLLER_USER_NAME \
    --policy-arn ALB_IAM_POLICY_ARN
   

   Haz los cambios siguientes:

   • ALB_CONTROLLER_USER_NAME con el nombre de usuario que quieras crear para tu controlador de entradas ALB.
   • ALB_IAM_POLICY_ARN con el ARN de la política de gestión de identidades y accesos que has creado anteriormente.

3. Crea una clave de acceso de gestión de identidades y accesos de AWS para el usuario del controlador de entrada de ALB.

   aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
   

   Sustituye ALB_CONTROLLER_USER_NAME por el nombre de usuario que quieras crear para tu controlador Ingress de ALB.

   La herramienta de línea de comandos aws muestra los detalles de la clave de acceso.

   {
     "AccessKey": {
       "UserName": ALB_CONTROLLER_USER_NAME
       "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
       "Status": "Active",
       "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
       "CreateDate": "2020-07-23T17:53:58Z"
     }
   }
   

   Precaución: No podrás recuperar la clave secreta después de este punto. Guarda la clave para usarla más tarde.

4. Guarda la clave de acceso y la clave de acceso secreta en variables de entorno. Los usarás para configurar tu clúster de usuarios.

   ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
   ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
   

   Nota: También necesitas la clave de acceso y la clave secreta en la siguiente sección.

5. Crea un secreto en tu clúster con la clave de acceso y la clave de acceso secreta. El controlador de entrada ALB usa este secreto para autenticarse en AWS y gestionar los ALB.

   Importante: Asegúrate de que el contexto esté definido en el clúster de usuarios en el que quieras habilitar ALB.

   env HTTPS_PROXY=http://localhost:8118 \
     kubectl create secret generic alb-ingress-controller-creds \
     -n kube-system \
     --from-literal=access_key_id=$ALB_ACCESS_KEY_ID \
     --from-literal=secret_access_key=$ALB_SECRET_ACCESS_KEY
   

Rol con Workload Identity

Completa los pasos que se indican en el artículo Crear un clúster de usuarios con Workload Identity. Cuando cree una política, utilice el ARN de ALBIngressControllerIAMPolicy como valor de EXISTING_AWS_POLICY.

Configura el clúster

Para configurar un ALB, debes instalar los siguientes componentes en tu clúster de usuario:

• El cert-manager de Jetstack para generar y gestionar certificados TLS para los recursos ALB de tu clúster.
• El controlador de balanceador de carga de AWS para aprovisionar y gestionar ALBs.

1. Despliega Jetstack cert-manager instalando el manifiesto desde GitHub.

   env HTTPS_PROXY=http://localhost:8118 \
     kubectl apply \
     --validate=false \
     -f https://github.com/jetstack/cert-manager/releases/download/v1.5.4/cert-manager.yaml
   

2. Descarga el manifiesto del controlador de balanceador de carga de AWS desde GitHub:

   curl -Lo v2_4_0_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.0/v2_4_0_full.yaml
   

3. Selecciona si usas un usuario o un rol de gestión de identidades y accesos con Workload Identity.

   Usuario de IAM

   Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Sustituye el objeto Deployment por 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.0
           env:
           - name: AWS_ACCESS_KEY_ID
             valueFrom:
               secretKeyRef:
                 name: alb-ingress-controller-creds
                 key: access_key_id
           - name: AWS_SECRET_ACCESS_KEY
             valueFrom:
               secretKeyRef:
                 name: alb-ingress-controller-creds
                 key: secret_access_key
           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
         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
       ---
   

   Haz los cambios siguientes:

   • AWS_ACCESS_KEY_ID: la clave de acceso de AWS generada cuando creaste un usuario de gestión de identidades y accesos de AWS
   • AWS_SECRET_ACCESS_KEY: la clave de acceso secreta de AWS generada al crear un usuario de gestión de identidades y accesos de AWS

   Rol con Workload Identity

   Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Sustituye todo el objeto Deployment por esta versión modificada:

   apiVersion: apps/v1
   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.0
           env:
           - name: AWS_ROLE_ARN
             value: LB_CONTROLLER_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
   ---
   

   Haz los cambios siguientes:

   • CLUSTER_UID: el UID de tu clúster. Por ejemplo: bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
   • AWS_VPC_ID: el ID de tu VPC de AWS. Por ejemplo, vpc-1234567890abc.
   • LB_CONTROLLER_ROLE_ARN: el ARN del rol AWSLBControllerRole
   • AWS_REGION: la región de AWS de tu clúster. Por ejemplo, us-east-1.

4. Aplica el controlador a tu clúster.

   env HTTPS_PROXY=http://localhost:8118 \
     kubectl apply -f v2_4_0_full.yaml
   

   GKE on AWS instala el controlador de entradas ALB.

Crear un ALB

En esta sección, crearás un ALB de ejemplo que sirva una versión renovada del juego 2048.

1. Copia la siguiente configuración YAML en un archivo llamado 2048.yaml. La configuración crea un espacio de nombres, un servicio y un despliegue de Kubernetes. El despliegue se expone mediante un Ingress.

   apiVersion: v1
   kind: Namespace
   metadata:
     name: "2048-game"
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: "service-2048"
     namespace: "2048-game"
   spec:
     ports:
       - port: 80
         targetPort: 80
         protocol: TCP
     type: NodePort
     selector:
       app: "2048"
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: "2048-deployment"
     namespace: "2048-game"
   spec:
     selector:
       matchLabels:
         app: "2048"
     replicas: 5
     template:
       metadata:
         labels:
           app: "2048"
       spec:
         containers:
         - image: alexwhen/docker-2048
           imagePullPolicy: Always
           name: "2048"
           ports:
           - containerPort: 80
   ---
   apiVersion: extensions/v1beta1
   kind: Ingress
   metadata:
     name: "2048-ingress"
     namespace: "2048-game"
     annotations:
       kubernetes.io/ingress.class: alb
       alb.ingress.kubernetes.io/scheme: internet-facing
     labels:
       app: 2048-ingress
   spec:
     rules:
       - http:
           paths:
             - path: /*
               backend:
                 serviceName: "service-2048"
                 servicePort: 80
   

2. Usa kubectl para aplicar la configuración a tu clúster.

   env HTTPS_PROXY=http://localhost:8118 \
     kubectl apply -f 2048.yaml
   

3. Usa kubectl para comprobar el estado del recurso Ingress.

   env HTTPS_PROXY=http://localhost:8118 \
     kubectl get ingress -n 2048-game 2048-ingress
   

   Aparecerá el estado de tu Ingress. La columna ADDRESS contiene el endpoint de tu Ingress.

   NAME           HOSTS   ADDRESS                                                             PORTS   AGE
   2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
   

4. Desplázate hasta el endpoint de ALB en un navegador. Por ejemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Aparece el juego 2048.

Siguientes pasos

• Consulta la documentación del controlador de entrada de ALB.