Créer un cluster GKE avec Cloud Service Mesh et gcloud CLI

Dans ce tutoriel, vous provisionnez Cloud Service Mesh géré à l'aide de l'API Fleet de Google Kubernetes Engine (GKE) sur un nouveau cluster public GKE. Ce tutoriel vous guide à travers les étapes suivantes :

  1. Configurer votre projet Google Cloud .
  2. Créer un cluster GKE avec le nombre minimal de processeurs virtuels requis par Cloud Service Mesh.
  3. Enregistrer le cluster GKE dans le parc de votre projet.
  4. Provisionner Cloud Service Mesh géré sur le cluster à l'aide de l'API Fleet.
  5. Déployer une passerelle d'entrée pour exposer l'application.
  6. Déployer un exemple d'application afin de pouvoir afficher les données de télémétrie sur les tableaux de bord Cloud Service Mesh dans la console Google Cloud .
  7. Exposer et accéder à l'exemple d'application.

API Fleet

Ce guide part du principe que vous connaissez les parcs, qui sont des regroupements logiques de clusters GKE et d'autres ressources pouvant être gérés ensemble. Un parc est un concept GKE, et non un concept Kubernetes. L'enregistrement d'un cluster dans un parc vous permet de provisionner Cloud Service Mesh géré sur ce cluster à l'aide de la commande gcloud container fleet mesh update. L'utilisation de parcs est rendue possible grâce à l'API Fleet (gkehub.googleapis.com) que vous activez lorsque vous commencez ce tutoriel.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce guide de démarrage rapide, vous pouvez éviter de continuer à payer des frais en supprimant le cluster. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

    8.
  8. Notez l'ID de votre projet.

    9. Installer les outils nécessaires

    Vous pouvez exécuter l'outil sur Cloud Shell ou sur votre machine locale. Cloud Shell préinstalle tous les outils requis.

    Cloud Shell

    Cloud Shell provisionne une machine virtuelle (VM) g1-small Compute Engine exécutant un système d'exploitation Linux basé sur Debian. Les avantages liés à l'utilisation de Cloud Shell sont les suivants :

    • Cloud Shell comprend gcloud, kubectl, git et les autres outils de ligne de commande dont vous avez besoin.

    • Votre répertoire Cloud Shell $HOME dispose d'un espace de stockage persistant de 5 Go.

    • Nous vous proposons plusieurs éditeurs de texte :

      • Éditeur de code, auquel vous accédez en cliquant sur en haut de la fenêtre Cloud Shell.

      • Emacs, Vim ou Nano, auxquels vous accédez depuis la ligne de commande dans Cloud Shell.

    In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    Ordinateur local

    1. Assurez-vous que les outils suivants sont installés :

    2. Authentifiez-vous avec Google Cloud CLI :

      gcloud auth login --project PROJECT_ID

    3. Mettez à jour les composants :

      gcloud components update

    Créer un cluster GKE

    1. Exécutez la commande suivante pour créer le cluster avec le nombre minimal de processeurs virtuels requis par Cloud Service Mesh. Dans la commande, remplacez les espaces réservés par les informations suivantes :

      • CLUSTER_NAME : nom du cluster Le nom ne peut contenir que des caractères alphanumériques minuscules et -, doit commencer par une lettre et se terminer par un caractère alphanumérique, et ne doit pas comporter plus de 40 caractères.
      • PROJECT_ID : ID du projet dans lequel le cluster sera créé.
      • CLUSTER_LOCATION : zone du cluster, par exemple us-central1-a.
      gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --workload-pool=PROJECT_ID.svc.id.goog

      La création du cluster prend quelques minutes. Pendant la création du cluster, la commande gcloud affiche les éléments suivants :

      Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...working...

      Le résultat attendu lors d'une création réussie ressemble à ce qui suit :

      Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/CLUSTER_LOCATION/CLUSTER_NAME?project=PROJECT_ID
