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.

Avant de commencer

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

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

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

    Recherchez l'UID de votre cluster en exécutant 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)"
    

    Pour trouver l'ARN du rôle nommé AWSLBControllerRole, exécutez la commande suivante :

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

    Recherchez la région AWS de votre cluster en exécutant 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
  2. 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
    
  3. 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
    
  4. 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
  5. Appliquez le fichier manifeste modifié à votre cluster à l'aide de la commande suivante :

    kubectl apply -f v2_4_4_full.yaml
    
  6. Vérifiez que le contrôleur de l'équilibreur de charge est en cours d'exécution avec la commande :

    kubectl get deployment -n kube-system aws-load-balancer-controller
    

    Le résultat doit se présenter comme 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 exemple d'ALB

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

  1. 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
    
  2. Appliquez la configuration à votre cluster à l'aide de la commande suivante :

    kubectl apply -f 2048.yaml
    
  3. 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
     ```
    
  4. 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