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.

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.

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

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.

Usuário IAM

Use a ferramenta aws para criar um usuário do IAM para o controlador ALB Ingress.
```
aws iam create-user \
--user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você deseja criar para seu controlador ALB Ingress.
Anexe o ALBIngressControllerIAMPolicy ao nome de usuário.
```
aws iam attach-user-policy \
 --user-name ALB_CONTROLLER_USER_NAME \
 --policy-arn ALB_IAM_POLICY_ARN
```
Substitua o seguinte:
- ALB_CONTROLLER_USER_NAME pelo nome de usuário que você deseja criar para seu controlador ALB Ingress.
- ALB_IAM_POLICY_ARN pelo ARN da política do IAM que você criou anteriormente.
Crie uma chave de acesso do AWS IAM para o usuário do controlador ALB Ingress.
```
aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você deseja criar para seu controlador ALB Ingress.
A ferramenta de linha de comando 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"
  }
}
```
Atenção: Você não poderá recuperar a chave secreta após este ponto. Guarde a chave para usá-la mais tarde.
Salve a chave de acesso e a chave de acesso secreta em variáveis de ambiente. Você as usará para configurar seu cluster de usuários.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```
Observação: você também precisa da chave de acesso e da chave secreta na seção a seguir.
Crie um segredo no seu cluster com a chave de acesso e a chave de acesso secreta. O controlador de entrada do ALB usa esse segredo para autenticar na AWS e gerenciar ALBs.
Importante: certifique-se de que seu contexto esteja definido para o cluster de usuários no qual você deseja habilitar 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 identidade de carga de trabalho

Conclua as etapas em Criação de um cluster de usuários com identidade de carga de trabalho . Ao criar uma política , use o ARN de ALBIngressControllerIAMPolicy para o valor de EXISTING_AWS_POLICY .

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.

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

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

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

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 .

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

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

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

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

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 .

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

Antes de começar

Marcação de sub-redes

Configurar o ALB no GKE na AWS

Criar permissões do AWS IAM

Conceda acesso ao seu balanceador de carga

Usuário IAM

Função com identidade de carga de trabalho

Configure seu cluster

Usuário IAM

Função com identidade de carga de trabalho

Criando um ALB

O que vem a seguir

Criando um balanceador de carga de aplicativo (ALB)