kubeconfig entry generated for CLUSTER_NAME.
NAME: CLUSTER_NAME
LOCATION: CLUSTER_LOCATION
MASTER_VERSION: 1.20.10-gke.1600
MASTER_IP: 198.51.100.1
MACHINE_TYPE: e2-standard-4
NODE_VERSION: 1.20.10-gke.1600
NUM_NODES: 2
STATUS: RUNNING

    2. Obtenez des identifiants d'authentification pour interagir avec le cluster.

      gcloud container clusters get-credentials CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION

      Résultat attendu :

      Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.

    3. Définissez le contexte actuel de kubectl sur le cluster.

      kubectl config set-context CLUSTER_NAME

      Résultat attendu :

      Context "CLUSTER_NAME" created.

    Provisionner Cloud Service Mesh

    Si vous n'avez pas fermé cette page depuis la création du cluster, les espaces réservés contiennent les valeurs que vous avez saisies pour la commande gcloud container clusters create.

    1. Activez Cloud Service Mesh sur le parc de votre projet.

      gcloud container fleet mesh enable --project PROJECT_ID

      Le résultat est semblable à :

      Waiting for Feature Service Mesh to be created...done.

    2. Enregistrez le cluster dans le parc du projet :

      gcloud container fleet memberships register CLUSTER_NAME-membership \
  --gke-cluster=CLUSTER_LOCATION/CLUSTER_NAME \
  --enable-workload-identity \
  --project PROJECT_ID

      Le résultat est semblable à :

       Waiting for membership to be created...done.
 Finished registering to the Fleet.

    3. Provisionnez Cloud Service Mesh géré sur le cluster à l'aide de l'API Fleet :

      gcloud container fleet mesh update \
  --management automatic \
  --memberships CLUSTER_NAME-membership \
  --project PROJECT_ID

      Le résultat est semblable à :

      Waiting for Feature Service Mesh to be updated...done.

    4. Vérifiez que Cloud Service Mesh géré a été activé pour le cluster et qu'il est prêt à être utilisé :

      gcloud container fleet mesh describe --project PROJECT_ID

      Il peut s'écouler environ 10 minutes avant que Cloud Service Mesh ne soit provisionné et prêt à être utilisé sur le cluster. Si controlPlaneManagement.state: DISABLED ou controlPlaneManagement.state: PROVISIONING s'affiche, vous devez relancer la commande précédente toutes les deux ou trois minutes jusqu'à ce que controlPlaneManagement.state: ACTIVE s'affiche.

      Le résultat est semblable à :

      createTime: '2022-07-06T01:05:39.110120474Z'
membershipSpecs:
  projects/123456789123/locations/global/memberships/your-cluster-membership:
    mesh:
      management: MANAGEMENT_AUTOMATIC
membershipStates:
  projects/123456789123/locations/global/memberships/your-cluster-membership:
    servicemesh:
      controlPlaneManagement:
        details:
        - code: REVISION_READY
          details: 'Ready: asm-managed'
        state: ACTIVE
      dataPlaneManagement:
        details:
        - code: OK
          details: Service is running.
        state: ACTIVE
    state:
      code: OK
      description: 'Revision(s) ready for use: asm-managed.'
      updateTime: '2022-07-06T01:19:24.243993678Z'
name: projects/your-project-id/locations/global/features/servicemesh
resourceState:
  state: ACTIVE
spec: {}
state:
  state: {}
