Como criar um balanceador de carga de aplicativo (ALB)

Neste tópico, mostramos como configurar um balanceador de carga de aplicativo (ALB) da AWS com o GKE na AWS.

Antes de começar

Antes de começar a usar o GKE na AWS, verifique se você executou as seguintes tarefas:

  • Ter permissões para criar políticas, papéis e usuários do IAM da AWS para o balanceador de carga.
  • Instale um serviço de gerenciamento.
  • Crie um cluster de usuário. Caso esteja usando a identidade da carga de trabalho, Crie um cluster de usuário com a identidade da carga de trabalho.
  • No diretório anthos-aws, use anthos-gke para alternar o contexto para o cluster de usuário.
    cd anthos-aws
    env HTTPS_PROXY=http://localhost:8118 \
      anthos-gke aws clusters get-credentials CLUSTER_NAME
    Substitua CLUSTER_NAME pelo nome do cluster de usuário.
  • Instale a ferramenta de linha de comando curl ou uma ferramenta semelhante.

Como marcar sub-redes

O GKE na AWS requer tags em sub-redes que contêm endpoints do ALB. O GKE na AWS marca automaticamente todas as sub-redes especificadas no campo spec.Networking.ServiceLoadBalancerSubnetIDs do recurso AWSCluster.

Se você tiver instalado o GKE na AWS em uma VPC existente ou quiser usar outras sub-redes, aplique tags a sub-redes em duas ou mais zonas de disponibilidade da AWS.

Como configurar o ALB no GKE na AWS

Antes de criar um ALB, configure o GKE na AWS configurando permissões de IAM da AWS e fornecendo chaves de acesso.

Criar permissões do IAM da AWS

Para criar um ALB para o cluster de usuário, é necessário configurar um usuário de IAM da AWS com permissões para criar e operar o ALB.

  1. Faça o download de uma política do IAM para o controlador de Entrada do ALB. Revise a política no 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. Use a ferramenta de linha de comando aws para criar uma política de IAM chamada ALBIngressControllerIAMPolicy.

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

    A resposta inclui o Nome do Recurso da Amazon (ARN) da política de IAM. Salve o ARN para uso posterior.

Conceder acesso ao balanceador de carga

Nesta seção, você associa a política do usuário a um usuário do IAM da AWS ou a um papel do IAM que tenha uma identidade de carga de trabalho configurada.

Usuário do IAM

  1. Use a ferramenta aws para criar um usuário de IAM para o controlador da Entrada do ALB.

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

    Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.

  2. Anexe ALBIngressControllerIAMPolicy ao nome de usuário.

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

    Substitua:

    • ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.
    • ALB_IAM_POLICY_ARN pelo ARN da política do IAM criada anteriormente.
  3. Crie uma chave de acesso de IAM da AWS para o usuário do controlador da Entrada do ALB.

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

    Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.

    A ferramenta de linha de comando aws imprime os detalhes da chave de acesso.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  4. Salve a chave de acesso e a chave de acesso secreta em variáveis de ambiente. Você os usará para configurar o cluster de usuário.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    
  5. Crie um secret no cluster com as chave de acesso e a chave de acesso secreta. O controlador de ALB usa esse Secret para se autenticar na AWS e gerenciar os ABLs.

    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
    
    .

Papel com a identidade da carga de trabalho

Conclua as etapas em Como criar um cluster de usuário com a identidade da carga de trabalho. Ao criar uma política, use o ARN de ALBIngressControllerIAMPolicy como o valor de EXISTING_AWS_POLICY.

Configurar o cluster

Para configurar um ALB, é necessário instalar os seguintes componentes no cluster de usuário:

  1. Implante o Jetstack cert-manager instalando o manifesto do 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. Faça o download do manifesto do controlador de balanceadores de carga da AWS no 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. Selecione se você estiver usando um usuário do IAM ou um papel com identidade da carga de trabalho.

    Usuário do IAM

    Edite o arquivo v2_4_0_full.yaml e pesquise kind: Deployment. Substitua o objeto de implantação por esta versão 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
        ---
    

    Substitua:

    • AWS_ACCESS_KEY_ID: a chave de acesso da AWS gerada quando você criou um usuário do IAM da AWS
    • AWS_SECRET_ACCESS_KEY: a chave de acesso secreta da AWS gerada quando você cria um usuário do IAM da AWS

    Papel com a identidade da carga de trabalho

    Edite o arquivo v2_4_0_full.yaml e pesquise kind: Deployment. Substitua o objeto Deployment por esta versão 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
    ---
    

    Substitua:

    • CLUSTER_UID: o UID do seu cluster, por exemplo, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
    • AWS_VPC_ID: o ID da VPC da AWS, por exemplo, vpc-1234567890abc.
    • LB_CONTROLLER_ROLE_ARN: o ARN do papel AWSLBControllerRole
    • AWS_REGION: a região da AWS do cluster, por exemplo, us-east-1
  4. Aplique o controlador ao cluster.

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

    O GKE na AWS instala o controlador da Entrada do ALB.

Como criar um ALB

Nesta seção, você cria um ALB de exemplo que exibe uma recriação do jogo 2048.

  1. Copie a seguinte configuração de YAML em um arquivo chamado 2048.yaml. A configuração cria um namespace, serviço e implantação do Kubernetes. A implantação é exposta usando uma Entrada.

    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. Use kubectl para aplicar a configuração ao cluster.

    env HTTPS_PROXY=http://localhost:8118 \
      kubectl apply -f 2048.yaml
    
  3. Use kubectl para verificar o status do recurso Entrada.

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

    O status da Entrada será exibido. A coluna ADDRESS contém o endpoint da sua Entrada.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Navegue até o endpoint do ALB em um navegador. Por exemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com o jogo de 2048 aparece.

A seguir