Anthos Service Mesh 1.6

Ajouter des clusters à un maillage de services Anthos Service Mesh

Ce guide explique comment joindre deux clusters dans un seul maillage de services Anthos Service Mesh à l'aide de Mesh CA ou de Citadel, et comment activer l'équilibrage de charge interclusters. Vous pouvez facilement étendre ce processus pour intégrer autant de clusters que vous le souhaitez dans votre maillage.

Une configuration multicluster Anthos Service Mesh peut résoudre plusieurs scénarios d'entreprise essentiels, tels que l'échelle, l'emplacement et l'isolation. Pour en savoir plus, consultez la section Cas d'utilisation multicluster. En outre, vous devez optimiser vos applications pour tirer le meilleur parti d'un maillage de services. Pour en savoir plus, consultez la page Préparer une application pour Anthos Service Mesh.

Prérequis

Dans ce guide, nous partons du principe que vous disposez d'au moins deux clusters GKE Google Cloud répondant aux exigences suivantes :

  • Anthos Service Mesh version 1.6.8 ou supérieure est installé sur les clusters. Consultez la page Présentation de l'installation pour installer ou mettre à niveau les clusters vers la version requise.
  • Si vous joignez des clusters qui ne font pas partie du même projet, ils doivent être installés à l'aide du profil asm-gcp-multiproject et se trouver dans une configuration de VPC partagé sur le même réseau. En outre, nous vous recommandons de disposer d'un projet pour héberger le VPC partagé et de deux projets de service pour la création de clusters. Pour en savoir plus, consultez la page Configurer des clusters avec un VPC partagé.
  • Si vous utilisez l'autorité de certification Citadel, utilisez la même autorité de certification racine personnalisée pour les deux clusters.

Définir des variables de projet et de cluster

  1. Pour plus de commodité, définissez un dossier de travail. Il s'agit du dossier dans lequel vous avez téléchargé et extrait les fichiers Anthos Service Mesh à l'étape préalable (Préparer l'installation d'Anthos Service Mesh).

    export PROJECT_DIR=YOUR_WORKING_FOLDER
  2. Créez une variable de contexte pour chaque cluster. Le contexte est une chaîne constituée d'ID de projet de cluster, de noms de clusters et d'emplacements. Pour les valeurs d'emplacement, utilisez l'emplacement du cluster, par exemple us-west2-a. Dans cet exemple, un maillage contient déjà un cluster et vous y ajoutez un autre cluster : 

    export CTX_1=gke_CLUSTER_1_PROJECT_ID_CLUSTER_1_LOCATION_CLUSTER_1_NAME
    export CTX_2=gke_CLUSTER_2_PROJECT_ID_CLUSTER_2_LOCATION_CLUSTER_2_NAME

Configurer la découverte des points de terminaison entre les clusters

Configurez la découverte des points de terminaison pour l'équilibrage de charge interclusters à l'aide des commandes suivantes. Cette étape permet d'effectuer les tâches suivantes :

  • La commande istioctl crée un secret accordant l'accès au serveur de l'API Kube pour un cluster.
  • La commande kubectl applique le secret à un autre cluster afin que le second cluster puisse lire les points de terminaison de service à partir du premier.
istioctl x create-remote-secret --context=${CTX_1} --name=${CLUSTER_1_NAME} | \
  kubectl apply -f - --context=${CTX_2}
istioctl x create-remote-secret --context=${CTX_2} --name=${CLUSTER_2_NAME} | \
  kubectl apply -f - --context=${CTX_1}

Vérifier votre déploiement

Cette section explique comment déployer un exemple de service HelloWorld dans votre environnement multicluster pour vérifier que l'équilibrage de charge interclusters fonctionne.

Installer le service HelloWorld

Créez l'exemple d'espace de noms et la définition de service dans chaque cluster.

for CTX in ${CTX_1} ${CTX_2}
  do
    kubectl create --context=${CTX} namespace sample
    kubectl label --context=${CTX} namespace sample \
      istio-injection=enabled
    kubectl create --context=${CTX} \
      -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
      -l app=helloworld -n sample
  done

Déployer HelloWorld v1 et v2 sur chaque cluster

  1. Déployez HelloWorld v1 sur CLUSTER_1 et v2 sur CLUSTER_2, ce qui vous permet de vérifier ultérieurement l'équilibrage de charge interclusters :

    kubectl create --context=${CTX_1} \
      -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
      -l app=helloworld -l version=v1 -n sample
    kubectl create --context=${CTX_2} \
      -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
      -l app=helloworld -l version=v2 -n sample
  2. Vérifiez que HelloWorld v1 et v2 sont en cours d'exécution à l'aide des commandes suivantes. Vérifiez que le résultat ressemble à celui-ci :

    kubectl get pod --context=${CTX_1} -n sample
    NAME                            READY     STATUS    RESTARTS   AGE
    helloworld-v1-86f77cd7bd-cpxhv  2/2       Running   0          40s
    kubectl get pod --context=${CTX_2} -n sample
    NAME                            READY     STATUS    RESTARTS   AGE
    helloworld-v2-758dd55874-6x4t8  2/2       Running   0          40s

Déployer le service Sleep

  1. Déployez le service Sleep sur les deux clusters. Ce pod génère un trafic réseau artificiel à des fins de démonstration :

    for CTX in ${CTX_1} ${CTX_2}
      do
        kubectl apply --context=${CTX} \
          -f ${PROJECT_DIR}/samples/sleep/sleep.yaml -n sample
      done
  2. Attendez que le service Sleep démarre dans chaque cluster. Vérifiez que le résultat ressemble à celui-ci :

    kubectl get pod --context=${CTX_1} -n sample -l app=sleep
    NAME                             READY   STATUS    RESTARTS   AGE
    sleep-754684654f-n6bzf           2/2     Running   0          5s
    kubectl get pod --context=${CTX_2} -n sample -l app=sleep
    NAME                             READY   STATUS    RESTARTS   AGE
    sleep-754684654f-dzl9j           2/2     Running   0          5s

Vérifier l'équilibrage de charge interclusters

Appelez le service HelloWorld plusieurs fois et vérifiez le résultat pour vérifier l'alternance des réponses de v1 et v2 :

kubectl exec --context=${CTX_1} -it -n sample -c sleep \
   $(kubectl get pod --context=${CTX_1} -n sample -l \
   app=sleep -o jsonpath='{.items[0].metadata.name}') -- curl \
   helloworld.sample:5000/hello
Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...
kubectl exec --context=${CTX_2} -it -n sample -c sleep \
   $(kubectl get pod --context=${CTX_2} -n sample -l \
   app=sleep -o jsonpath='{.items[0].metadata.name}') -- curl \
   helloworld.sample:5000/hello

Vérifiez que le résultat ressemble à celui-ci :

Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...

Félicitations, vous avez vérifié votre équilibreur de charge multicluster déployé sur Anthos Service Mesh !

Nettoyer le service HelloWorld

Lorsque vous avez terminé la vérification de l'équilibrage de charge, supprimez les services HelloWorld et Sleep de votre cluster.

kubectl delete ns sample --context ${CTX_1}
kubectl delete ns sample --context ${CTX_2}