Esta documentação é referente à versão atual do GKE na AWS, lançada em novembro de 2021. Consulte as Notas de lançamento para mais informações.

Configurar um balanceador de carga HTTP

Nesta página, mostramos como configurar um balanceador de carga de aplicativo (ALB) da AWS.

Para mais informações sobre os outros tipos de balanceadores de carga que o GKE na AWS é compatível, consulte Visão geral do balanceador de carga.

Antes de começar

Antes que o GKE na AWS possa criar um ALB, você precisa:

Criar um cluster do GKE na AWS e configurar o acesso a ele com kubectl.
Registre o provedor OIDC do cluster com a AWS.

Visão geral

A criação do primeiro ALB em um cluster envolve as seguintes etapas:

Identifique e marque ou anote as sub-redes na VPC em que você quer que os ALBs sejam provisionados.
Crie um papel da AWS que conceda ao controlador do ALB acesso aos recursos da AWS.
Instale o código aberto aws-load-balancer-controller.
Crie e implante uma configuração do ALB.

Para criar ALBs subsequentes, você só precisa criar e implantar outra configuração do ALB.

Crie um balanceador de carga de aplicativo

Incluir tags nas sub-redes do ALB

Antes de criar um ALB, é preciso informar à AWS em quais sub-redes ele será executado. O método comum é marcar a sub-rede com uma tag que a identifique como disponível para o processo de descoberta automática. Como alternativa, é possível adicionar uma anotação ao objeto Ingress para listar explicitamente as sub-redes em que ele é executado.

Para marcar as sub-redes selecionadas como disponíveis para descoberta automática, consulte marque as sub-redes do balanceador de carga de serviço.

Para anotar o objeto Entrada com uma lista de sub-redes, adicione uma anotação chamada alb.ingress.kubernetes.io/subnets ao objeto Entrada do Kubernetes. Defina o valor da anotação como uma lista separada por vírgulas de IDs de sub-rede ou nomes de sub-rede, por exemplo, subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Criar permissões do IAM da AWS

Faça o download da política do IAM para o controlador de balanceador de carga da AWS. Essa política enumera as permissões que o controlador do balanceador de carga precisa para funcionar. Revise a política no GitHub. Esse comando salva a política em um arquivo chamado iam_policy.json.

  curl -Lo iam_policy.json \
    https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.4/docs/install/iam_policy.json

Use este arquivo para criar uma política do IAM chamada AWSLoadBalancerControllerIAMPolicy:

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

Conceder acesso ao balanceador de carga

Crie um papel do IAM da AWS para a conta de serviço do controlador seguindo as instruções em Criar um papel do IAM da AWS. Nestas instruções, substitua o seguinte:

AWS_POLICY_ARN: o ARN do AWSLoadBalancerControllerIAPolicy criado na etapa anterior
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

Para recuperar o ARN da política, execute este comando:

aws iam list-policies \
  --query 'Policies[?PolicyName==`AWSLoadBalancerControllerIAMPolicy`].Arn' \
  --output text

Instalar o controlador do balanceador de carga da AWS

Para concluir essas etapas, extraia e salve os valores a seguir. Você vai precisar deles mais tarde.

Encontre o UID do cluster executando o seguinte comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"
```
Encontre o ID de VPC do cluster executando o seguinte comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"
```
Para encontrar o ARN do papel chamado AWSLBControllerRole, execute o comando a seguir:
```
aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
```
Para encontrar a região da AWS do cluster, execute o comando a seguir:
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"
```
Substitua:
- GOOGLE_CLOUD_LOCATION pelo nome da região do Google associada ao cluster
- CLUSTER_NAME pelo nome do cluster.

Instale cert-manager com o seguinte comando:

kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.yaml

Faça o download do manifesto para a aws-load-balancer-controller e salve-o no arquivo local v2_4_4_full.yaml com o seguinte comando:

curl -Lo v2_4_4_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.4/v2_4_4_full.yaml

Edite o arquivo v2_4_4_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.4
        env:
        - name: AWS_ROLE_ARN
          value: AWS_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.
AWS_ROLE_ARN: o ARN do papel chamado AWSLBControllerRole
AWS_REGION: a região da AWS do cluster, por exemplo, us-east-1

Aplique o manifesto modificado ao cluster com o seguinte comando:
```
kubectl apply -f v2_4_4_full.yaml
```
Confirme se o controlador do balanceador de carga está em execução com o seguinte comando:
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
A saída será semelhante à seguinte, que mostra que a implantação do aws-load-balancer-controller está disponível.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Criar um exemplo de ALB

Esta seção demonstra como criar um exemplo de ALB que veicula uma nova versão do jogo 2048.

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 por meio de um ALB de entrada.

apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
---
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
      - image: alexwhen/docker-2048
        imagePullPolicy: Always
        name: app-2048
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80

Aplique a configuração ao cluster com o seguinte comando:
```
kubectl apply -f 2048.yaml
```

Verifique o status do recurso Entrada com o seguinte comando:

kubectl get ingress -n game-2048 ingress-2048

A resposta ao comando é semelhante ao exemplo abaixo. A coluna ADDRESS contém o endpoint do seu recurso de Entrada.

 NAME           CLASS    HOSTS   ADDRESS                                                                   PORTS   AGE
 ingress-2048   <none>   *       k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com   80      2m19s
 ```

Navegue até o endpoint do ALB em um navegador, por exemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. O jogo de 2048 é exibido, demonstrando que você implantou e configurou com sucesso o balanceador de carga do ALB.

Como fazer a limpeza

Para remover o ALB de amostra e a implantação criados na etapa anterior, exclua o manifesto com o seguinte comando:

kubectl delete -f 2048.yaml

A seguir

Saiba mais sobre as anotações da Entrada.
Saiba mais sobre a documentação do controlador de balanceador de carga da AWS.