O produto descrito nesta documentação, o GKE no AWS, encontra-se agora no modo de manutenção e vai ser encerrado a 17 de março de 2027.

Esta página foi traduzida pela API Cloud Translation.

Configure um balanceador de carga HTTP

Esta página mostra como configurar um Application Load Balancer (ALB) da AWS.

Para mais informações sobre os outros tipos de balanceadores de carga que o GKE no AWS suporta, consulte o artigo Vista geral do balanceador de carga.

Esta página destina-se a especialistas de redes que pretendam instalar, configurar e prestar apoio técnico a equipamentos de rede. Para saber mais sobre as funções comuns e as tarefas de exemplo a que fazemos referência no Google Cloud conteúdo, consulte Funções e tarefas comuns de utilizadores do GKE.

Antes de começar

Antes de o GKE no AWS poder criar um ALB, tem de:

Crie um cluster do GKE no AWS e configure o acesso ao mesmo com o kubectl.
Registe o fornecedor OIDC do cluster na AWS.

Vista geral

A criação do primeiro ALB num cluster envolve os seguintes passos:

Identifique e etiquete ou anote as sub-redes na sua VPC onde quer que os ALBs sejam aprovisionados.
Crie uma função da AWS que conceda ao controlador do ALB acesso aos recursos da AWS.
Instale o aws-load-balancer-controller de código aberto.
Crie e implemente uma configuração do ALB.

Para criar ALBs subsequentes, só tem de criar e implementar outra configuração de ALB.

Crie um balanceador de carga de aplicações

Etiquete as sub-redes para o seu ALB

Antes de criar um ALB, tem de indicar à AWS em que sub-redes o executar. O método habitual consiste em etiquetar a sub-rede com uma etiqueta que a identifique como disponível para o processo de deteção automática. Em alternativa, pode adicionar uma anotação ao objeto Ingress para listar explicitamente as sub-redes nas quais deve ser executado.

Para etiquetar as sub-redes selecionadas como disponíveis para deteção automática, consulte o artigo Etiquete as sub-redes do equilibrador de carga do serviço.

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

Crie autorizações de IAM do AWS

Transfira a política de IAM para o controlador do balanceador de carga da AWS. Esta política enumera as autorizações de que o controlador do equilibrador de carga precisa para funcionar. Pode rever a política no GitHub. Este comando guarda a política num ficheiro com o nome 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 ficheiro para criar uma política IAM denominada AWSLoadBalancerControllerIAMPolicy:

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

Conceda acesso ao seu balanceador de carga

Crie uma função do IAM da AWS para a conta de serviço do controlador seguindo as instruções em crie uma função do IAM da AWS. Nestas instruções, substitua o seguinte:

AWS_POLICY_ARN: o ARN da AWSLoadBalancerControllerIAPolicy criado no passo anterior
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

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

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

Instale o controlador do balanceador de carga da AWS

Para concluir estes passos, extraia e guarde os seguintes valores. Vai precisar delas 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 da VPC do seu cluster executando o seguinte comando:

  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"

Encontre o ARN da função denominada AWSLBControllerRole executando o seguinte comando:

aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text

Encontre a região da AWS do seu cluster executando o seguinte comando:

gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"

Substituição:

GOOGLE_CLOUD_LOCATION com o nome da região da Google associada ao seu cluster
CLUSTER_NAME com o nome do cluster

Instale o 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

Transfira o manifesto para aws-load-balancer-controller e guarde-o no ficheiro 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 ficheiro v2_4_4_full.yaml e pesquise kind: Deployment. Substituir 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 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.
AWS_ROLE_ARN: o ARN da função denominada AWSLBControllerRole
AWS_REGION: a região da AWS do seu 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 que o controlador do balanceador de carga está em execução com o seguinte comando:
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
O resultado deve ser semelhante ao seguinte, que mostra que a implementação aws-load-balancer-controller está disponível.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Crie um ALB de exemplo

Esta secção demonstra como criar um ALB de exemplo que disponibiliza um remake 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 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 estado do recurso Ingress com o seguinte comando:

kubectl get ingress -n game-2048 ingress-2048

O resultado do comando é semelhante ao seguinte. A coluna ADDRESS contém o ponto final do seu recurso Ingress.

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

Navegue para o ponto final do ALB num navegador, por exemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. O jogo 2048 é apresentado, o que demonstra que implementou e configurou com êxito o seu equilibrador de carga do ALB.

Limpar

Para remover o ALB e a implementação de exemplo criados no passo anterior, elimine o manifesto com o seguinte comando:

kubectl delete -f 2048.yaml

O que se segue?

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

Configure um balanceador de carga HTTP Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.