Utiliser plusieurs équilibreurs de charge dans Azure Kubernetes Service (préversion)

Azure Kubernetes Service (AKS) provisionne normalement un équilibreur de charge standard (SLB) pour tous les LoadBalancer services d’un cluster. Étant donné que chaque carte réseau de chaque nœud est limitée à 300 règles d’équilibrage de charge entrantes et à 8 services de lien privé, les grands clusters ou les charges de travail à nombreux ports peuvent rapidement épuiser ces limites.

La préversion de SLB multiples supprime ce goulot d'étranglement en vous permettant de créer plusieurs SLB au sein du même cluster et de répartir les nœuds et Services entre eux. Vous définissez des configurations d’équilibreur de charge, chacune associée à un pool d’agents principal, ainsi qu'à un espace de noms facultatif, des étiquettes ou des sélecteurs de nœuds, et AKS place automatiquement les nœuds et les Services sur le SLB approprié. Le comportement SNAT sortant reste inchangé si outboundType est loadBalancer. Le trafic sortant transite toujours par le premier SLB.

Utilisez cette fonctionnalité pour :

• Mettez à l’échelle au-delà de 300 règles de trafic entrant sans ajouter de clusters.
• Isolez le trafic de locataire ou de charge de travail en liant un SLB dédié à son propre pool d’agents.
• Distribuez les services de lien privé sur plusieurs SLB lorsque vous approchez de la limite par SLB.

Conditions préalables

• aks-preview extension 18.0.0b1 ou ultérieure.
• Fonctionnalité d’abonnement Microsoft.ContainerService/MultipleStandardLoadBalancersPreview enregistrée.
• Kubernetes version 1.28 ou ultérieure.
• Cluster créé avec --load-balancer-backend-pool-type nodeIP ou mettre à jour un cluster existant à l’aide de az aks update.

Installer l’extension Azure CLI aks-preview

• Installez l’extension aks-preview en tirant parti de la commande az extension add.

  az extension add --name aks-preview
  

• Mettez à jour vers la dernière version de l’extension publiée à l’aide de la commande az extension update.

  az extension update --name aks-preview
  

Inscrire l’indicateur de fonctionnalité MultipleStandardLoadBalancersPreview

1. Inscrivez l’indicateur de fonctionnalité MultipleStandardLoadBalancersPreview à l’aide de la commande az feature register.

   az feature register --namespace "Microsoft.ContainerService" --name "MultipleStandardLoadBalancersPreview"
   

   Quelques minutes sont nécessaires pour que l’état s’affiche Registered (Inscrit).

2. Vérifiez l’état de l’inscription en utilisant la commande az feature show :

   az feature show --namespace "Microsoft.ContainerService" --name "MultipleStandardLoadBalancersPreview"
   

3. Quand l’état reflète Inscrit, actualisez l’inscription du fournisseur de ressources Microsoft.ContainerService à l’aide de la commande az provider register.

   az provider register --namespace Microsoft.ContainerService
   

Comment AKS choisit un équilibreur de charge (placement de nœud et de service)

AKS utilise plusieurs entrées pour déterminer où placer des nœuds et exposer les services LoadBalancer. Ces entrées sont définies dans chaque configuration de l’équilibreur de charge et influencent l’équilibrage de charge sélectionné pour chaque ressource.

Utilisation de ces entrées par AKS

Le plan de contrôle AKS rapproche en permanence le nœud et l’état du service à l’aide des règles ci-dessus :

Positionnement des nœuds

Lorsqu’un nœud est ajouté ou mis à jour, AKS vérifie les équilibreurs de charge auxquels il est éligible en fonction du pool principal et du sélecteur de nœuds.

• Si plusieurs SLB correspondent, le contrôleur choisit celui avec les nœuds actuels les plus rares.
• Le nœud est ajouté au pool principal de ce SLB.

Placement du service

Lorsqu’un service LoadBalancer est créé ou mis à jour :

