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

Esta página le muestra cómo configurar un balanceador de carga de aplicaciones (ALB) de AWS.

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

Esta página está dirigida a especialistas en redes que desean instalar, configurar y dar soporte a equipos de red. Para obtener más información sobre roles comunes y ejemplos de tareas que mencionamos en Google Cloud contenido, consulte Roles y tareas de usuario comunes de GKE Enterprise .

Antes de empezar

Antes de que GKE en AWS pueda crear un ALB, debe:

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

Descripción general

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

Identifique y etiquete o anote las subredes dentro de su VPC en las que desea que se aprovisionen los ALB.
Cree una función de AWS que le dé al controlador ALB acceso a los recursos de AWS.
Instale el aws-load-balancer-controller de código abierto.
Cree e implemente una configuración ALB.

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

Crear un balanceador de carga de aplicaciones

Etiqueta las subredes para 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 autodescubrimiento. Como alternativa, puede agregar una anotación al objeto Ingress para indicar explícitamente las subredes en las que se ejecutará.

Para etiquetar las subredes seleccionadas como disponibles para el descubrimiento automático, consulte etiquetar las subredes de su balanceador de carga de servicio .

Para anotar el objeto Ingress con una lista de subredes, agregue una anotación llamada alb.ingress.kubernetes.io/subnets al objeto Ingress de Kubernetes. Establezca el valor de la anotación como una lista de ID o nombres de subred separados por comas; por ejemplo subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef .

Crear permisos de AWS IAM

Descargue la política de IAM para el controlador del balanceador de carga de AWS. Esta política enumera los permisos que necesita el controlador para funcionar. Puede consultarla en GitHub . Este comando la guarda 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

Utilice este archivo para crear una política de IAM denominada AWSLoadBalancerControllerIAMPolicy :

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

Otorgar acceso a su balanceador de carga

Cree un rol de AWS IAM para la cuenta de servicio del controlador siguiendo las instrucciones de "Crear un rol de AWS IAM" . En estas instrucciones, sustituya lo siguiente:

AWS_POLICY_ARN : el ARN de la AWSLoadBalancerControllerIAPolicy creada 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, ejecute 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, extraiga y guarde los siguientes valores. Los necesitará más adelante.

Encuentre el UID de su clúster ejecutando el siguiente comando:

  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"

Encuentre el ID de VPC de su clúster ejecutando el siguiente comando:

  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"

Busque el ARN del rol llamado AWSLBControllerRole ejecutando el siguiente comando:

aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text

Encuentre la región de AWS de su clúster ejecutando el siguiente comando:

gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"

Reemplazar:

GOOGLE_CLOUD_LOCATION con el nombre de la región de Google asociada a su clúster
CLUSTER_NAME con el nombre de su clúster

Instale 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

Descargue el manifiesto de aws-load-balancer-controller y guárdelo 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

Edite el archivo v2_4_4_full.yaml y busque kind: Deployment . Reemplace 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
---

Reemplace lo siguiente:

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

Aplique el manifiesto modificado a su clúster con el siguiente comando:
```
kubectl apply -f v2_4_4_full.yaml
```
Confirme 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 verse similar a la siguiente, lo 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

Esta sección demuestra cómo crear un ALB de ejemplo que sirva como remake del juego 2048 .

Copie la siguiente configuración YAML en un archivo llamado 2048.yaml . Esta configuración crea un espacio de nombres, un servicio y una implementación de Kubernetes. La implementación se expone mediante 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

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

Verifique 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 punto final de su 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
 ```

Acceda al punto final de ALB en un navegador (por ejemplo: http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com ). Se mostrará el juego 2048, lo que demuestra que ha implementado y configurado correctamente su balanceador de carga ALB.

Limpiando

Para eliminar el ALB de muestra y la implementación creada en el paso anterior, elimine el manifiesto con el siguiente comando:

kubectl delete -f 2048.yaml

¿Qué sigue?

Obtenga más información sobre las anotaciones de Ingress
Obtenga información sobre la documentación de AWS Load Balancer Controller .

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