updateTime: '2022-07-06T01:19:27.475885687Z'

    Télécharger l'exemple de code

    Clonez le dépôt git contenant l'exemple de code utilisé dans ce tutoriel :

       git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git

    Les sections suivantes de ce tutoriel utilisent une variable DIR_PATH. Définissez cette variable sur le chemin du dépôt anthos-service-mesh-packages que vous avez cloné (par exemple, ./anthos-service-mesh-packages).

    Déployer une passerelle d'entrée

    Cloud Service Mesh vous permet de déployer et de gérer des passerelles avec votre maillage de services. Une passerelle décrit un équilibreur de charge fonctionnant à la périphérie du réseau maillé recevant des connexions HTTP/TCP entrantes ou sortantes. Les passerelles sont des proxys Envoy qui vous permettent de contrôler avec précision le trafic entrant et sortant du réseau maillé.

    1. Créez un espace de noms pour la passerelle d'entrée si vous n'en possédez pas déjà un. Les passerelles sont des charges de travail d'utilisateur. Il est déconseillé de les déployer dans l'espace de noms du plan de contrôle. Remplacez GATEWAY_NAMESPACE par le nom de votre espace de noms.

      kubectl create namespace GATEWAY_NAMESPACE

      Résultat attendu :

      namespace/GATEWAY_NAMESPACE created

    2. Activez l'injection automatique sur la passerelle. Les étapes requises varient selon que vous souhaitez utiliser des libellés d'injection par défaut (par exemple, istio-injection=enabled) ou le libellé de révision sur l'espace de noms de la passerelle. Le tag de révision et le libellé de révision par défaut sont utilisés par le webhook d'injecteur side-car pour associer les proxys injectés à une révision spécifique du plan de contrôle.

      Libellés d'injection par défaut

      Appliquez les libellés d'injection par défaut à l'espace de noms.

      kubectl label namespace GATEWAY_NAMESPACE istio-injection=enabled istio.io/rev-

      Libellé de révision

      1. Exécutez la commande suivante pour localiser le libellé de révision sur istiod :

        kubectl get deploy -n istio-system -l app=istiod -o \
  "jsonpath={.items[*].metadata.labels['istio\.io/rev']}{'\n'}"

        La commande génère le libellé de révision correspondant à la version de Cloud Service Mesh, par exemple : asm-11910-9

      2. Appliquez le libellé de révision à l'espace de noms. Dans la commande suivante, REVISION correspond à la valeur du libellé de révision istiod que vous avez notée à l'étape précédente.

        kubectl label namespace GATEWAY_NAMESPACE \
  istio.io/rev=REVISION --overwrite

        Résultat attendu :

        namespace/GATEWAY_NAMESPACE labeled

      Vous pouvez ignorer le message "istio.io/rev" not found dans le résultat. Cela signifie que l'espace de noms ne portait pas précédemment le libellé istio.io/rev, auquel on s'attend dans de nouvelles installations de Cloud Service Mesh ou de nouveaux déploiements. Étant donné que l'injection automatique échoue si un espace de noms possède à la fois le libellé istio.io/rev et le libellé istio-injection, toutes les commandes kubectl label de la documentation Cloud Service Mesh spécifient explicitement les deux libellés.

      Si l'espace de noms de la passerelle n'est pas libellé, les pods istio-ingressgateway échoueront avec une erreur ImagePullBackOff lorsque la passerelle tentera d'extraire l'image auto. Cette image doit être remplacée par le webhook.

    3. Téléchargez l'exemple de fichier de configuration .yaml de la passerelle d'entrée depuis le dépôt anthos-service-mesh-packages.

    4. Appliquez l'exemple de configuration .yaml de passerelle d'entrée tel quel ou modifiez-le si nécessaire.

      kubectl apply -n GATEWAY_NAMESPACE \
  -f CONFIG_PATH/istio-ingressgateway

      Résultat attendu :

      deployment.apps/istio-ingressgateway created
poddisruptionbudget.policy/istio-ingressgateway created
horizontalpodautoscaler.autoscaling/istio-ingressgateway created
role.rbac.authorization.k8s.io/istio-ingressgateway created
rolebinding.rbac.authorization.k8s.io/istio-ingressgateway created
service/istio-ingressgateway created
serviceaccount/istio-ingressgateway created

    Découvrez les bonnes pratiques liées aux passerelles.

    Déployer l'exemple de boutique en ligne

    L'exemple d'application Online Boutique du dépôt anthos-service-mesh-packages est modifié à partir de l'ensemble de fichiers manifestes d'origine dans le dépôt microservices-demo. Conformément aux bonnes pratiques, chaque service est déployé dans un espace de noms distinct avec un compte de service unique.

    1. Créez les espaces de noms pour l'application :

      kubectl apply -f \
  DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces

      Résultat attendu :

      namespace/ad created
