Configurer l’équilibrage de charge multi-cluster de couche 4 sur les clusters membres Azure Kubernetes Fleet Manager (préversion)

Pour les applications déployées sur plusieurs clusters, les administrateurs veulent souvent router le trafic entrant vers ceux-ci entre les clusters.

Vous pouvez suivre ce document pour configurer l’équilibrage de charge de couche 4 pour ces applications multiclusters.

Important

Les fonctionnalités d’évaluation d’Azure Kubernetes Fleet Manager sont disponibles en libre-service et font l’objet d’un abonnement. Les préversions sont fournies « en l’état » et « en fonction des disponibilités », et sont exclues des contrats de niveau de service et de la garantie limitée. Les préversions d’Azure Kubernetes Fleet Manager sont, dans la mesure du possible, partiellement couvertes par le service clientèle. Telles quelles, ces fonctionnalités ne sont pas destinées à une utilisation en production.

Prérequis

Si vous ne disposez pas d’un compte Azure, créez-en un gratuitement avant de commencer.

Lisez la vue d’ensemble des concepts de cette fonctionnalité, qui fournit une explication des objets ServiceExport et MultiClusterService référencés dans ce document.
Vous devez avoir une ressource Fleet avec un cluster hub et des clusters membres. Si vous n’avez pas cette ressource, suivez le guide de Démarrage rapide : Créer une ressource Fleet et joindre des clusters membres.
Les clusters Azure Kubernetes Service (AKS) cibles sur lesquels les charges de travail sont déployées doivent être présents sur le même réseau virtuel ou sur des réseaux virtuels appairés.
- Ces clusters cibles doivent être ajoutés en tant que clusters membres à la ressource Fleet.
- Ces clusters cibles doivent utiliser la mise en réseau Azure CNI (Container Networking Interface).
Vous devez pouvoir accéder à l’API Kubernetes du cluster hub en suivant les étapes décrites dans Accéder à l’API Kubernetes du cluster hub Fleet.

Définissez les variables d’environnement suivantes et obtenez les kubeconfigs pour la flotte et tous les clusters membres :

export GROUP=<resource-group>
export FLEET=<fleet-name>
export MEMBER_CLUSTER_1=aks-member-1
export MEMBER_CLUSTER_2=aks-member-2

az fleet get-credentials --resource-group ${GROUP} --name ${FLEET} --file fleet

az aks get-credentials --resource-group ${GROUP} --name ${MEMBER_CLUSTER_1} --file aks-member-1

az aks get-credentials --resource-group ${GROUP} --name ${MEMBER_CLUSTER_2} --file aks-member-2

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour obtenir plus d’informations, consultez Démarrage d’Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez S’authentifier auprès d’Azure à l’aide d’Azure CLI.
- Quand vous y êtes invité, installez l’extension Azure CLI à la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Déployer une charge de travail sur des clusters membres de la ressource Fleet

Remarque

Les étapes décrites dans ce guide pratique font référence à un exemple d’application à des fins de démonstration uniquement. Vous pouvez remplacer cette charge de travail par l’un de vos propres objets de déploiement et de service existants.
Ces étapes déploient l’exemple de charge de travail du cluster Fleet sur des clusters membres à l’aide de la propagation de la configuration Kubernetes. Vous pouvez également choisir de déployer ces configurations Kubernetes sur chaque cluster membre séparément.

Créez un espace de noms sur le cluster de flotte :
```
KUBECONFIG=fleet kubectl create namespace kuard-demo
```
La sortie ressemble à l’exemple suivant :
```
namespace/kuard-demo created
```
Appliquez les objets Deployment, Service et ServiceExport :
```
KUBECONFIG=fleet kubectl apply -f https://raw.githubusercontent.com/Azure/AKS/master/examples/fleet/kuard/kuard-export-service.yaml
```
La spécification ServiceExport du fichier ci-dessus vous permet d’exporter un service à partir de clusters membres vers la ressource Fleet. Une fois l’exportation réussie, le service et tous ses points de terminaison sont synchronisés avec le cluster Fleet, et ils peuvent ensuite être utilisés pour configurer l’équilibrage de charge multicluster entre ces points de terminaison. Le résultat ressemble à l’exemple qui suit :
```
deployment.apps/kuard created
service/kuard created
serviceexport.networking.fleet.azure.com/kuard created
```

