El 31 de marzo, se lanzó una nueva versión de los clústeres de Anthos en AWS (GKE en AWS). Consulta las notas de la versión para obtener más información.

Crea un Application Load Balancer (ALB)

En este tema, se muestra cómo configurar un balanceador de cargas de aplicación (ALB) de AWS con clústeres de Anthos alojados en AWS (GKE en AWS).

Antes de comenzar

Antes de comenzar a usar clústeres de Anthos alojados en AWS, asegúrate de haber realizado las siguientes tareas:

  • Tener permisos a fin de crear un usuario IAM de AWS para el balanceador de cargas
  • Instalar un servicio de administración
  • Crear un clúster de usuario
  • Desde tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuario.
    cd anthos-aws
    env HTTP_PROXY=http://localhost:8118 \
    anthos-gke aws clusters get-credentials CLUSTER_NAME
  • Instalar la herramienta de línea de comandos de curl o una herramienta similar.
  • Crear o seleccionar subredes en dos o más zonas de disponibilidad para ALB

Configura ALB en clústeres de Anthos alojados en AWS

Antes de crear un ALB, configura clústeres de Anthos alojados en AWS configurando permisos de IAM de AWS y proporcionando claves de acceso.

Crea permisos de IAM de AWS

A fin de crear un ALB para tu clúster de usuario, debes configurar un usuario de IAM de AWS con permisos para crear y operar el ALB.

  1. Descarga una política de IAM para el controlador de Ingress de ALB. Puedes revisar la política en 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. Usa la herramienta de aws para crear una política de IAM llamada ALBIngressControllerIAMPolicy a partir de la política que descargaste.

    aws iam create-policy \
      --policy-name ALBIngressControllerIAMPolicy \
      --policy-document file://iam-policy.json
    

    La respuesta incluye el nombre de recurso de Amazon (ARN) de la política de IAM. Guarda el ARN para usarlo más tarde.

  3. Usa la herramienta aws a fin de crear un usuario de IAM para el controlador de Ingress del ALB.

    aws iam create-user \
    --user-name ALB_CONTROLLER_USER_NAME
    

    Reemplaza ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.

  4. Adjunta ALBIngressControllerIAMPolicy al nombre de usuario.

    aws iam attach-user-policy \
     --user-name ALB_CONTROLLER_USER_NAME \
     --policy-arn ALB_IAM_POLICY_ARN
    

    Reemplaza lo siguiente:

    • ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.
    • ALB_IAM_POLICY_ARN por el ARN de la política de IAM que creaste antes.
  5. Crea una clave de acceso de IAM de AWS para el usuario del controlador de Ingress del ALB.

    aws iam create-access-key --user-name ALB_CONTROLLER_USER_NAME
    

    Reemplaza ALB_CONTROLLER_USER_NAME por el nombre de usuario que deseas crear para el controlador de Ingress del ALB.

    La herramienta de línea de comandos de aws imprime los detalles de la clave de acceso.

    {
      "AccessKey": {
        "UserName": ALB_CONTROLLER_USER_NAME
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
        "Status": "Active",
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "CreateDate": "2020-07-23T17:53:58Z"
      }
    }
    
  6. Guarda la clave de acceso y la clave de acceso secreta en variables de entorno. Las usarás para configurar tu clúster de usuario.

    ALB_ACCESS_KEY_ID=ACCESS_KEY_ID
    ALB_SECRET_ACCESS_KEY=SECRET_ACCESS_KEY
    

Configura clústeres de Anthos alojados en AWS

Para configurar un ALB, guarda tus credenciales de IAM de AWS como un Secret de Kubernetes.

  1. Crea un secreto con el par de claves de acceso secreto y la clave de acceso. El controlador de Ingress del ALB usa este secreto para autenticarse en AWS y administrar los 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
    

Implementa el controlador de Ingress del ALB

  1. Copia el siguiente YAML en un archivo llamado 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
    

    Reemplaza lo siguiente:

    • CLUSTER_ID con el nombre de tu clúster de usuario. Por ejemplo, gke-abcdef12.

    • AWS_VPC_ID por el ID de la VPC de AWS. Por ejemplo, vpc-1234567890abc.

    • AWS_REGION por la región de AWS del clúster de usuario. Por ejemplo, us-east-1

    Para obtener más información sobre esta configuración, consulta el manifiesto alb-ingress-controller en el repositorio de GitHub aws-alb-ingress-controller.

  2. Aplica el manifiesto al clúster.

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

Crea un ALB

En esta sección, crearás un ALB que entregará una versión nueva del juego 2048.

  1. Copia la siguiente configuración de YAML en un archivo llamado 2048.yaml. La configuración crea un objeto Namespace, Service y Deployment de Kubernetes. La implementación se expone mediante un Ingress.

    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. Usa kubectl para aplicar la configuración al clúster.

    env HTTP_PROXY=http://localhost:8118 \
    kubectl apply -f 2048.yaml
    
  3. Usa kubectl para verificar el estado del recurso Ingress.

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

    Aparecerá el estado del Ingress. La columna ADDRESS contiene el extremo del Ingress.

    NAME           HOSTS   ADDRESS                                                             PORTS   AGE
    2048-ingress   *       123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com   80      2m19s
    
  4. Navega hasta la extremo del ALB en un navegador. Por ejemplo: http://123456-2048game-2048ingr-6fa0-abcdefg.us-east-1.elb.amazonaws.com Aparecerá el juego 2048.