El producto descrito en esta documentación, clústeres de Anthos en AWS (generación anterior), ahora está en modo de mantenimiento. Todas las instalaciones nuevas deben usar el producto de generación actual, clústeres de Anthos en AWS.

Crea un balanceador de cargas de aplicaciones (ALB)

En este tema, se muestra cómo configurar un balanceador de cargas de aplicaciones (ALB) de AWS con GKE en AWS.

Antes de comenzar

Antes de comenzar a usar GKE on AWS, completa las siguientes tareas:

Completa los requisitos previos.

Tener permisos a fin de crear políticas de IAM, funciones y usuarios de AWS para el balanceador de cargas
Instalar un servicio de administración
Crear un clúster de usuario Si usas Workload Identity, crea un clúster de usuario con Workload Identity.
Desde tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuario.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Reemplaza CLUSTER_NAME por el nombre de tu clúster de usuario.
Instalar la herramienta de línea de comandos de curl o una herramienta similar.

Etiqueta subredes

GKE en AWS requiere etiquetas en las subredes que contienen extremos del ALB. GKE en AWS etiqueta de forma automática todas las subredes especificadas en el campo spec.Networking.ServiceLoadBalancerSubnetIDs del recurso AWSCluster.

Si instalaste clústeres de GKE en AWS en una VPC existente o deseas usar subredes adicionales, aplica etiquetas a las subredes en dos o más zonas de disponibilidad de AWS.

Configura el ALB en GKE en AWS

Antes de crear un ALB, configura clústeres de GKE 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.

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-load-balancer-controller/v2.4.0/docs/install/iam_policy.json

