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.