Creación de un balanceador de carga de aplicaciones (ALB)

Este tema le muestra cómo configurar un balanceador de carga de aplicaciones (ALB) de AWS con GKE en AWS.

Antes de empezar

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

  • Tener permisos para crear políticas, roles y usuarios de AWS IAM para el balanceador de carga.
  • Instalar un servicio de gestión .
  • Cree un clúster de usuarios . Si utiliza la identidad de carga de trabajo, cree un clúster de usuarios con la identidad de carga de trabajo .
  • 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.
  • Instale la herramienta de línea de comandos curl o una herramienta similar.

Etiquetado de subredes

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

Si instaló GKE en AWS en una VPC existente o desea utilizar subredes adicionales, aplique etiquetas a las subredes en dos o más zonas de disponibilidad de AWS.

Configurar ALB en GKE en AWS

Antes de poder crear un ALB, debe configurar GKE en AWS configurando los permisos de AWS IAM y proporcionando claves de acceso.

Crear permisos de AWS IAM

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

  1. Descarga una política de IAM para el controlador de entrada ALB. Puedes consultarla 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. Utilice 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 IAM. Guarde el ARN para su uso posterior.

Otorgar acceso a su balanceador de carga

En esta sección, asocia la política de usuario con un usuario de AWS IAM o con un rol de IAM que tenga una identidad de carga de trabajo configurada.

Usuario de IAM

  1. Utilice la herramienta aws para crear un usuario IAM para el controlador de ingreso ALB.

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

    Reemplace ALB_CONTROLLER_USER_NAME con el nombre de usuario que desea crear para su controlador ALB Ingress.

  2. Adjunte ALBIngressControllerIAMPolicy al nombre de usuario.

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

    Reemplace lo siguiente:

    • ALB_CONTROLLER_USER_NAME con el nombre de usuario que desea crear para su controlador ALB Ingress.
    • ALB_IAM_POLICY_ARN con el ARN de la política de IAM que creó anteriormente.

  3. Cree una clave de acceso de AWS IAM para el usuario del controlador de ingreso ALB.

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

    Reemplace ALB_CONTROLLER_USER_NAME con el nombre de usuario que desea crear para su controlador ALB Ingress.

    La herramienta de línea de comandos 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. Guarde la clave de acceso y la clave de acceso secreta en variables de entorno. Las usará para configurar su clúster de usuarios.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY

  5. Cree un secreto en su clúster con la clave de acceso y la clave de acceso secreta. El controlador de entrada de ALB utiliza 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 identidad de carga de trabajo

Complete los pasos de "Creación de un clúster de usuarios con identidad de carga de trabajo" . Al crear una política , utilice el ARN de ALBIngressControllerIAMPolicy para el valor de EXISTING_AWS_POLICY .

Configurar su clúster

Para configurar un ALB, debe instalar los siguientes componentes en su clúster de usuarios:

  1. Implemente 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. Descargue el manifiesto del controlador de AWS Load Balancer 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. Seleccione si está utilizando un usuario o rol de IAM con identidad de carga de trabajo.

    Usuario de IAM

    Edite el archivo v2_4_0_full.yaml y busque kind: Deployment . Reemplace 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.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
    ---

    Reemplace lo siguiente:

    • AWS_ACCESS_KEY_ID : la clave de acceso de AWS generada cuando creó un usuario de AWS IAM
    • AWS_SECRET_ACCESS_KEY : la clave de acceso secreta de AWS generada cuando creó un usuario de AWS IAM

    Rol con identidad de carga de trabajo

    Edite el archivo v2_4_0_full.yaml y busque kind: Deployment . Reemplace 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
---

    Reemplace lo siguiente:

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

  4. Aplique el controlador a su clúster. 

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

    GKE en AWS instala el controlador de ingreso ALB.

Creando un ALB

En esta sección crearás un ALB de ejemplo que sirva como remake del juego 2048 .

  1. Copia la siguiente configuración YAML en un archivo llamado 2048.yaml . Esta configuración crea un espacio de nombres, un servicio y una implementación 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. Utilice kubectl para aplicar la configuración a su clúster. 

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

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

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

    Se muestra el estado de su Ingress. La columna ADDRESS contiene el punto final de su Ingress. 

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

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

¿Qué sigue?