Le produit décrit dans cette documentation, GKE sur AWS, est désormais en mode de maintenance et sera arrêté le 17 mars 2027.

Cette page a été traduite par l'API Cloud Translation.

Configurer un équilibreur de charge HTTP

Cette page vous explique comment configurer un équilibreur de charge d'application (ALB) AWS.

Pour en savoir plus sur les autres types d'équilibreurs de charge compatibles avec GKE sur AWS, consultez la page Présentation de l'équilibreur de charge.

Cette page s'adresse aux spécialistes de la mise en réseau qui souhaitent installer, configurer et gérer l'équipement réseau. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud , consultez Rôles utilisateur et tâches courantes de GKE.

Avant de commencer

Pour que GKE sur AWS puisse créer un ALB, vous devez :

Créer un cluster GKE sur AWS et configurer l'accès à celui-ci avec kubectl.
Enregistrer le fournisseur OIDC du cluster avec AWS.

Présentation

La création du premier ALB dans un cluster implique les étapes suivantes :

Identifier et ajouter un tag ou annoter les sous-réseaux de votre VPC dans lesquels vous souhaitez que les ALB soient provisionnés.
Créer un rôle AWS qui accorde au contrôleur ALB l'accès aux ressources AWS.
Installer le logiciel Open Source aws-load-balancer-controller.
Créer et déployer une configuration d'ALB.

Pour créer des ALB ultérieurs, il vous suffit de créer et de déployer une autre configuration d'ALB.

Créer un équilibreur de charge d'application

Ajouter des tags aux sous-réseaux de votre ALB

Avant de créer un ALB, vous devez indiquer à AWS les sous-réseaux dans lesquels l'exécuter. La méthode habituelle consiste à ajouter un tag au sous-réseau qui l'identifie comme étant disponible pour le processus de découverte automatique. Vous pouvez également ajouter une annotation à l'objet Ingress pour lister explicitement les sous-réseaux dans lesquels il doit s'exécuter.

Pour ajouter un tag aux sous-réseaux sélectionnés comme disponibles pour la découverte automatique, consultez la section Ajouter des tags aux sous-réseaux de votre équilibreur de charge de service.

Pour annoter l'objet Ingress avec une liste de sous-réseaux, ajoutez une annotation nommée alb.ingress.kubernetes.io/subnets à l'objet Ingress Kubernetes. Définissez la valeur de l'annotation sur une liste d'ID ou de noms de sous-réseau séparés par une virgule, par exemple subnet-012345678abcdef,subnet- abcdef123456789,subnet-123456789abcdef.

Créer des autorisations IAM AWS

Téléchargez la stratégie IAM pour le contrôleur d'équilibreur de charge AWS. Cette stratégie énumère les autorisations dont le contrôleur d'équilibrage de charge a besoin pour fonctionner. Vous pouvez consulter la stratégie sur GitHub. Cette commande enregistre la stratégie dans un fichier nommé 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

Utilisez ce fichier pour créer une stratégie IAM nommée AWSLoadBalancerControllerIAMPolicy :

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

Accorder l'accès à votre équilibreur de charge

Créez un rôle AWS IAM pour le compte de service du contrôleur en suivant les instructions de la section Créer un rôle AWS IAM. Dans les instructions ci-dessous, remplacez les éléments suivants :

AWS_POLICY_ARN : ARN de AWSLoadBalancerControllerIAPolicy créé à l'étape précédente.
KSA_NAME : "aws-load-balancer-controller"
K8S_NAMESPACE : "kube-system"
AWS_ROLE_NAME : "AWSLBControllerRole"

Pour récupérer l'ARN de la stratégie, exécutez la commande suivante :

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

Installer le contrôleur d'équilibreur de charge AWS

Pour effectuer ces étapes, extrayez et enregistrez les valeurs suivantes. Vous en aurez besoin ultérieurement.

Pour trouver l'UID de votre cluster, exécutez la commande suivante :
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(uid)"
```
Pour trouver l'ID de VPC de votre cluster, exécutez la commande suivante :
```
  gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION \
    --format "value(networking.vpcId)"
```
Trouvez l'ARN du rôle nommé AWSLBControllerRole en exécutant la commande suivante :
```
aws iam get-role --role-name AWSLBControllerRole --query Role.Arn --output text
```
Pour trouver la région AWS de votre cluster, exécutez la commande suivante :
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location GOOGLE_CLOUD_LOCATION \
  --format "value(awsRegion)"
```
Remplacez :
- GOOGLE_CLOUD_LOCATION par le nom de la région Google associée à votre cluster
- CLUSTER_NAME par le nom de votre cluster

Installez cert-manager à l'aide de la commande suivante :

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

Téléchargez le fichier manifeste pour aws-load-balancer-controller et enregistrez-le dans le fichier local v2_4_4_full.yaml à l'aide de la commande suivante :
```
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
```

Modifiez le fichier v2_4_4_full.yaml et recherchez kind: Deployment. Remplacez l'objet Deployment par cette version modifiée :

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

Remplacez les éléments suivants :

CLUSTER_UID : UID unique de votre cluster, par exemple bbc7d232-21f6-4bb1-90dd-4b064cf8ccf8
AWS_VPC_ID : ID de votre VPC AWS, par exemple vpc-1234567890abc
AWS_ROLE_ARN : ARN du rôle nommé AWSLBControllerRole
AWS_REGION : région AWS de votre cluster, par exemple us-east-1

Appliquez le fichier manifeste modifié à votre cluster à l'aide de la commande suivante :
```
kubectl apply -f v2_4_4_full.yaml
```
Vérifiez que le contrôleur d'équilibreur de charge est en cours d'exécution à l'aide de la commande suivante :
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
Le résultat doit ressembler à ce qui suit, ce qui indique que le déploiement aws-load-balancer-controller est disponible.
```
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
aws-load-balancer-controller   1/1     1            1           51s
```

Créer un ALB d'exemple

Cette section explique comment créer un exemple d'ALB qui diffuse un remake du jeu 2048.

Copiez la configuration YAML suivante dans un fichier nommé 2048.yaml. La configuration crée un espace de noms Kubernetes, un service et un déploiement. Le déploiement est exposé via un ALB d'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

Appliquez la configuration à votre cluster à l'aide de la commande suivante :
```
kubectl apply -f 2048.yaml
```

Vérifiez l'état de la ressource Ingress à l'aide de la commande suivante :

kubectl get ingress -n game-2048 ingress-2048

Le résultat de la commande ressemble à ce qui suit. La colonne ADDRESS contient le point de terminaison de votre ressource Ingress.

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

Accédez au point de terminaison ALB dans un navigateur, par exemple : http://k8s-game2048-ingress2-e2c347319a-1195690687.us-west-2.elb.amazonaws.com. Le jeu 2048 s'affiche, démontrant que vous avez déployé et configuré votre équilibreur de charge ALB avec succès.

Nettoyer

Pour supprimer l'exemple d'ALB et le déploiement créés à l'étape précédente, supprimez le fichier manifeste à l'aide de la commande suivante :

kubectl delete -f 2048.yaml

Étapes suivantes

Découvrez les annotations Ingress.
Découvrez la documentation du contrôleur d'équilibreur de charge AWS.

Configurer un équilibreur de charge HTTP Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.