Crea un balanceador de cargas de aplicaciones (ALB)

En este tema, se muestra cómo configurar un balanceador de cargas de aplicaciones (ALB) de AWS con GKE en AWS.

Antes de comenzar

Antes de comenzar a usar GKE on AWS, completa las siguientes tareas:

  • Tener permisos a fin de crear políticas de IAM, funciones y usuarios de AWS para el balanceador de cargas
  • Instalar un servicio de administración
  • Crear un clúster de usuario Si usas Workload Identity, crea un clúster de usuario con Workload Identity.
  • Desde tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuario.
    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Reemplaza CLUSTER_NAME por el nombre de tu clúster de usuario.
  • Instalar la herramienta de línea de comandos de curl o una herramienta similar.

Etiqueta subredes

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

Si instalaste clústeres de GKE en AWS en una VPC existente o deseas usar subredes adicionales, aplica etiquetas a las subredes en dos o más zonas de disponibilidad de AWS.

Configura el ALB en GKE en AWS

Antes de crear un ALB, configura clústeres de GKE en AWS configurando permisos de IAM de AWS y proporcionando claves de acceso.

Crea permisos de IAM de AWS

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

  1. Descarga una política de IAM para el controlador de Ingress de ALB. Puedes revisar 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 de 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 IAM. Guarda el ARN para usarlo más tarde.

Otorga acceso al balanceador de cargas

En esta sección, asociarás la política de usuarios con un usuario de 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 a fin de crear un usuario de IAM para el controlador de Ingress del ALB.

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

    Reemplaza ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.

  2. Adjunta ALBIngressControllerIAMPolicy al nombre de usuario.

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

    Reemplaza lo siguiente:

    • ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.
    • ALB_IAM_POLICY_ARN por el ARN de la política de IAM que creaste antes.
  3. Crea una clave de acceso de IAM de AWS para el usuario del controlador de Ingress del ALB.

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

    Reemplaza ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.

    La herramienta de línea de comandos de aws imprime 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"
      }
    }
    
  4. Guarda la clave de acceso y la clave de acceso secreta en variables de entorno. Las usarás para configurar tu clúster de usuario.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    
  5. Crea un secreto en su clúster con la clave de acceso y la clave de acceso secreta. El controlador de Ingress del ALB usa este secreto para autenticarse en AWS y administrar los 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 de Crea un clúster de usuario con identidad con Workload Identity. Cuando crees una política, usa el ARN de ALBIngressControllerIAMPolicy para el valor de EXISTING_AWS_POLICY.

Configura tu clúster

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

  1. Para implementar el administrador de certificados de Jetstack, instala 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 del balanceador de cargas 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 rol de usuario de IAM con identidad de carga de trabajo.

    Usuario de IAM

    Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Reemplaza el objeto de 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.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
        ---
    

    Reemplaza lo siguiente:

    • AWS_ACCESS_KEY_ID: La clave de acceso de AWS que se generó cuando creaste un usuario de IAM de AWS
    • AWS_SECRET_ACCESS_KEY: La clave de acceso secreta de AWS generada cuando creaste un usuario de IAM de AWS

    Rol con Workload Identity

    Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Reemplaza todo el objeto Deployment con 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
    ---
    

    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
    • 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 al clúster.

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

    GKE en AWS instala el controlador de Ingress del ALB.

Crea un ALB

En esta sección, crearás un ALB que entregará 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 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 al clúster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f 2048.yaml
    
  3. Usa kubectl para verificar el estado del recurso Ingress.

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

    Aparecerá el estado del Ingress. La columna ADDRESS contiene el extremo del Ingress.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Navega hasta la extremo del ALB en un navegador. Por ejemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Aparecerá el juego 2048.

¿Qué sigue?