namespace/cart created
namespace/checkout created
namespace/currency created
namespace/email created
namespace/frontend created
namespace/loadgenerator created
namespace/payment created
namespace/product-catalog created
namespace/recommendation created
namespace/shipping created

    2. Activez l'injection side-car automatique (injection automatique). La commande requise varie selon que vous souhaitez utiliser des libellés d'injection par défaut (par exemple, istio-injection=enabled) ou le même libellé de révision que vous avez utilisé pour annoter l'espace de noms de la passerelle d'entrée.

      Libellés d'injection par défaut

      Appliquez les libellés d'injection par défaut à l'espace de noms. Dans la commande suivante, GATEWAY_NAMESPACE est la même valeur que celle que vous avez utilisée pour annoter l'espace de noms de la passerelle d'entrée.

      for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
  kubectl label namespace $ns istio-injection=enabled istio.io/rev-
done;

      Résultat attendu :

      namespace/ad labeled
namespace/cart labeled
namespace/checkout labeled
namespace/currency labeled
namespace/email labeled
namespace/frontend labeled
namespace/loadgenerator labeled
namespace/payment labeled
namespace/product-catalog labeled
namespace/recommendation labeled
namespace/shipping labeled

      Libellé de révision

      Appliquez le libellé de révision aux espaces de noms de l'application. Dans la commande suivante, REVISION est la même valeur que celle que vous avez utilisée pour annoter l'espace de noms de la passerelle d'entrée.

      for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
  kubectl label namespace $ns istio.io/rev=REVISION --overwrite
done;

      Résultat attendu :

      namespace/ad labeled
namespace/cart labeled
namespace/checkout labeled
namespace/currency labeled
namespace/email labeled
namespace/frontend labeled
namespace/loadgenerator labeled
namespace/payment labeled
namespace/product-catalog labeled
namespace/recommendation labeled
namespace/shipping labeled

    3. Déployez l'exemple d'application sur le cluster.

      1. Créez les comptes de service et les déploiements :

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/kubernetes-manifests/deployments

        Résultat attendu :

        serviceaccount/ad created
deployment.apps/adservice created
serviceaccount/cart created
deployment.apps/cartservice created
serviceaccount/checkout created
deployment.apps/checkoutservice created
serviceaccount/currency created
deployment.apps/currencyservice created
serviceaccount/email created
deployment.apps/emailservice created
serviceaccount/frontend created
deployment.apps/frontend created
serviceaccount/loadgenerator created
deployment.apps/loadgenerator created
serviceaccount/payment created
deployment.apps/paymentservice created
serviceaccount/product-catalog created
deployment.apps/productcatalogservice created
serviceaccount/recommendation created
deployment.apps/recommendationservice created
serviceaccount/shipping created
deployment.apps/shippingservice created

      2. Créez les services :

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/kubernetes-manifests/services

        Résultat attendu :

        service/adservice created
service/cartservice created
service/checkoutservice created
service/currencyservice created
service/emailservice created
service/frontend created
service/frontend-external created
service/paymentservice created
service/productcatalogservice created
service/recommendationservice created
service/shippingservice created

      3. Créez les entrées de service :

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml

        Résultat attendu :

        serviceentry.networking.istio.io/allow-egress-googleapis created
serviceentry.networking.istio.io/allow-egress-google-metadata created

    Exposer l'application et y accéder

    Il existe plusieurs façons d'exposer l'application. Pour ce faire, nous utiliserons dans ce guide la passerelle d'entrée que nous avons déployée ci-dessus. Pour découvrir d'autres moyens d'exposer l'application Online Boutique, consultez la section Exposer l'application et y accéder dans le guide de déploiement de l'exemple d'application Online Boutique.

    1. Déployez Gateway et VirtualService pour le service d'interface.

      kubectl apply -f \
    DIR_PATH/samples/online-boutique/istio-manifests/frontend-gateway.yaml

      Résultat attendu :

      gateway.networking.istio.io/frontend-gateway created