1. AKS recherche des SLB dont les sélecteurs d’espace de noms et d’étiquette correspondent au service.
2. Si l’annotation de service est présente, seuls les SLB nommés sont pris en compte.
3. Les SLB qui ont allowServicePlacement=false ou qui dépassent les limites Azure (300 règles ou 8 services de liaison privée) sont exclus.
4. Parmi les options valides, le SLB avec les règles les plus rares est choisi.

Comportement de "externalTrafficPolicy (ETP)"

AKS gère les services différemment en fonction de la valeur de externalTrafficPolicy.

Pourquoi un pool dédié pour ETP Local ?
En mode multi-SLB, les nœuds qui hébergent des pods pour un service donné peuvent résider sur différents SLB de l’adresse IP virtuelle côté client. Un pool principal partagé contient souvent zéro nœud éligible, ce qui rompt le trafic. En allouant un pool par service et en le synchronisant à partir de EndpointSlice, AKS garantit que l’équilibrage de charge réseau du service pointe toujours vers les nœuds appropriés.

Impact sur les quotas

• Chaque service local ETP ajoute un pool de serveurs en arrière-plan et une règle d'équilibrage de charge à son SLB.
• Cela compte pour la limite de 300 règles, alors surveillez l'utilisation des règles lorsque vous avez de nombreux services locaux ETP.

Aucune modification du trafic sortant

La SNAT sortante transite toujours par le premier aksOutboundBackendPool de SLB lorsque outboundType est loadBalancer, indépendamment des paramètres ETP.

Facultatif : Rééquilibrage

Vous pouvez rééquilibrer manuellement la distribution des nœuds ultérieurement à l’aide de az aks loadbalancer rebalance.

Cette conception vous permet de définir un routage flexible basé sur l’étiquette pour l’infrastructure et les charges de travail, tandis qu’AKS gère automatiquement le placement pour maintenir l’équilibre et éviter les problèmes de quota.

Ajouter la première configuration de l’équilibreur de charge

Ajoutez une configuration nommée kubernetes et liez-la à un pool d’agents principal qui possède toujours au moins un nœud. La suppression de toute configuration ramène le cluster en mode SLB unique.

1. Définissez des variables d’environnement à utiliser dans ce tutoriel. Vous pouvez remplacer toutes les valeurs d’espace réservé par les vôtres, sauf DEFAULT_LB_NAME, qui doit rester sous la forme de kubernetes.

   RESOURCE_GROUP="rg-aks-multislb"
   CLUSTER_NAME="aks-multi-slb"
   LOCATION="westus"
   DEFAULT_LB_NAME="kubernetes"
   PRIMARY_POOL="nodepool1"
   

2. Créez un groupe de ressources à l’aide de la az group create commande.

   az group create --name $RESOURCE_GROUP --location $LOCATION
   

3. Créer un cluster AKS à l’aide de la az aks create commande.\

   az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME \
     --load-balancer-backend-pool-type nodeIP \
     --node-count 3
   

4. Ajoutez un équilibreur de charge par défaut à l’aide de la az aks loadbalancer add commande.

   az aks loadbalancer add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $DEFAULT_LB_NAME \
     --primary-agent-pool-name $PRIMARY_POOL \
     --allow-service-placement true
   

Ajouter des équilibreurs de charge supplémentaires

Créez des configurations spécifiques au locataire en spécifiant un pool principal différent, ainsi que des sélecteurs facultatifs d’espace de noms, d’étiquette ou de nœud.

1. L’équipe 1 exécutera ses propres charges de travail dans un pool de nœuds distinct. Affectez une tenant=team1 étiquette afin que les charges de travail puissent être planifiées à l’aide de sélecteurs :

   TEAM1_POOL="team1pool"
   TEAM1_LB_NAME="team1-lb"
   

