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.

Tem permissões para criar um usuário do IAM da AWS para o balanceador de carga.
Instale um serviço de gerenciamento.
Crie um cluster de usuário.

No diretório anthos-aws, use anthos-gke para alternar o contexto para o cluster de usuário.

    cd anthos-aws
    env HTTP_PROXY=http://localhost:8118 \
    anthos-gke aws clusters get-credentials [CLUSTER_NAME]

Instale a ferramenta de linha de comando curl ou uma ferramenta semelhante.
Crie ou selecione sub-redes em duas ou mais zonas de disponibilidade para seu ALB.

Como configurar o ALB no GKE na AWS

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

Como criar permissões de IAM da AWS

Para criar um ALB com GKE na AWS, configure 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-alb-ingress-controller/v1.1.8/docs/examples/iam-policy.json

Use a ferramenta aws para criar uma política de IAM chamada ALBIngressControllerIAMPolicy na política obtida por download.
```
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.
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.
```
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.
```
{
  "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 na próxima etapa.
Salve a chave de acesso e a chave de acesso secreta em variáveis de ambiente. Você os usará para configurar o GKE na AWS.
```
ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
```

Configurar o GKE na AWS

Para configurar o ALB no GKE na AWS, salve as credenciais do IAM da AWS como Secret do Kubernetes.

Crie um Secret com a chave de acesso e o par de chaves de acesso. O controlador de ALB usa esse Secret para se autenticar na AWS e gerenciar os ABLs.

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

Implantar o controlador da entrada do ALB

Copie o seguinte YAML para um arquivo chamado aws-alb-ingress-controller.yaml.

# Original from GitHub: https://github.com/kubernetes-sigs/aws-alb-ingress-controller
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/name: alb-ingress-controller
  name: alb-ingress-controller
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: alb-ingress-controller
  template:
    metadata:
      labels:
        app.kubernetes.io/name: alb-ingress-controller
    spec:
      containers:
        - name: alb-ingress-controller
          args:
            - --ingress-class=alb

            # ID of your cluster. Used when naming resources created
            # by the ALB Ingress Controller, providing distinction between
            # clusters.
            - --cluster-name=CLUSTER_ID

            # AWS VPC ID this Ingress controller uses to create AWS resources.
            - --aws-vpc-id=AWS_VPC_ID

            # AWS region this Ingress controller operates in. Should match the region of your GKE on AWS cluster.
            - --aws-region=AWS_REGION

          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

          # Repository location of the ALB Ingress Controller.
          image: docker.io/amazon/aws-alb-ingress-controller:v1.1.8
      serviceAccountName: alb-ingress-controller
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    app.kubernetes.io/name: alb-ingress-controller
  name: alb-ingress-controller
rules:
  - apiGroups:
      - ""
      - extensions
    resources:
      - configmaps
      - endpoints
      - events
      - ingresses
      - ingresses/status
      - services
      - pods/status
    verbs:
      - create
      - get
      - list
      - update
      - watch
      - patch
  - apiGroups:
      - ""
      - extensions
    resources:
      - nodes
      - pods
      - secrets
      - services
      - namespaces
    verbs:
      - get
      - list
      - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    app.kubernetes.io/name: alb-ingress-controller
  name: alb-ingress-controller
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: alb-ingress-controller
subjects:
  - kind: ServiceAccount
    name: alb-ingress-controller
    namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app.kubernetes.io/name: alb-ingress-controller
  name: alb-ingress-controller
  namespace: kube-system

Substitua:

CLUSTER_ID pelo nome do cluster de usuários do GKE na AWS. Por exemplo, gke-abcdef12.
AWS_VPC_ID pelo código de VPC da AWS. Por exemplo, vpc-1234567890abc.
AWS_REGION pela região da AWS do cluster de usuários. Por exemplo, us-east-1.

Para mais informações sobre essa configuração, consulte alb-ingress-controller no repositório aws-alb-ingress-controller do GitHub.

Aplique o manifesto ao cluster.

env HTTP_PROXY=http://localhost:8118 \
  kubectl apply -f aws-alb-ingress-controller.yaml

Como criar um ALB

Nesta seção, você cria um ALB 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 HTTP_PROXY=http://localhost:8118 \
kubectl apply -f 2048.yaml

Use kubectl para verificar o status do recurso Entrada.

env HTTP_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.