The product described by this documentation, Anthos Clusters on AWS (previous generation), is now in maintenance mode. All new installs must use the current generation product, Anthos clusters on AWS.

Como criar um balanceador de carga de aplicativo (ALB)

Neste tópico, mostramos como configurar um balanceador de carga de aplicativo (ALB) da AWS com o GKE na AWS.

Antes de começar

Antes de começar a usar o GKE na AWS, verifique se você executou as seguintes tarefas:

Conclua os Pré-requisitos.

Ter permissões para criar políticas, papéis e usuários do IAM da AWS para o balanceador de carga.
Instale um serviço de gerenciamento.
Crie um cluster de usuário. Caso esteja usando a identidade da carga de trabalho, Crie um cluster de usuário com a identidade da carga de trabalho.
No diretório anthos-aws, use anthos-gke para alternar o contexto para o cluster de usuário.
```
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 usuário.
Instale a ferramenta de linha de comando curl ou uma ferramenta semelhante.

Como marcar sub-redes

O GKE na AWS requer tags em sub-redes que contêm endpoints do ALB. O GKE na AWS marca automaticamente todas as sub-redes especificadas no campo spec.Networking.ServiceLoadBalancerSubnetIDs do recurso AWSCluster.

Se você tiver instalado o GKE na AWS em uma VPC existente ou quiser usar outras sub-redes, aplique tags a sub-redes em duas ou mais zonas de disponibilidade da AWS.

Como configurar o ALB no GKE na AWS

Antes de criar um ALB, configure o GKE na AWS configurando permissões de IAM da AWS e fornecendo chaves de acesso.

Criar permissões do IAM da AWS

Para criar um ALB para o cluster de usuário, é necessário configurar um usuário de IAM da AWS com permissões para criar e operar o ALB.

Faça o download de uma política do IAM para o controlador de Entrada do ALB. Revise 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 de IAM chamada 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 de IAM. Salve o ARN para uso posterior.

Conceder acesso ao balanceador de carga

Nesta seção, você associa a política do usuário a um usuário do IAM da AWS ou a um papel do IAM que tenha uma identidade de carga de trabalho configurada.

Usuário do IAM

Use a ferramenta aws para criar um usuário de IAM para o controlador da Entrada do ALB.
```
aws iam create-user \
--user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.
Anexe ALBIngressControllerIAMPolicy ao nome de usuário.
```
aws iam attach-user-policy \
 --user-name ALB_CONTROLLER_USER_NAME \
 --policy-arn ALB_IAM_POLICY_ARN
```
Substitua:
- ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.
- ALB_IAM_POLICY_ARN pelo ARN da política do IAM criada anteriormente.
Crie uma chave de acesso de IAM da AWS para o usuário do controlador da Entrada do ALB.
```
aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
```
Substitua ALB_CONTROLLER_USER_NAME pelo nome de usuário que você quer criar para o controlador da entrada do ALB.

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"
  }
}
```
Cuidado: não é possível recuperar a chave secreta após esse ponto. Salve a chave para usá-la posteriormente.
Salve a chave de acesso e a chave de acesso secreta em variáveis de ambiente. Você os usará para configurar o cluster de usuário.
```
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 secret no cluster com as chave de acesso e a chave de acesso secreta. O controlador de ALB usa esse Secret para se autenticar na AWS e gerenciar os ABLs.

Importante: verifique se o contexto está definido como o cluster de usuários em que você 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
```
.

Papel com a identidade da carga de trabalho

Conclua as etapas em Como criar um cluster de usuário com a identidade da carga de trabalho. Ao criar uma política, use o ARN de ALBIngressControllerIAMPolicy como o valor de EXISTING_AWS_POLICY.

Configurar o cluster

Para configurar um ALB, é necessário instalar os seguintes componentes no cluster de usuário:

O cert-manager do Jetstack para gerar e gerenciar certificados TLS para os recursos ALB do cluster.
O controlador do balanceador de carga da AWS para provisionar e gerenciar ALBs.

Implante o Jetstack cert-manager 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

Faça o download do manifesto do controlador de balanceadores de carga da AWS no 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ê estiver usando um usuário do IAM ou um papel com identidade da carga de trabalho.

Usuário do IAM

Edite o arquivo v2_4_0_full.yaml e pesquise kind: Deployment. Substitua o objeto de implantação 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:

AWS_ACCESS_KEY_ID: a chave de acesso da AWS gerada quando você criou um usuário do IAM da AWS
AWS_SECRET_ACCESS_KEY: a chave de acesso secreta da AWS gerada quando você cria um usuário do IAM da AWS

Papel com a identidade da carga de trabalho

Edite o arquivo v2_4_0_full.yaml e pesquise kind: Deployment. Substitua 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:

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.
LB_CONTROLLER_ROLE_ARN: o ARN do papel AWSLBControllerRole
AWS_REGION: a região da AWS do 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 da Entrada do ALB.

Como criar um ALB

Nesta seção, você cria um ALB de exemplo que exibe uma recriaçã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 usando uma Entrada.

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 status do recurso Entrada.

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

O status da Entrada será exibido. A coluna ADDRESS contém o endpoint da sua Entrada.

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

Navegue até o endpoint do ALB em um navegador. Por exemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com o jogo de 2048 aparece.

A seguir

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