virtualservice.networking.istio.io/frontend-ingress created

    2. Obtenez l'adresse IP externe de la passerelle d'entrée, en remplaçant les espaces réservés par les informations suivantes :

      • GATEWAY_SERVICE_NAME : nom du service de passerelle d'entrée. Si vous avez déployé l'exemple de passerelle sans modification, la valeur est istio-ingressgateway.
      • GATEWAY_NAMESPACE : espace de noms dans lequel vous avez déployé la passerelle d'entrée :
      kubectl get service GATEWAY_SERVICE_NAME \
    -n GATEWAY_NAMESPACE

      Le résultat est semblable à :

      NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

      Dans cet exemple, l'adresse IP de la passerelle d'entrée est 35.239.7.64.

    3. Accédez à l'application dans votre navigateur pour confirmer l'installation :

      http://EXTERNAL_IP/

    Afficher les tableaux de bord de Service Mesh

    Une fois que les charges de travail sont déployées sur votre cluster et que les proxys side-car ont été injectés, vous pouvez explorer les pages Cloud Service Mesh de la console Google Cloud pour consulter toutes les fonctionnalités d'observabilité offertes par Cloud Service Mesh. Notez qu'il faut environ une à deux minutes pour que les données de télémétrie soient affichées dans la consoleGoogle Cloud après le déploiement des charges de travail.

    L'accès à Cloud Service Mesh dans la console Google Cloud est contrôlé par la gestion de l'authentification et des accès (IAM). Pour permettre l'accès aux pages Cloud Service Mesh, un Propriétaire du projet doit accorder aux utilisateurs le rôle éditeur ou lecteur de projet, ou les rôles plus restrictifs décrits dans la section Contrôler l'accès à Cloud Service Mesh dans la console Google Cloud .

    1. Dans la console Google Cloud , accédez à Cloud Service Mesh.

      Accéder à Cloud Service Mesh

    2. Sélectionnez le projet Google Cloud dans la liste déroulante de la barre de menu.

    3. Si vous avez plusieurs maillages de services, sélectionnez le maillage dans la liste déroulante Maillage de services.

    Pour en savoir plus, consultez Explorer Cloud Service Mesh dans la console Google Cloud .

    Effectuer un nettoyage

    Avant de procéder au nettoyage, si vous souhaitez en savoir plus sur l'authentification TLS mutuelle, consultez la section Exemple Cloud Service Mesh : mTLS.

    • Si vous souhaitez conserver votre cluster et supprimer l'exemple de boutique en ligne, procédez comme suit :

      1. Supprimez les espaces de noms de l'application :

        kubectl delete -f DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces

        Résultat attendu :

        namespace "ad" deleted
namespace "cart" deleted
namespace "checkout" deleted
namespace "currency" deleted
namespace "email" deleted
namespace "frontend" deleted
namespace "loadgenerator" deleted
namespace "payment" deleted
namespace "product-catalog" deleted
namespace "recommendation" deleted
namespace "shipping" deleted

      2. Supprimez les entrées de service :

        kubectl delete -f DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml

        Résultat attendu :

        serviceentry.networking.istio.io "allow-egress-googleapis" deleted
serviceentry.networking.istio.io "allow-egress-google-metadata" deleted

    • Si vous souhaitez éviter des frais supplémentaires, supprimez le cluster :

      1. Exécutez la commande suivante :

        gcloud container clusters delete CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION

      2. Lorsque l'invite Do you want to continue (Y/N)? (Voulez-vous continuer (O/N) ?) s'affiche, saisissez y.

        Après quelques minutes, le résultat suivant s'affiche :

        Deleting cluster CLUSTER_NAME...done.
Deleted [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].

    Étapes suivantes