Guide de démarrage rapide d'Anthos Service Mesh pour GKE

Dans ce tutoriel, vous installez Anthos Service Mesh 1.11.8-asm.4 à l'aide d'un outil fourni par Google, asmcli, sur un nouveau cluster Google Kubernetes Engine (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 Anthos Service Mesh.
  3. Installer Anthos Service Mesh avec un plan de contrôle intégré au cluster.
  4. Déployer un exemple d'application afin de pouvoir afficher les données de télémétrie sur les tableaux de bord d'Anthos Service Mesh dans la console Google Cloud.
  5. Exposer et accéder à l'exemple d'application.

Pour simplifier le démarrage rapide et ne pas avoir plusieurs chemins différents, les choix suivants ont été effectués :

  1. Activer l'autorité de certification Anthos Service Mesh
  2. Déployer une passerelle d'entrée pour exposer l'application

Coûts

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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du 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. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  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 Kubernetes Engine API.

    Enable the API

  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 Kubernetes Engine API.

    Enable the API

  8. Notez l'ID de votre projet.

Bien qu'Anthos Service Mesh nécessite d'autres API, asmcli les active pour vous. Afin de limiter les coûts de facturation, le script asmcli n'active pas l'API GKE Enterprise. Il existe des différences mineures dans la console Google Cloud lorsque l'API GKE Enterprise est activée. Pour en savoir plus sur ces différences, consultez la section Différences entre les interfaces utilisateur de GKE Enterprise et d'Anthos Service Mesh.

Installer les outils nécessaires

Vous pouvez exécuter l'outil sur Cloud Shell ou sur votre ordinateur local exécutant Linux. Cloud Shell préinstalle tous les outils requis. Notez que macOS n'est pas compatible, car il est fourni avec une ancienne version de bash.

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, kpt 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.

Pour utiliser Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.
  2. Sélectionnez votre projet Google Cloud.
  3. Cliquez sur le bouton Activer Cloud Shell en haut de la fenêtre de la console Google Cloud.

    Console Google Cloud Platform

    Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console Google Cloud et affiche une invite de ligne de commande.

    Session Cloud Shell

Ordinateur Linux local

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

  2. Authentifiez-vous en utilisant gcloud CLI :

    gcloud auth login
    
  3. Mettez à jour les composants :

    gcloud components update
    
  4. Assurez-vous que git se trouve dans votre chemin pour que kpt puisse le trouver.

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

Télécharger asmcli

Cette section explique comment télécharger le asmcli.

  1. Téléchargez la version qui installe Anthos Service Mesh 1.11.8 dans le répertoire de travail actuel :

    curl https://storage.googleapis.com/csm-artifacts/asm/asmcli_1.11 > asmcli
    

    Résultat attendu :

    % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
    100  167k  100  167k    0     0   701k      0 --:--:-- --:--:-- --:--:--  701k
    
  2. Rendez le script exécutable :

    chmod +x asmcli
    

Installer Anthos Service Mesh

Exécutez l'outil asmcli avec les options suivantes pour installer Anthos Service Mesh sur le cluster que vous avez créé précédemment. 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.

./asmcli install \
  --project_id PROJECT_ID \
  --cluster_name CLUSTER_NAME \
  --cluster_location CLUSTER_LOCATION \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all  \
  --ca mesh_ca
  • --project_id, --cluster_name et --cluster_location : spécifiez l'ID du projet dans lequel se trouve le cluster, son nom, ainsi que la zone ou la région du cluster.
  • --fleet_id : ID du projet du projet hôte du parc. Si vous n'incluez pas cette option, asmcli utilise le projet dans lequel le cluster a été créé lors de son enregistrement.
  • --output_dir : incluez cette option pour spécifier un répertoire dans lequel asmcli télécharge le package anthos-service-mesh et extrait le fichier d'installation, qui contient istioctl, des exemples et des fichiers manifestes. Sinon, asmcli télécharge les fichiers dans un répertoire tmp. Vous pouvez spécifier un chemin d'accès relatif ou complet. La variable d'environnement $PWD ne fonctionne pas ici.
  • --enable_all : permet au script d'effectuer les opérations suivantes :
    • Accorder les autorisations IAM requises.
    • Activer les API Google requises.
    • Définir un libellé sur le cluster qui identifie le réseau maillé.
    • Enregistrer le cluster dans le parc si ce n'est déjà fait.

    L'exécution de l'outil asmcli peut prendre plusieurs minutes. L'outil génère des messages d'information pour que vous puissiez suivre sa progression.

    Résultat attendu pour une installation réussie :

    asmcli: Successfully installed ASM.
    

    Déployer une passerelle d'entrée

    Anthos 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 en appliquant un libellé de révision sur l'espace de noms de la passerelle. Le libellé de révision est utilisé par le webhook d'injecteur side-car pour associer les proxys injectés à une révision du plan de contrôle particulière.

      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 d'Anthos Service Mesh, par exemple : asm-1118-4

      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
        
    3. Vous pouvez déployer l'exemple de configuration de passerelle d'entrée situé dans le répertoire samples/gateways/istio-ingressgateway/ ou le modifier si nécessaire.

      kubectl apply -n GATEWAY_NAMESPACE \
        -f DIR_PATH/samples/gateways/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). Le libellé de révision utilisé ici est le même que celui qui est utilisé pour annoter l'espace de noms de la passerelle d'entrée. 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 Anthos Service Mesh de la console Google Cloud pour consulter toutes les fonctionnalités d'observabilité offertes par Anthos 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 console Google Cloud après le déploiement des charges de travail.

    L'accès à Anthos Service Mesh dans la console Google Cloud est contrôlé par IAM (Identity and Access Management). Pour permettre l'accès aux pages Anthos Service Mesh, un propriétaire de 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 à Anthos Service Mesh dans la console Google Cloud.

    1. Dans Google Cloud Console, accédez à Anthos Service Mesh.

      Accéder à Anthos 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 la page Explorer Anthos 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 Anthos 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

    En savoir plus :