2. Créez un deuxième pool de nœuds pour l’équipe 1 à l’aide de la az aks nodepool add commande.

   az aks nodepool add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $TEAM1_POOL \
     --labels tenant=team1 \
     --node-count 2
   

3. Créez un équilibreur de charge pour l’équipe 1 à l’aide de la az aks loadbalancer add commande.

   az aks loadbalancer add --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME \
     --name $TEAM1_LB_NAME \
     --primary-agent-pool-name $TEAM1_POOL \
     --service-namespace-selector "tenant=team1" \
     --node-selector "tenant=team1"
   

4. Étiquetez l’espace de noms cible (par exemple) team1-appspour qu’il corresponde au sélecteur à l’aide de la az aks command invoke commande.

   az aks command invoke \
     --resource-group $RESOURCE_GROUP \
     --name $CLUSTER_NAME \
     --command "
   kubectl create namespace team1-apps --dry-run=client -o yaml | kubectl apply -f -
   kubectl label namespace team1-apps tenant=team1 --overwrite
   "
   

5. Vous pouvez maintenant répertorier les équilibreurs de charge dans le cluster pour afficher les plusieurs configurations à l’aide de la az aks loadbalancer list commande.

   az aks loadbalancer list --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --output table
   

   Exemple de sortie :

   AllowServicePlacement    ETag     Name        PrimaryAgentPoolName    ProvisioningState    ResourceGroup
   -----------------------  -------  ----------  ----------------------  -------------------  ---------------
   True                     <ETAG>   kubernetes  nodepool1               Succeeded            rg-aks-multislb
   True                     <ETAG>   team1-lb    team1pool               Succeeded            rg-aks-multislb
   

Déployer un service sur un équilibreur de charge spécifique

Ajoutez l’annotation service.beta.kubernetes.io/azure-load-balancer-configurations avec une liste séparée par des virgules de noms de configuration. Si l’annotation est omise, le contrôleur choisit automatiquement.

az aks command invoke \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --command "
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: lb-svc-1
  namespace: team1-apps
  labels:
    app: nginx-test
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-configurations: \"team1-lb\"
    # service.beta.kubernetes.io/azure-load-balancer-internal: "true" # If you want to create an internal load balancer. 
spec:
  selector:
    app: nginx-test
  ports:
  - name: port1
    port: 80
    targetPort: 80
    protocol: TCP
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-test
  namespace: team1-apps
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-test
  template:
    metadata:
      labels:
        app: nginx-test
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
        resources:
          limits:
            cpu: \"150m\"
            memory: \"300Mi\"
EOF
"

Rééquilibrer les nœuds (facultatif)

Exécutez une opération de rééquilibrage après la mise à l’échelle si le nombre de règles devient déséquilibré à l’aide de la az aks loadbalancer rebalance commande. Cette commande interrompt les flux actifs, donc planifiez-la pendant une fenêtre de maintenance.

az aks loadbalancer rebalance --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME

Surveillance et dépannage

• Observez les événements du contrôleur (kubectl get events …) pour vérifier que les services sont réconciliés.
• Si la connectivité externe est bloquée, ouvrez un interpréteur de commandes de nœud et bouclez l’adresse IP virtuelle du service pour confirmer le routage kube-proxy.

Limitations et problèmes connus

Nettoyer les ressources

Supprimez le groupe de ressources lorsque vous avez terminé de supprimer le cluster et les équilibreurs de charge à l’aide de la az group delete commande.

az group delete --name $RESOURCE_GROUP --yes --no-wait

Étapes suivantes

La fonctionnalité sLB multiple permet de mettre à l’échelle et d’isoler les charges de travail au niveau de la couche réseau tout en conservant la simplicité par le biais de la configuration gérée par Azure. Pour plus d’informations, consultez les ressources suivantes :

• Concepts d’AKS Load Balancer
• Configurer des connexions sortantes dans AKS
• Pools de nœuds AKS
• Limites d’abonnement Azure