Uma nova versão dos clusters do Anthos no AWS (GKE na AWS) foi lançada em 17 de dezembro. Consulte as Notas de lançamento para mais informações.

Como criar um balanceador de carga de aplicativo (ALB)

Neste tópico, mostramos como configurar um balanceador de carga de aplicativo (ALB, na sigla em inglês; link em inglês) da AWS com clusters do Anthos na AWS (GKE na AWS).

Antes de começar

Antes de começar a usar os clusters do Anthos na AWS, realize as tarefas a seguir:

  • 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 nos clusters do Anthos na AWS

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

Como criar permissões de 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.

  1. 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

  2. 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.

  3. 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.

  4. 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.

  5. 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"
  }
}

  6. 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

Configurar clusters do Anthos na AWS

Para configurar um ALB, salve as credenciais do IAM da AWS como um secret do Kubernetes.

  1. 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.

    .
    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

  1. 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
            - --cluster-name=CLUSTER_ID
            - --aws-vpc-id=AWS_VPC_ID
            - --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
          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 o nome do cluster de usuário. 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.

  2. 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.

  1. 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

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

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

  3. 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

  4. 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.