Uma nova versão do GKE na AWS foi lançada em 27 de agosto. Consulte as notas de lançamento para informações sobre alterações interruptivas.

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:

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

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

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

  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.