Créez les éléments suivants ClusterResourcePlacement dans un fichier appelé crp-2.yaml. Notez que nous sélectionnons des clusters dans la région eastus :

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: kuard-demo
spec:
  resourceSelectors:
    - group: ""
      version: v1
      kind: Namespace
      name: kuard-demo
  policy:
    affinity:
      clusterAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  fleet.azure.com/location: eastus

Appliquez ClusterResourcePlacement :

KUBECONFIG=fleet kubectl apply -f crp-2.yaml

En cas de réussite, la sortie est similaire à l’exemple suivant :

clusterresourceplacement.placement.kubernetes-fleet.io/kuard-demo created

Vérifiez l'état de ClusterResourcePlacement :

KUBECONFIG=fleet kubectl get clusterresourceplacements

En cas de réussite, la sortie est similaire à l’exemple suivant :

NAME            GEN   SCHEDULED   SCHEDULEDGEN   APPLIED   APPLIEDGEN   AGE
kuard-demo      1     True        1              True      1            20s

Créer MultiClusterService pour équilibrer la charge entre les points de terminaison de service dans plusieurs clusters membres

Vérifiez si le service a été exporté avec succès pour les clusters membres de la région eastus :
```
KUBECONFIG=aks-member-1 kubectl get serviceexport kuard --namespace kuard-demo
```
La sortie ressemble à l’exemple suivant :
```
NAME    IS-VALID   IS-CONFLICTED   AGE
kuard   True       False           25s
```
```
KUBECONFIG=aks-member-2 kubectl get serviceexport kuard --namespace kuard-demo
```
La sortie ressemble à l’exemple suivant :
```
NAME    IS-VALID   IS-CONFLICTED   AGE
kuard   True       False           55s
```
Vous devez voir que le service est valide pour l’exportation (le champ IS-VALID est true) et n’a aucun conflit avec d’autres exportations (IS-CONFLICT est false).

Remarque

La propagation de ServiceExport peut prendre une ou deux minutes.

Créez un MultiClusterService sur un membre pour équilibrer la charge entre les points de terminaison de service dans ces clusters :

KUBECONFIG=aks-member-1 kubectl apply -f https://raw.githubusercontent.com/Azure/AKS/master/examples/fleet/kuard/kuard-mcs.yaml

Remarque

Pour exposer le service via l’adresse IP interne au lieu d’une adresse IP publique, ajoutez l’annotation au MultiClusterService :

apiVersion: networking.fleet.azure.com/v1alpha1
kind: MultiClusterService
metadata:
  name: kuard
  namespace: kuard-demo
  annotations:
     networking.fleet.azure.com/azure-load-balancer-internal: "true"
  ...

La sortie ressemble à l’exemple suivant :

multiclusterservice.networking.fleet.azure.com/kuard created

Vérifiez que MultiClusterService est valide en exécutant la commande suivante :
```
KUBECONFIG=aks-member-1 kubectl get multiclusterservice kuard --namespace kuard-demo
```
Vous devez obtenir un résultat semblable à l’exemple qui suit :
```
NAME    SERVICE-IMPORT   EXTERNAL-IP     IS-VALID   AGE
kuard   kuard            <a.b.c.d>       True       40s
```
Le champ IS-VALID doit être true dans la sortie. Consultez l’adresse IP de l’équilibreur de charge externe (EXTERNAL-IP) dans la sortie. L’importation peut prendre un certain temps avant qu’elle ne soit entièrement traitée et que l’adresse IP soit disponible.
Exécutez la commande suivante plusieurs fois en utilisant l’adresse IP de l’équilibreur de charge externe :
```
curl <a.b.c.d>:8080 | grep addrs 
```
Notez que les adresses IP des pods qui servent la demande changent et que ces pods proviennent de clusters membres aks-member-1 et aks-member-2 de la région eastus. Vous pouvez vérifier les adresses IP de pod en exécutant les commandes suivantes sur les clusters à partir de la région eastus :
```
KUBECONFIG=aks-member-1 kubectl get pods -n kuard-demo -o wide
```
```
KUBECONFIG=aks-member-2 kubectl get pods -n kuard-demo -o wide
```

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-09-29