O produto descrito nesta documentação, GKE na AWS, agora está em modo de manutenção e será encerrado em 17 de março de 2027.

Esta página foi traduzida pela API Cloud Translation.

Configurar um balanceador de carga HTTP

Esta página mostra como configurar um balanceador de carga de aplicação (ALB) da AWS.

Para obter mais informações sobre outros tipos de balanceadores de carga compatíveis com o GKE na AWS, consulte Visão geral do balanceador de carga .

Esta página é para especialistas em redes que desejam instalar, configurar e oferecer suporte a equipamentos de rede. Para saber mais sobre funções comuns e exemplos de tarefas que mencionamos em Google Cloud conteúdo, consulte Funções e tarefas comuns do usuário do GKE Enterprise .

Antes de começar

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

Crie um cluster do GKE na AWS e configure 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 dentro da sua VPC nas quais você deseja que os ALBs sejam provisionados.
Crie uma função da AWS dando ao controlador ALB acesso aos recursos da AWS.
Instale o aws-load-balancer-controller de código aberto.
Crie e implante uma configuração ALB.

Para criar ALBs subsequentes, você precisa apenas criar e implantar outra configuração de ALB.

Criar um balanceador de carga de aplicativo

Marque as sub-redes para seu ALB

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

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

Para anotar o objeto Ingress com uma lista de sub-redes, adicione uma anotação chamada 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 ou nomes de sub-redes — por exemplo subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef .

Criar permissões do AWS IAM

Baixe a política do IAM para o Controlador do Balanceador de Carga da AWS. Esta política enumera as permissões necessárias para o funcionamento do controlador do balanceador de carga. Você pode consultar a política no GitHub . Este 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

Conceda acesso ao seu balanceador de carga

Crie uma função do AWS IAM para a conta de serviço do controlador seguindo as instruções em Criar uma função do AWS IAM . Nessas 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 seguintes valores. Você precisará deles mais tarde.

Encontre o UID do seu 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 chamada AWSLBControllerRole executando o seguinte comando:

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

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

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

Substituir:

GOOGLE_CLOUD_LOCATION com o nome da região do Google associada ao seu cluster
CLUSTER_NAME com o nome do seu 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

Baixe o manifesto para 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 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.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 seu cluster — por exemplo, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID : o ID do seu AWS VPC — por exemplo, vpc-1234567890abc .
AWS_ROLE_ARN : o ARN da função chamada AWSLBControllerRole
AWS_REGION : a região AWS do seu cluster — por exemplo, us-east-1

Aplique o manifesto modificado ao seu 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 deve ser semelhante à seguinte, o que mostra que a implantaçã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 exemplo de ALB

Esta seção demonstra como criar um ALB de exemplo que serve um remake do jogo 2048 .

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

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 seu cluster com o seguinte comando:
```
kubectl apply -f 2048.yaml
```

Verifique o status do recurso Ingress com o seguinte comando:

kubectl get ingress -n game-2048 ingress-2048

A saída do comando é semelhante à seguinte. A coluna ADDRESS contém o ponto de extremidade do seu recurso do Ingress.

 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 ALB em um navegador — por exemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com . O jogo 2048 será exibido, demonstrando que você implantou e configurou com sucesso o balanceador de carga ALB.

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

O que vem a seguir

Saiba mais sobre anotações do Ingress
Saiba mais sobre a documentação do AWS Load Balancer Controller .

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