El producto descrito en esta documentación, GKE en AWS, ahora está en modo de mantenimiento y se cerrará el 17 de marzo de 2027.

Esta página se ha traducido con Cloud Translation API.

Configurar un balanceador de carga HTTP

En esta página se explica cómo configurar un balanceador de carga de aplicaciones (ALB) de AWS.

Para obtener más información sobre los otros tipos de balanceadores de carga que admite GKE en AWS, consulta la descripción general de los balanceadores de carga.

Esta página está dirigida a especialistas en redes que quieran instalar, configurar y ofrecer asistencia para equipos de redes. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas de usuario habituales de GKE.

Antes de empezar

Para que GKE on AWS pueda crear un ALB, debes hacer lo siguiente:

Crea un clúster de GKE en AWS y configura el acceso a él con kubectl.
Registre el proveedor de OIDC del clúster en AWS.

Información general

Para crear el primer ALB en un clúster, sigue estos pasos:

Identifique y etiquete o anote las subredes de su VPC en las que quiera aprovisionar los balanceadores de carga de aplicaciones.
Crea un rol de AWS que dé al controlador de ALB acceso a los recursos de AWS.
Instala aws-load-balancer-controller de código abierto.
Crea y despliega una configuración de ALB.

Para crear otros balanceadores de carga de aplicaciones, solo tienes que crear e implementar otra configuración de ALB.

Crear un balanceador de carga de aplicaciones

Etiqueta las subredes de tu ALB

Antes de crear un ALB, debe indicar a AWS en qué subredes se ejecutará. El método habitual consiste en etiquetar la subred con una etiqueta que la identifique como disponible para el proceso de detección automática. También puedes añadir una anotación al objeto Ingress para enumerar explícitamente las subredes en las que se va a ejecutar.

Para etiquetar las subredes seleccionadas como disponibles para la detección automática, consulta Etiquetar las subredes del balanceador de carga de tu servicio.

Para anotar el objeto Ingress con una lista de subredes, añade una anotación llamada alb.ingress.kubernetes.io/subnets al objeto Ingress de Kubernetes. Asigna al valor de la anotación una lista de IDs o nombres de subredes separados por comas. Por ejemplo, subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Crear permisos de gestión de identidades y accesos de AWS

Descarga la política de gestión de identidades y accesos del controlador de balanceador de carga de AWS. Esta política enumera los permisos que necesita el controlador del balanceador de carga para funcionar. Puedes consultar 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 gestión de identidades y accesos llamada AWSLoadBalancerControllerIAMPolicy:

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

Conceder acceso al balanceador de carga

Crea un rol de gestión de identidades y accesos de AWS para la cuenta de servicio del controlador siguiendo las instrucciones para crear un rol de gestión de identidades y accesos de AWS. En estas instrucciones, sustituye lo siguiente:

AWS_POLICY_ARN: el ARN de la política de IAP de AWSLoadBalancerController creada en el paso anterior
KSA_NAME: "aws-load-balancer-controller"
K8S_NAMESPACE: "kube-system"
AWS_ROLE_NAME: "AWSLBControllerRole"

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

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

Instalar el controlador del balanceador de carga de AWS

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

Para encontrar el UID de tu clúster, ejecuta el siguiente comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"
```
Para encontrar el ID de VPC de tu clúster, ejecuta el siguiente comando:
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"
```
Para encontrar el ARN del rol llamado AWSLBControllerRole, ejecuta el siguiente comando:
```
aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
```
Para encontrar la región de AWS de tu clúster, ejecuta el siguiente comando:
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"
```
Sustituye:
- GOOGLE_CLOUD_LOCATION con el nombre de la región de Google asociada a tu clúster
- CLUSTER_NAME por el nombre de tu 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 de 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. Sustituye el objeto Deployment por 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
---

Haz los cambios siguientes:

CLUSTER_UID: el UID de tu clúster. Por ejemplo: bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID: el ID de tu VPC de AWS. Por ejemplo, vpc-1234567890abc.
AWS_ROLE_ARN: el ARN del rol llamado AWSLBControllerRole
AWS_REGION: 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 carga se está ejecutando con el siguiente comando:
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
La salida debería ser similar a la siguiente, que muestra que la implementación de aws-load-balancer-controller está disponible.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Crear un ALB de ejemplo

En esta sección se muestra cómo crear un ALB de ejemplo que sirva una versión del juego 2048.

Copia la siguiente configuración YAML en un archivo llamado 2048.yaml. La configuración crea un espacio de nombres, un servicio y un despliegue de Kubernetes. El Deployment 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
```

Consulta el estado del recurso Ingress con el siguiente comando:

kubectl get ingress -n game-2048 ingress-2048

El resultado del comando será similar al siguiente. La columna ADDRESS contiene el endpoint de tu recurso Ingress.

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

Ve al endpoint de ALB en un navegador. Por ejemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Se muestra el juego 2048, lo que demuestra que has implementado y configurado correctamente tu balanceador de carga ALB.

Eliminar los recursos utilizados

Para eliminar el ALB y el Deployment de ejemplo que has creado en el paso anterior, elimina el manifiesto con el siguiente comando:

kubectl delete -f 2048.yaml

Siguientes pasos

Consulta información sobre las anotaciones de entrada.
Consulta la documentación del controlador de balanceador de carga de AWS.

Configurar un balanceador de carga HTTP Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.