Uma nova versão dos clusters do Anthos na AWS (GKE na AWS) foi lançada em 1º de julho. 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:

  • 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ários.
  • Instale a ferramenta de linha de comando curl ou uma ferramenta semelhante.

Como marcar sub-redes

Os clusters do Anthos na AWS exigem tags em sub-redes que contenham endpoints ALB. Os clusters do Anthos na AWS marcam automaticamente todas as sub-redes especificadas no campo spec.Networking.ServiceLoadBalancerSubnetIDs do recurso AWSCluster.

Se você tiver instalado clusters do Anthos 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 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.

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 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, se estiver usando a identidade da carga de trabalho, um papel do IAM da AWS.

Usuário do IAM

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

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

    .
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

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, crie papéis no cluster de usuário e implante o controlador de entrada do ALB.

  1. Crie um ClusterRole, ClusterRoleBinding e uma ServiceAccount do Kubernetes para vincular a um usuário ou papel do IAM da AWS. Copie o seguinte YAML para um arquivo chamado aws-alb-ingress-roles.yaml.

    # Original from GitHub: https://github.com/kubernetes-sigs/aws-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
    
  2. Aplique o manifesto ao cluster.

    env HTTP_PROXY=http://localhost:8118 \
      kubectl apply -f aws-alb-ingress-roles.yaml
    
  3. Escolha se você está usando um usuário do IAM ou uma identidade de carga de trabalho e copie o YAML a seguir para um arquivo chamado aws-alb-ingress-deployment.yaml:

    Usuário do IAM

    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
    

    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.

    Identidade da carga de trabalho

    # Original on 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:
          serviceAccount: alb-ingress-controller
          containers:
            - name: alb-ingress-controller
              args:
                - --ingress-class=alb
                - --cluster-name=CLUSTER_ID
                - --aws-vpc-id=AWS_VPC_ID
                - --aws-region=AWS_REGION
              image: amazon/aws-alb-ingress-controller:v1.1.8
              env:
              - name: AWS_ROLE_ARN
                value: AWS_POLICY_ARN
              - name: AWS_WEB_IDENTITY_TOKEN_FILE
                value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
              volumeMounts:
              - mountPath: /var/run/secrets/eks.amazonaws.com/serviceaccount
                name: aws-iam-token
                readOnly: true
          volumes:
          - name: aws-iam-token
            projected:
              defaultMode: 420
              sources:
              - serviceAccountToken:
                  audience: sts.amazonaws.com
                  expirationSeconds: 86400
                  path: token
    

    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.

    • AWS_POLICY_ARN pelo ARN do papel do IAM da AWS com a BLBIngressControllerIAMPolicy anexada. Por exemplo, arn:aws:iam::1234567890:role/my-example-workload-role-1.

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

  4. Aplique o manifesto ao cluster.

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

    Os clusters do Anthos na AWS instalam o controlador de Entrada do ALB.

Como criar um ALB

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

A seguir