Esta documentación es para la versión actual de GKE en AWS, publicada en noviembre de 2021. Consulta las notas de la versión para obtener más información.

Configura un balanceador de cargas de HTTP

En esta página, se muestra cómo configurar un balanceador de cargas de aplicaciones (ALB) de AWS.

Para obtener más información sobre los otros tipos de balanceadores de cargas que admite GKE en AWS, consulta Descripción general del balanceador de cargas.

Antes de comenzar

Antes de que GKE en AWS pueda crear un ALB, debes hacer lo siguiente:

Crear un clúster de GKE en AWS y configurar el acceso a él con kubectl.
Registrar el proveedor de OIDC del clúster con AWS.

Descripción general

La creación del primer ALB en un clúster implica los siguientes pasos:

Identificar y etiquetar o anotar las subredes dentro de tu VPC en la que deseas aprovisionar los ELB.
Crear una función de AWS que otorgue al controlador de ALB acceso a los recursos de AWS.
Instalar el código abierto aws-load-balancer-controller.
Crear e implementar una configuración de ALB

Para crear los ALB posteriores, solo necesitas crear e implementar otra configuración de ALB.

Crea un balanceador de cargas de aplicaciones

Etiqueta las subredes para tu ALB

Antes de crear un ALB, debes indicarle a AWS en qué subredes se debe ejecutar. El método habitual es etiquetar la subred con una etiqueta que la identifique como disponible para el proceso de descubrimiento automático. Como alternativa, puedes agregar una anotación al objeto Ingress a fin de enumerar de forma explícita las subredes en las que se ejecutará.

A fin de etiquetar las subredes seleccionadas como disponibles para la detección automática, consulta Etiqueta las subredes del balanceador de cargas de servicio.

Para anotar el objeto Ingress con una lista de subredes, agrega una anotación llamada alb.ingress.kubernetes.io/subnets al objeto Ingress de Kubernetes. Configura el valor de la anotación en una lista separada por comas de ID de subredes o nombres de subredes, por ejemplo, subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crea permisos de AWS IAM

Descarga la política de IAM para el controlador del balanceador de cargas de AWS. Esta política enumera los permisos que el controlador del balanceador de cargas necesita para funcionar. Puedes revisar la política en GitHub. Este comando guarda la política en un archivo llamado iam_policy.json.

  curl -Lo iam_policy.json \
    https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.4/docs/install/iam_policy.json

Usa este archivo para crear una política de IAM llamada AWSLoadBalancerControllerIAMPolicy:

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

Otorga acceso al balanceador de cargas

Crea una función de IAM de AWS para la cuenta de servicio del controlador si sigues las instrucciones en Crea una función de IAM de AWS. En estas instrucciones, reemplaza lo siguiente:

AWS_POLICY_ARN: El ARN de AWSLoadBalancerControllerIAPolicy creado en el paso anterior
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

Para recuperar el ARN de la política, ejecuta este comando:

aws iam list-policies \
  --query 'Policies[?PolicyName==`AWSLoadBalancerControllerIAMPolicy`].Arn' \
  --output text

Instala el controlador del balanceador de cargas de AWS

Para completar estos pasos, extrae y guarda los siguientes valores. Los necesitarás más tarde.

Encuentra el UID de tu clúster con la ejecución del siguiente comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"
```
Encuentra el ID de VPC de tu clúster con la ejecución del siguiente comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"
```
Encuentra el ARN del rol llamado AWSLBControllerRole con la ejecución del siguiente comando:
```
aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
```
Encuentra la región de AWS de tu clúster con la ejecución del siguiente comando:
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"
```
Reemplaza lo siguiente:
- GOOGLE_CLOUD_LOCATION por el nombre de la región de Google asociada con el clúster
- CLUSTER_NAME por el nombre del clúster

Instala cert-manager con el siguiente comando:

kubectl apply \
  --validate=false \
  -f https://github.com/jetstack/cert-manager/releases/download/v1.10.0/cert-manager.yaml

Descarga el manifiesto para aws-load-balancer-controller y guárdalo en el archivo local v2_4_4_full.yaml con el siguiente comando:

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

Edita el archivo v2_4_4_full.yaml y busca kind: Deployment. Reemplaza el objeto 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.4
        env:
        - name: AWS_ROLE_ARN
          value: AWS_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
AWS_ROLE_ARN: El ARN del rol llamado AWSLBControllerRole
AWS_REGION: La región de AWS de tu clúster, por ejemplo, us-east-1

Aplica el manifiesto modificado a tu clúster con el siguiente comando:
```
kubectl apply -f v2_4_4_full.yaml
```
Confirma que el controlador del balanceador de cargas se ejecuta con el siguiente comando:
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
El resultado debería ser similar al siguiente, que muestra que la implementación aws-load-balancer-controller está disponible.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Crea un ALB de ejemplo

En esta sección, se muestra cómo crear un ALB de ejemplo que entregue 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 a través de un ALB de Ingress.

apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
---
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
      - image: alexwhen/docker-2048
        imagePullPolicy: Always
        name: app-2048
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80

Aplica la configuración a tu clúster con el siguiente comando:
```
kubectl apply -f 2048.yaml
```

Verifica el estado del recurso Ingress con el siguiente comando:

kubectl get ingress -n game-2048 ingress-2048

El resultado del comando es similar al siguiente. La columna ADDRESS contiene el extremo del recurso de Ingress.

 NAME           CLASS    HOSTS   ADDRESS                                                                   PORTS   AGE
 ingress-2048   <none>   *       k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com   80      2m19s
 ```

Navega al extremo del ALB en un navegador, por ejemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Se muestra el juego 2048 que demuestra que implementaste y configuraste el balanceador de cargas ALB de forma correcta.

Realice una limpieza

Para quitar el ALB y la implementación de muestra que se crearon en el paso anterior, borra el manifiesto con el siguiente comando:

kubectl delete -f 2048.yaml

¿Qué sigue?

Obtén más información sobre anotaciones de Ingress.
Obtén información sobre la documentación del controlador del balanceador de cargas de AWS.