O produto descrito nesta documentação, Anthos Clusters na AWS (geração anterior), está em modo de manutenção . Todas as novas instalações devem usar o produto da geração atual, Anthos Clusters na AWS .

Esta página foi traduzida pela API Cloud Translation.

Criar um balanceador de carga de aplicações (ALB)

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

Antes de começar

Antes de começar a usar o GKE on AWS, certifique-se de que realizou as seguintes tarefas:

Cumpra os pré-requisitos.

Ter autorizações para criar políticas, funções e utilizadores do IAM do AWS para o equilibrador de carga.
Instale um serviço de gestão.
Crie um cluster de utilizadores. Se estiver a usar o Workload Identity, crie um cluster de utilizadores com o Workload Identity.
No diretório do anthos-aws, use anthos-gke para mudar o contexto para o cluster de utilizadores.
```
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 utilizadores.
Instale a ferramenta de linha de comandos curl ou uma ferramenta semelhante.

Etiquetar sub-redes

O GKE no AWS requer etiquetas em sub-redes que contenham pontos finais do ALB. O GKE on AWS etiqueta automaticamente todas as sub-redes especificadas no campo spec.Networking.ServiceLoadBalancerSubnetIDs do recurso AWSCluster.

Se instalou o GKE na AWS numa VPC existente ou quiser usar sub-redes adicionais, aplique etiquetas a sub-redes em duas ou mais zonas de disponibilidade da AWS.

Configure o ALB no GKE na AWS

Antes de poder criar um ALB, configure o GKE no AWS configurando as autorizações do IAM do AWS e fornecendo chaves de acesso.

Crie autorizações de IAM do AWS

Para criar um ALB para o cluster de utilizadores, tem de configurar um utilizador do AWS IAM com autorizações para criar e operar o ALB.

Transfira uma política IAM para o controlador de entrada do ALB. Pode rever 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

Use a ferramenta de linha de comandos aws para criar uma política de IAM denominada 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 IAM. Guarde o ARN para utilização posterior.

Conceda acesso ao seu balanceador de carga

Nesta secção, associa a política do utilizador a um utilizador do AWS IAM ou a uma função do IAM que tenha uma identidade de carga de trabalho configurada.

Utilizador do IAM

Use a ferramenta aws para criar um utilizador do IAM para o controlador de entrada do ALB.
```
aws iam create-user \
--user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de utilizador que quer criar para o controlador de entrada do ALB.
Anexe o símbolo ALBIngressControllerIAMPolicy ao nome de utilizador.
```
aws iam attach-user-policy \
 --user-name ALB_CONTROLLER_USER_NAME \
 --policy-arn ALB_IAM_POLICY_ARN
```
Substitua o seguinte:
- ALB_CONTROLLER_USER_NAME com o nome de utilizador que quer criar para o controlador de entrada do ALB.
- ALB_IAM_POLICY_ARN com o ARN da política de IAM que criou anteriormente.
Crie uma chave de acesso do IAM da AWS para o utilizador do controlador de entrada do ALB.
```
aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de utilizador que quer criar para o controlador de entrada do ALB.

A ferramenta de linha de comandos 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"
  }
}
```
Aviso: não pode obter a chave secreta após este ponto. Guarde a chave para a usar mais tarde.
Guarde a chave de acesso e a chave de acesso secreta em variáveis de ambiente. Vai usá-los para configurar o cluster de utilizadores.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```
Nota: também precisa da chave de acesso e da chave secreta na secção seguinte.
Crie um segredo no cluster com a chave de acesso e a chave de acesso secreta. O controlador ALB Ingress usa este segredo para fazer a autenticação na AWS e gerir ALBs.

Importante: certifique-se de que o context está definido para o cluster de utilizadores no qual quer ativar o 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
```

Função com Workload Identity

Conclua os passos em Criar um cluster de utilizadores com a identidade da carga de trabalho. Quando criar uma política, use o ARN de ALBIngressControllerIAMPolicy para o valor de EXISTING_AWS_POLICY.

Configure o cluster

Para configurar um ALB, tem de instalar os seguintes componentes no cluster de utilizadores:

O Jetstack cert-manager para gerar e gerir certificados TLS para os recursos ALB do seu cluster.
O AWS Load Balancer Controller para aprovisionar e gerir ALBs.

Implemente o cert-manager do Jetstack instalando o manifesto a partir 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

Transfira o manifesto do controlador do balanceador de carga da AWS a partir 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

Selecione se está a usar um utilizador ou uma função do IAM com o Workload Identity.

Utilizador do IAM

Edite o ficheiro v2_4_0_full.yaml e pesquise 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 criou um utilizador do IAM da AWS
AWS_SECRET_ACCESS_KEY: a chave de acesso secreta do AWS gerada quando criou um utilizador do IAM do AWS

Função com Workload Identity

Edite o ficheiro v2_4_0_full.yaml e pesquise kind: Deployment. Substituir o objeto Deployment completo 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 cluster, por exemplo, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: o ID da sua VPC da AWS, por exemplo, vpc-1234567890abc
LB_CONTROLLER_ROLE_ARN: o ARN da função AWSLBControllerRole
AWS_REGION: a região da AWS do seu cluster, por exemplo, us-east-1

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 de entrada do ALB.

Criar um ALB

Nesta secção, cria um ALB de exemplo que apresenta uma nova versão do jogo 2048.

Copie a seguinte configuração YAML para um ficheiro com o nome 2048.yaml. A configuração cria um espaço de nomes, um serviço e uma implementação do Kubernetes. A implementação é exposta através de 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

Use kubectl para aplicar a configuração ao cluster.

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

Use kubectl para verificar o estado do recurso Ingress.

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

É apresentado o estado da sua entrada. A coluna ADDRESS contém o ponto final do seu Ingress.

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

Navegue para o ponto final do ALB num navegador. Por exemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com O jogo 2048 é apresentado.

O que se segue?

Leia a documentação do controlador de entrada ALB.

Criar um balanceador de carga de aplicações (ALB) Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Etiquetar sub-redes

Configure o ALB no GKE na AWS

Crie autorizações de IAM do AWS

Conceda acesso ao seu balanceador de carga

Utilizador do IAM

Função com Workload Identity

Configure o cluster

Utilizador do IAM

Função com Workload Identity

Criar um ALB

O que se segue?

Criar um balanceador de carga de aplicações (ALB)