Criando um balanceador de carga de aplicativo (ALB)

Este tópico mostra como configurar um AWS Application Load Balancer (ALB) com o GKE na AWS.

Antes de começar

Antes de começar a usar o GKE na AWS, certifique-se de ter executado as seguintes tarefas:

• Conclua os pré-requisitos .

• Tenha permissões para criar políticas, funções e usuários do AWS IAM para o balanceador de carga.
• Instalar um serviço de gerenciamento .
• Crie um cluster de usuários . Se você estiver usando identidade de carga de trabalho, crie um cluster de usuários com identidade de carga de trabalho .
• No seu diretório anthos-aws , use anthos-gke para alternar o contexto para seu cluster de usuários.

  cd anthos-aws
  env HTTPS_PROXY=http://localhost:8118 \
    anthos-gke aws clusters get-credentials CLUSTER_NAME

  Substitua CLUSTER_NAME pelo nome do seu cluster de usuário.
• Instale a ferramenta de linha de comando curl ou uma ferramenta similar.

Marcação de sub-redes

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

Se você instalou o GKE na AWS em uma VPC existente ou deseja usar sub-redes adicionais, aplique tags a sub-redes em duas ou mais zonas de disponibilidade da AWS.

Configurar o ALB no GKE na AWS

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

Criar permissões do AWS IAM

Para criar um ALB para seu cluster de usuários, você deve configurar um usuário do AWS IAM com permissões para criar e operar o ALB.

1. Baixe uma política do IAM para o Controlador de Entrada ALB. Você pode consultar 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 do IAM chamada ALBIngressControllerIAMPolicy .

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

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

Conceda acesso ao seu balanceador de carga

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

Configure seu cluster

Para configurar um ALB, você precisa instalar os seguintes componentes no seu cluster de usuários:

• O gerenciador de certificados Jetstack para gerar e gerenciar certificados TLS para os recursos ALB do seu cluster.
• O AWS Load Balancer Controller para provisionar e gerenciar ALBs.

1. Implante o gerenciador de certificados do Jetstack 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. Baixe o manifesto do AWS Load Balancer Controller do 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ê está usando um usuário ou função do IAM com identidade de carga de trabalho.

   Usuário IAM

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

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

   Função com identidade de carga de trabalho

   Edite o arquivo v2_4_0_full.yaml e pesquise por kind: Deployment . Substitua todo 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 o seguinte:

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

4. Aplique o controlador ao seu cluster.

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

   O GKE na AWS instala o controlador ALB Ingress.

Criando um ALB

Nesta seção, você cria um ALB de exemplo que serve como um remake do jogo 2048 .

1. Copie a seguinte configuração YAML para um arquivo chamado 2048.yaml . A configuração cria um namespace, serviço e implantação do Kubernetes. A implantação é exposta usando um 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. Use kubectl para aplicar a configuração ao seu cluster.

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

3. Use kubectl para verificar o status do recurso Ingress.

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

   O status do seu Ingress é exibido. A coluna ADDRESS ​​contém o ponto de extremidade do seu Ingress.

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

4. Navegue até o ponto final do ALB em um navegador. Por exemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com O jogo de 2048 é exibido.

O que vem a seguir

• Leia a documentação do controlador ALB Ingress .