Usa la herramienta de línea de comandos de aws para crear una política de IAM llamada ALBIngressControllerIAMPolicy.
```
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.

Otorga acceso al balanceador de cargas

En esta sección, asociarás la política de usuarios con un usuario de IAM de AWS o con un rol de IAM que tenga una identidad de carga de trabajo configurada.

Usuario de IAM

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.
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.
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"
  }
}
```
Precaución: : No puedes recuperar la clave secreta después de este punto. Guarda la clave para usarla más adelante.
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
```
Nota: También necesitas la clave de acceso y la clave secreta en la siguiente sección.
Crea un secreto en su clúster con la clave de acceso y la clave de acceso secreta. El controlador de Ingress del ALB usa este secreto para autenticarse en AWS y administrar los ALB.
Importante: Asegúrate de que el contexto esté configurado en el clúster de usuario en el que deseas habilitar el ALB.
```
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
```

Rol con Workload Identity

Completa los pasos de Crea un clúster de usuario con identidad con Workload Identity. Cuando crees una política, usa el ARN de ALBIngressControllerIAMPolicy para el valor de EXISTING_AWS_POLICY.

Configura tu clúster

Para configurar un ALB, debes instalar los siguientes componentes en tu clúster de usuario:

El cert-manager de Jetstack a fin de generar y administrar certificados TLS para los recursos ALB de tu clúster.
El controlador del balanceador de cargas de AWS para aprovisionar y administrar los ALB

Para implementar el administrador de certificados de Jetstack, instala el manifiesto desde GitHub.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.5.4/cert-manager.yaml

Descarga el manifiesto del controlador del balanceador de cargas de AWS desde GitHub:

curl -Lo v2_4_0_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.4.0/v2_4_0_full.yaml

Selecciona si usas un rol de usuario de IAM con identidad de carga de trabajo.

Usuario de IAM

Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Reemplaza el objeto de Deployment con esta versión modificada:

kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: aws-load-balancer-controller
  name: aws-load-balancer-controller
  namespace: kube-system
spec:
  replicas: 1
  selector:
  matchLabels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: aws-load-balancer-controller
  template:
    metadata:
      labels:
        app.kubernetes.io/component: controller
        app.kubernetes.io/name: aws-load-balancer-controller
    spec:
      containers:
        - args:
          - --cluster-name=CLUSTER_UID
          - --aws-region=AWS_REGION
          - --aws-vpc-id=AWS_VPC_ID
          - --ingress-class=alb
          - --disable-restricted-sg-rules=true
        image: amazon/aws-alb-ingress-controller:v2.4.0
        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
        livenessProbe:
          failureThreshold: 2
          httpGet:
            path: /healthz
            port: 61779
            scheme: HTTP
          initialDelaySeconds: 30
          timeoutSeconds: 10
        name: controller
        ports:
        - containerPort: 9443
          name: webhook-server
          protocol: TCP
        resources:
          limits:
            cpu: 200m
            memory: 500Mi
          requests:
            cpu: 100m
            memory: 200Mi
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsNonRoot: true
        volumeMounts:
        - mountPath: /tmp/k8s-webhook-server/serving-certs
          name: cert
          readOnly: true
      priorityClassName: system-cluster-critical
      securityContext:
        fsGroup: 1337
      serviceAccountName: aws-load-balancer-controller
      terminationGracePeriodSeconds: 10
      volumes:
      - name: cert
        secret:
          defaultMode: 420
          secretName: aws-load-balancer-webhook-tls
    ---

Reemplaza lo siguiente:

AWS_ACCESS_KEY_ID: La clave de acceso de AWS que se generó cuando creaste un usuario de IAM de AWS
AWS_SECRET_ACCESS_KEY: La clave de acceso secreta de AWS generada cuando creaste un usuario de IAM de AWS

Rol con Workload Identity

Edita el archivo v2_4_0_full.yaml y busca kind: Deployment. Reemplaza todo el objeto Deployment con esta versión modificada:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: aws-load-balancer-controller
  name: aws-load-balancer-controller
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/component: controller
      app.kubernetes.io/name: aws-load-balancer-controller
  template:
    metadata:
      labels:
        app.kubernetes.io/component: controller
        app.kubernetes.io/name: aws-load-balancer-controller
    spec:
      containers:
      - args:
        - --cluster-name=CLUSTER_UID
        - --aws-region=AWS_REGION
        - --aws-vpc-id=AWS_VPC_ID
        - --ingress-class=alb
        - --disable-restricted-sg-rules=true
        image: amazon/aws-alb-ingress-controller:v2.4.0
        env:
        - name: AWS_ROLE_ARN
          value: LB_CONTROLLER_ROLE_ARN
        - name: AWS_WEB_IDENTITY_TOKEN_FILE
          value: /var/run/secrets/aws-load-balancer-controller/serviceaccount/token
        livenessProbe:
          failureThreshold: 2
          httpGet:
            path: /healthz
            port: 61779
            scheme: HTTP
          initialDelaySeconds: 30
          timeoutSeconds: 10
        name: controller
        ports:
        - containerPort: 9443
          name: webhook-server
          protocol: TCP
        resources:
          limits:
            cpu: 200m
            memory: 500Mi
          requests:
            cpu: 100m
            memory: 200Mi
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsNonRoot: true
        volumeMounts:
        - mountPath: /tmp/k8s-webhook-server/serving-certs
          name: cert
          readOnly: true
        - mountPath: /var/run/secrets/aws-load-balancer-controller/serviceaccount
          name: aws-iam-token
          readOnly: true
      priorityClassName: system-cluster-critical
      securityContext:
        fsGroup: 1337
      serviceAccountName: aws-load-balancer-controller
      terminationGracePeriodSeconds: 10
      volumes:
      - name: cert
        secret:
          defaultMode: 420
          secretName: aws-load-balancer-webhook-tls
      - name: aws-iam-token
        projected:
          defaultMode: 420
          sources:
          - serviceAccountToken:
              audience: sts.amazonaws.com
              expirationSeconds: 86400
              path: token
---

Reemplaza lo siguiente:

CLUSTER_UID: El UID del clúster, por ejemplo, bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: El ID de la VPC de AWS, por ejemplo, vpc-1234567890abc
LB_CONTROLLER_ROLE_ARN: el ARN del rol AWSLBControllerRole
AWS_REGION: La región de AWS de tu clúster, por ejemplo, us-east-1

Aplica el controlador al clúster.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f v2_4_0_full.yaml
```
GKE en AWS instala el controlador de Ingress del ALB.

Crea un ALB

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

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

Usa kubectl para aplicar la configuración al clúster.

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

Usa kubectl para verificar el estado del recurso Ingress.

env HTTPS_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

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.

¿Qué sigue?

Lee la documentación del controlador de Ingress del ALB.