Faciliter votre migration avec le déploiement du maillage de services Istio : tutoriel

Ce tutoriel explique comment initialiser et configurer un maillage de services pour effectuer une migration fonctionnalité par fonctionnalité d'un centre de données sur site (ancien) vers Google Cloud Platform (GCP). Le tutoriel et l'article conceptuel associé sont destinés aux administrateurs système, aux développeurs et aux ingénieurs qui souhaitent utiliser un maillage de services pour le routage dynamique du trafic vers l'ancien environnement ou vers GCP.

Un maillage de services peut considérablement réduire la complexité de l'opération de migration et de l'effort de refactorisation, car il dissocie les fonctions réseau des fonctions des services. Il réduit également la complexité opérationnelle du réseau, car il fournit des fonctions d'équilibrage de charge, de gestion du trafic, de surveillance et d'observabilité.

Le schéma suivant montre comment utiliser un maillage de services pour acheminer le trafic vers des microservices s'exécutant dans l'ancien environnement ou vers GCP :

Utiliser un maillage de services pour acheminer le trafic vers des microservices s'exécutant dans l'ancien environnement ou vers GCP

Dans ce tutoriel, vous utiliserez les logiciels suivants :

  • Ubuntu Server et Container-Optimized OS : systèmes d'exploitation utilisés dans ce tutoriel
  • Docker Community Edition : plate-forme pour exécuter des charges de travail en conteneurs
  • Docker Compose : un outil pour définir et exécuter des applications Docker
  • Helm : un outil pour installer et gérer l'application Kubernetes
  • Istio : un maillage de services Open Source
  • Kiali : un outil pour visualiser les maillages de services Istio
  • Envoy : proxy side-car utilisé lors de la connexion au maillage de services Istio

Objectifs

  • Initialiser un environnement qui simule le centre de données sur site
  • Déployer des exemples de charges de travail sur le centre de données sur site
  • Tester les charges de travail exécutées dans le centre de données sur site
  • Configurer l'environnement de destination sur GCP
  • Migrer la charge de travail du centre de données sur site vers l'environnement de destination
  • Tester les charges de travail s'exécutant dans l'environnement de destination
  • Supprimer le centre de données sur site

Coûts

Ce tutoriel utilise des composants facturables de GCP, y compris :

Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. Activez Compute Engine and GKEles API requises.

    Activer les API.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Préparer votre environnement

Vous exécuterez la plupart des étapes de ce tutoriel dans Cloud Shell.

  1. Ouvrez Cloud Shell :

    OUVRIR Cloud Shell

  2. Passez au répertoire de travail $HOME.

    cd "$HOME"
    
  3. Clonez le dépôt Git, qui contient les scripts et les fichiers manifestes pour déployer et configurer l'application de démonstration :

    git clone https://github.com/GoogleCloudPlatform/solutions-istio-mesh-expansion-migration
    
  4. Définissez la région et la zone par défaut :

    gcloud config set compute/region us-east1
    gcloud config set compute/zone us-east1-b
    
  5. Initialisez une variable d'environnement qui stocke l'identifiant de la version Istio :

    export ISTIO_VERSION=1.1.1
    
  6. Téléchargez et extrayez Istio :

    wget https://github.com/istio/istio/releases/download/"$ISTIO_VERSION"/istio-"$ISTIO_VERSION"-linux.tar.gz
    tar -xvzf istio-"$ISTIO_VERSION"-linux.tar.gz
    
  7. Initialisez les variables d'environnement qui stockent le chemin d'accès où vous avez extrait Istio, l'identifiant de la version Helm et le chemin d'accès où vous extrayez Helm :

    ISTIO_PATH="$HOME"/istio-"$ISTIO_VERSION"
    HELM_VERSION=v2.13.0
    HELM_PATH="$HOME"/helm-"$HELM_VERSION"
    
  8. Téléchargez et extrayez Helm :

    wget https://storage.googleapis.com/kubernetes-helm/helm-"$HELM_VERSION"-linux-amd64.tar.gz
    tar -xvzf helm-"$HELM_VERSION"-linux-amd64.tar.gz
    mv linux-amd64 "$HELM_PATH"
    

Exemple de charge de travail

Dans ce tutoriel, vous utilisez l'application Bookinfo, une application de microservices polyglotte à quatre niveaux qui présente des informations sur des livres. Cette application est conçue pour être exécutée sur Kubernetes, mais vous devez d'abord la déployer sur une instance Compute Engine à l'aide de Docker et Docker Compose. Avec Docker Compose, vous décrivez des applications multiconteneurs à l'aide de descripteurs YAML. Vous pouvez ensuite démarrer l'application en exécutant une seule commande.

Bien que cet exemple de charge de travail soit déjà conteneurisé, cette approche s'applique également aux services qui ne sont pas conteneurisés. Dans de tels cas, vous pouvez ajouter une "phase de modernisation" au cours de laquelle vous conteneurisez les services que vous souhaitez migrer.

L'application Bookinfo comporte quatre composants de microservices :

  • productpage : appelle les microservices details , ratings et reviews pour remplir la page d'informations sur le livre
  • details : diffuse des informations sur les livres
  • reviews : contient des critiques de livres
  • ratings : renvoie les informations de classement des livres pour accompagner une critique de livre

Configurer les environnements

La première étape consiste à configurer les environnements dont vous avez besoin pour ce tutoriel :

  • Un environnement simulant le centre de données sur site (ancien)
  • Un environnement simulant la destination de la migration

L'objectif de ce tutoriel est de vous aider à migrer d'un environnement non-GCP (tel qu'un centre de données sur site ou un autre fournisseur cloud) vers GCP. Ces migrations comportent une couche de complexité réseau car vous devez configurer un canal de communication sécurisé entre l'environnement non-GCP et celui de GCP.

Pour ce tutoriel, les deux environnements sont exécutés dans GCP. Cela simplifie le processus d'installation car une seule phase d'amorçage est requise.

Provisionner l'ancien environnement

Dans cette section, vous configurez un environnement GCP pour émuler un environnement distinct non-GCP en initialisant les instances Compute Engine et en déployant les charges de travail à migrer. Le schéma suivant illustre l'architecture cible de l'ancien environnement :

Architecture pour provisionner l'ancien environnement

Créer des règles de pare-feu

Créez des règles de pare-feu pour autoriser l'accès externe aux microservices et à la base de données.

  • Dans Cloud Shell, créez les règles de pare-feu requises pour les communications entre les nœuds :

    gcloud compute firewall-rules create bookinfo \
        --description="Bookinfo App rules" \
        --action=ALLOW \
        --rules=tcp:9080,tcp:9081,tcp:9082,tcp:9083,tcp:9084 \
        --target-tags=bookinfo-legacy-vm
    

Initialiser un compte de service pour gérer les instances Compute Engine

Dans ce tutoriel, vous allez créer un compte de service pour gérer les instances Compute Engine. Il est recommandé de limiter le compte de service aux rôles et autorisations d'accès requis pour exécuter l'application. Dans ce tutoriel, le seul rôle requis pour le compte de service est le rôle Lecteur de Compute (roles/compute.viewer). Celui-ci fournit un accès en lecture seule aux ressources Compute Engine.

  1. Dans Cloud Shell, initialisez une variable d'environnement qui stocke le nom du compte de service :

    GCE_SERVICE_ACCOUNT_NAME=istio-migration-gce
    
  2. Créez un compte de service :

    gcloud iam service-accounts create "$GCE_SERVICE_ACCOUNT_NAME" --display-name="$GCE_SERVICE_ACCOUNT_NAME"
    
  3. Initialisez une variable d'environnement qui stocke l'adresse e-mail complète du compte de service :

    GCE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GCE_SERVICE_ACCOUNT_NAME")"
    
  4. Liez le rôle compute.viewer au compte de service :

    gcloud projects add-iam-policy-binding "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GCE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/compute.viewer
    

Initialiser l'environnement d'exécution

L'étape suivante consiste à créer et à configurer une instance Compute Engine afin d'héberger les charges de travail à migrer.

  1. Dans Cloud Shell, initialisez et exportez une variable avec le nom de l'instance Compute Engine :

    export GCE_INSTANCE_NAME=legacy-vm
    
  2. Créez une instance Compute Engine :

    gcloud compute instances create "$GCE_INSTANCE_NAME" \
        --boot-disk-device-name="$GCE_INSTANCE_NAME" \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-ssd \
        --image-family=ubuntu-1804-lts \
        --image-project=ubuntu-os-cloud \
        --machine-type=n1-standard-1 \
        --metadata-from-file startup-script="$HOME"/solutions-istio-mesh-expansion-migration/gce-startup.sh \
        --scopes=storage-ro,logging-write,monitoring-write,service-control,service-management,trace \
        --service-account="$GCE_SERVICE_ACCOUNT_EMAIL" \
        --tags=bookinfo-legacy-vm
    

    Le type de machine n1-standard-1 spécifié dans cette commande est le plus petit vous permettant d'exécuter l'exemple de charge de travail sans affecter les performances. À la fin de cette commande, la console affiche des détails sur la nouvelle instance :

    NAME           ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
    legacy-vm      us-east1-b  n1-standard-1               10.142.0.38  34.73.53.145  RUNNING
    

Le script de démarrage configure l'instance Compute Engine en installant :

Déployer la charge de travail sur l'ancien environnement

Dans ce tutoriel, vous allez déployer l'application Bookinfo Istio en tant que charge de travail à migrer.

  1. Dans Cloud Shell, copiez les descripteurs Docker Compose dans l'instance Compute Engine :

    gcloud compute scp --recurse \
    "$HOME"/solutions-istio-mesh-expansion-migration/compose \
    "$GCE_INSTANCE_NAME":/tmp --zone=us-east1-b
    
  2. Attendez que l'installation de Docker Compose soit terminée :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='while ! command -v docker-compose; do echo "Waiting for docker-compose to be installed"; sleep 5; done'
    
  3. Démarrez l'application Bookinfo avec Docker Compose :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml up -d'
    

Tester le déploiement sur l'ancien environnement

Vous avez fini de configurer l'exemple de charge de travail. Vous pouvez donc le tester.

  1. Dans Cloud Shell, recherchez l'adresse IP externe de l'instance Compute Engine qui exécute l'exemple de charge de travail :

    gcloud compute instances describe "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --format='value(networkInterfaces[0].accessConfigs[0].natIP)'
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]:9083/productpage
    

    Une page s'affiche avec des détails sur les livres et les évaluations correspondantes :

    Détails sur les livres et les évaluations correspondantes

Configurer l'environnement d'exécution de destination

Dans cette section, vous configurez l'environnement de destination dans GCP en initialisant un cluster GKE et en exposant l'ancien service avec Istio. Le schéma suivant illustre l'architecture cible de l'environnement d'exécution de destination :

Architecture pour provisionner l'ancien d'exécution de destination

Initialiser un compte de service pour gérer les clusters GKE

Dans ce tutoriel, vous créez un compte de service pour gérer les instances Compute Engine dans le cluster GKE. Les nœuds du cluster GKE utilisent ce compte de service au lieu du compte de service par défaut, car vous il est préférable de fournir moins d'autorisations que celles accordées au compte de service par défaut.

Les rôles requis pour le compte de service sont monitoring.viewer, monitoring.metricWriter et logging.logWriter, comme décrit dans la page Renforcer la sécurité d'un cluster .

  1. Dans Cloud Shell, initialisez une variable d'environnement qui stocke le nom du compte de service :

    GKE_SERVICE_ACCOUNT_NAME=istio-migration-gke
    
  2. Créez un compte de service :

    gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
        --display-name="$GKE_SERVICE_ACCOUNT_NAME"
    
  3. Initialisez une variable d'environnement qui stocke le nom du compte de messagerie du compte de service :

    GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"
    
  4. Attribuez les rôles monitoring.viewer, monitoring.metricWriter et logging.logWriter au compte de service :

    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.viewer
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.metricWriter
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/logging.logWriter
    

Préparer le cluster GKE

Dans cette section, vous allez lancer le cluster GKE, installer Istio, exposer les services Istio et terminer la configuration du cluster. La première étape consiste à créer et à lancer le cluster GKE.

  1. Dans Cloud Shell, initialisez et exportez une variable d'environnement qui stocke le nom du cluster GKE :

    export GKE_CLUSTER_NAME=istio-migration
    
  2. Créez un cluster GKE régional comportant un pool de nœuds et un seul nœud dans chaque zone :

    gcloud container clusters create "$GKE_CLUSTER_NAME" \
        --addons=HorizontalPodAutoscaling,HttpLoadBalancing \
        --enable-autoupgrade \
        --enable-network-policy \
        --enable-ip-alias \
        --machine-type=n1-standard-4 \
        --metadata disable-legacy-endpoints=true \
        --node-locations us-east1-b,us-east1-c,us-east1-d \
        --no-enable-legacy-authorization \
        --no-enable-basic-auth \
        --no-issue-client-certificate \
        --num-nodes=1 \
        --region us-east1 \
        --service-account="$GKE_SERVICE_ACCOUNT_EMAIL"
    

    Cette commande crée un cluster GKE appelé istio-migration. L'exécution de cette commande peut prendre jusqu'à cinq minutes. À la fin de la commande, la console affiche des détails sur le nouveau cluster :

    NAME             LOCATION  MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
    istio-migration  us-east1  1.11.7-gke.4    35.196.136.88  n1-standard-8  1.11.7-gke.4  3          RUNNING
    

Utilisez ensuite Helm pour installer Istio dans le cluster.

  1. Dans Cloud Shell, initialisez et exportez une variable d'environnement qui stocke le nom de l'espace de noms Istio :

    export ISTIO_NAMESPACE=istio-system
    
  2. Créez l'espace de noms Istio :

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/namespace.yaml
    
  3. Créez un compte de service Kubernetes pour Tiller, la partie serveur de Helm :

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/helm/helm-service-account.yaml
    
  4. Installez Tiller dans votre cluster :

    "$HELM_PATH"/helm init --service-account tiller
    
  5. Installez le graphique istio-init pour amorcer toutes les définitions de ressources personnalisées (CRD) d'Istio :

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio-init --name istio-init --namespace "$ISTIO_NAMESPACE"
    

    À la fin de cette commande, la console affiche un récapitulatif des nouveaux objets qui ont été installés dans le cluster GKE :

    NAME:   istio-init
    LAST DEPLOYED: Wed Mar 20 11:39:12 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    ==> v1/ClusterRole
    NAME                     AGE
    istio-init-istio-system  1s
    ==> v1/ClusterRoleBinding
    NAME                                        AGE
    istio-init-admin-role-binding-istio-system  1s
    ==> v1/ConfigMap
    NAME          DATA  AGE
    istio-crd-10  1     1s
    istio-crd-11  1     1s
    ==> v1/Job
    NAME               COMPLETIONS  DURATION  AGE
    istio-init-crd-10  0/1          1s        1s
    istio-init-crd-11  0/1          1s        1s
    ==> v1/Pod(related)
    NAME                     READY  STATUS             RESTARTS  AGE
    istio-init-crd-10-2s28z  0/1    ContainerCreating  0         1s
    istio-init-crd-11-28n9r  0/1    ContainerCreating  0         1s
    ==> v1/ServiceAccount
    NAME                        SECRETS  AGE
    istio-init-service-account  1        1s
    
  6. Vérifiez que les CRD d'Istio ont été validées sur le serveur d'API api-server Kubernetes :

    kubectl get crds | grep 'istio.io\|certmanager.k8s.io' | wc -l
    

    Le résultat attendu est 53.

  7. Installez le graphique Istio :

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio \
        --name istio \
        --namespace "$ISTIO_NAMESPACE" \
        --set gateways.istio-ilbgateway.enabled=true \
        --set global.meshExpansion.enabled=true \
        --set global.meshExpansion.useILB=true \
        --set grafana.enabled=true \
        --set kiali.enabled=true \
        --set kiali.createDemoSecret=true \
        --set kiali.dashboard.grafanaURL=http://grafana:3000 \
        --set prometheus.enabled=true \
        --set tracing.enabled=true
    

    L'exécution de cette commande peut prendre jusqu'à deux minutes. À la fin de la commande, la console affiche un récapitulatif des nouveaux objets qui ont été installés dans le cluster GKE :

    NAME:   istio
    LAST DEPLOYED: Wed Mar 20 11:43:08 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    

    Après ce récapitulatif, la console affiche une liste des ressources déployées.

Les instances Compute Engine que vous souhaitez ajouter au maillage doivent avoir accès aux services du plan de contrôle Istio (Pilot, Mixer, Citadel). Vous devez donc les exposer à l'aide des services istio-ingressgateway et istio-ilbgateway. Exposez également le serveur DNS Kubernetes à l'aide d'un équilibreur de charge interne, de sorte que le serveur puisse être interrogé pour résoudre les noms des services exécutés dans le cluster. Exposez également Kiali pour visualiser le maillage de services.

  1. Dans Cloud Shell, créez l'équilibreur de charge interne pour exposer le serveur DNS Kubernetes :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kube-dns-ilb.yaml
    
  2. Attendez qu'une adresse IP externe soit attribuée à l'objet de service nommé kube-dns-ilb :

    kubectl get svc kube-dns-ilb -n kube-system --watch
    

    Le résultat affiche une adresse IP pour EXTERNAL-IP  :

    NAME           TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
    kube-dns-ilb   LoadBalancer   10.35.252.144   10.128.0.3    53:31054/UDP   4d
    

    Pour arrêter la commande, appuyez sur les touches Control+C.

  3. Attendez qu'une adresse IP externe soit attribuée à l'objet de service istio-ingressgateway :

    kubectl get svc istio-ingressgateway -n "$ISTIO_NAMESPACE" --watch
    

    Le résultat affiche une adresse IP pour EXTERNAL-IP :

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    

    Pour arrêter la commande, appuyez sur les touches Control+C.

  4. Attendez qu'une adresse IP externe soit attribuée à l'objet de service istio-ilbgateway :

    kubectl get svc istio-ilbgateway -n "$ISTIO_NAMESPACE" --watch
    

    Le résultat affiche une adresse IP pour EXTERNAL-IP  :

    NAME               TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)                                                         AGE
    istio-ilbgateway   LoadBalancer   10.48.14.190   10.142.0.31   15011:30805/TCP,15010:31082/TCP,8060:30953/TCP,5353:30536/TCP   2m
    

    Pour arrêter la commande, appuyez sur les touches Control+C.

  5. Exposez Kiali avec une passerelle et un service virtuel :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kiali.yaml
    

Configurer l'expansion du maillage Istio

Dans cette section, vous configurez l'expansion du maillage Istio pour permettre aux instances Compute Engine de rejoindre le maillage de services. La première tâche consiste à générer les fichiers de configuration à déployer dans chaque instance Compute Engine qui doit rejoindre le maillage.

  1. Dans Cloud Shell, initialisez et exportez une variable d'environnement qui stocke le nom de l'espace de noms par défaut :

    export SERVICE_NAMESPACE=default
    
  2. Extrayez les clés du compte de service utilisé par Istio :

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh machineCerts default "$SERVICE_NAMESPACE" all
    
  3. Initialisez et exportez une variable d'environnement qui stocke les options du script de génération de configuration :

    export GCP_OPTS="--region $(gcloud config get-value compute/region 2> /dev/null)"
    
  4. Exécutez le script de génération de configuration de l'environnement du cluster :

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh generateClusterEnv "$GKE_CLUSTER_NAME"
    
  5. Exécutez le script de génération de configuration DNS :

    "$HOME"/solutions-istio-mesh-expansion-migration/gce-mesh-expansion-setup.sh
    

Configurez ensuite l'instance Compute Engine que vous souhaitez associer au maillage.

  1. Réinitialisez la variable GCP_OPTS pour permettre au script d'initialisation de sélectionner les valeurs par défaut :

    unset GCP_OPTS
    
  2. Initialisez et exportez une variable d'environnement qui stocke le chemin d'accès du script d'installation :

    export SETUP_ISTIO_VM_SCRIPT="$ISTIO_PATH"/install/tools/setupIstioVM.sh
    
  3. Préparez le descripteur de version d'Istio pour l'initialisation de l'instance Compute Engine :

    cp "$ISTIO_PATH"/istio.VERSION "$HOME"
    
  4. Exécutez le script de génération de configuration de l'environnement du cluster :

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh gceMachineSetup "$GCE_INSTANCE_NAME"
    
  5. Configurez les ports locaux qui utiliseront le side-car Envoy pour les services entrants :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_INBOUND_PORTS=9081,9082,9083,9084" /var/lib/istio/envoy/sidecar.env'
    
  6. Configurez l'espace de noms du cluster :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_NAMESPACE='"$SERVICE_NAMESPACE"'" /var/lib/istio/envoy/sidecar.env'
    
  7. Redémarrez Istio :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl restart istio'
    
  8. Vérifiez qu'Istio a bien été démarré :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl --type=service --state=running list-units | grep "dnsmasq\|istio\|systemd-resolved"'
    

    Le résultat indique que les services dnsmasq, istio, istio-auth-node-agent et systemd-resolved sont chargés, actifs et en cours d'exécution :

    dnsmasq.service                  loaded active running dnsmasq - A lightweight DHCP and caching DNS server
    istio-auth-node-agent.service    loaded active running istio-auth-node-agent: The Istio auth node agent
    istio.service                    loaded active running istio-sidecar: The Istio sidecar
    systemd-resolved.service         loaded active running Network Name Resolution
    

Ajoutez ensuite des services exécutés sur l'instance Compute  Engine dans le maillage de services Istio.

  1. Dans Cloud Shell, créez les services Kubernetes sans sélecteurs pour exposer les services exécutés dans l'instance Compute Engine :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/selectorless-services.yaml
    
  2. Initialisez une variable d'environnement qui stocke l'adresse IP de l'instance Compute Engine sur laquelle l'exemple de charge de travail est en cours d'exécution :

    GCE_INSTANCE_IP="$(gcloud compute instances describe "$GCE_INSTANCE_NAME" --format='value(networkInterfaces[].networkIP)')"
    
  3. Enregistrez les services dans le maillage :

    "$ISTIO_PATH"/bin/istioctl register details "$GCE_INSTANCE_IP" http:9082 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register productpage "$GCE_INSTANCE_IP" http:9083 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register ratings "$GCE_INSTANCE_IP" http:9081 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register reviews "$GCE_INSTANCE_IP" http:9084 -n "$SERVICE_NAMESPACE"
    

Enfin, configurez les services virtuels et les règles de routage correspondantes pour les services du maillage qui sont en cours d'exécution sur l'instance Compute Engine. Exposez également le service productpage via une passerelle d'entrée Istio.

  1. Dans Cloud Shell, déployez un objet passerelle pour exposer les services :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/gateway.yaml
    
  2. Déployez le service virtuel qui achemine le trafic de l'objet passerelle vers l'instance productpage en cours d'exécution dans Compute Engine :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-vm.yaml
    
  3. Créez les entrées de service pour activer la recherche de services pour les services exécutés dans les instances Compute Engine :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  4. Attendez qu'une adresse IP externe soit attribuée à l'objet de service istio-ingressgateway :

    kubectl get svc istio-ingressgateway -n istio-system --watch
    

    Dans le résultat, une adresse IP devrait s'afficher pour EXTERNAL-IP :

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    
  5. Confirmez qu'un objet passerelle nommé bookinfo-gateway a été créé :

    kubectl get gateway --watch
    

    Dans le résultat, vous devriez voir bookinfo-gateway dans la liste des objets passerelle :

    NAME               AGE
    bookinfo-gateway   3h
    

Tester l'expansion du maillage Istio

Maintenant que vous avez fini d'exposer l'exemple de charge de travail exécuté dans l'instance Compute Engine à l'aide d'Istio, vous pouvez le tester :

  1. Dans Cloud Shell, recherchez l'adresse IP externe de la passerelle d'entrée Istio :

    kubectl get svc istio-ingressgateway -n istio-system
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]/productpage
    

    Une page s'affiche avec des informations sur les livres et les évaluations correspondantes :

    Livres et évaluations correspondantes

Visualiser le maillage de services

Dans cette section, vous utilisez Kiali pour afficher une représentation visuelle du maillage de services.

  1. Dans Cloud Shell, recherchez l'adresse IP externe de la passerelle d'entrée Istio :

    kubectl get svc istio-ingressgateway -n istio-system
        EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?  edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Sur l'écran de connexion de Kiali, connectez-vous avec les identifiants suivants :

    • Username (Nom d'utilisateur) : admin
    • Password (Mot de passe) : admin

    Écran de connexion Kiali

  4. Exécutez une requête plusieurs fois pour la page principale de l'exemple de charge de travail :

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Avec cette commande, vous générez du trafic vers l'application Bookinfo. Le résultat attendu est une liste des codes HTTP renvoyés de chaque requête (200 OK dans ce cas) :

    200
    200
    200
    [...]
    

    Dans le tableau de bord des services Kiali, vous devriez voir un schéma du maillage actuel, avec tout le trafic acheminé vers des services exécutés dans Compute Engine. Tout le trafic est acheminé de istio-ingressgateway au service Kubernetes productpage.default.svc.cluster.local, pointant vers le microservice productpage en cours d' exécution sur l'instance Compute Engine. Vous ne voyez pas les autres microservices dans le graphique (details, reviews, ratings) car Docker Compose gère le routage localement sur l'instance Compute Engine.

    Si vous ne voyez pas le schéma, actualisez la page du tableau de bord Kiali.

    Schéma du maillage actuel

Migrer la charge de travail

Dans cette section, vous migrez les composants de l'exemple de charge de travail de l'instance Compute Engine vers le cluster GKE. Pour chaque service de l'exemple de charge de travail :

  1. Déployez un pod qui exécute le service dans le cluster GKE.
  2. Configurez des règles pour répartir le trafic entre le service en cours d'exécution dans le cluster GKE et celui en cours d'exécution dans l'instance Compute Engine.
  3. Migrez progressivement le trafic du service qui s'exécute dans l'instance Compute Engine vers le cluster GKE.
  4. Arrêtez le service qui s'exécute dans l'instance Compute Engine.

Le schéma suivant montre l'architecture cible du système pour cette section :

Architecture de migration de la charge de travail

Activer l'injection side-car Istio

Chaque service nécessite un proxy side-car Envoy en cours d'exécution pour rejoindre le maillage de services Istio. Vous pouvez activer l'injection side-car automatique afin d'éviter toute modification manuelle de la configuration de vos pods.

  1. Dans Cloud Shell, arrêtez la commande de génération de trafic en appuyant sur Control+C.

  2. Activez l'injection side-car automatique gérée par Istio dans l'espace de noms Kubernetes où vous déploierez les instances de service :

    kubectl label namespace "$SERVICE_NAMESPACE" istio-injection=enabled
    

Déployer des services dans le cluster GKE

Dans cette section, vous allez déployer des instances dans le cluster GKE et acheminer une partie du trafic vers ces instances.

  1. Dans Cloud Shell, supprimez les entrées de service avant de déployer d'autres services dans le maillage. La suppression de ces entrées empêche les requêtes de routage vers des instances qui ne sont pas encore prêtes :

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  2. Déployez des pods et des services Kubernetes pour les microservices productpage, details, reviews et ratings dans le cluster :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/productpage.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/details.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/ratings.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/reviews.yaml
    
  3. Mettez à jour la configuration des services virtuels pour répartir le trafic entrant entre les instances exécutées sur la machine Compute Engine et celles exécutées sur le cluster GKE :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-details-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-ratings-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-reviews-split.yaml
    
  4. Créez les entrées de service pour activer la recherche de services pour les services exécutés dans les instances Compute Engine :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    

La tâche suivante consiste à valider votre déploiement hybride en inspectant le trafic dirigé vers toutes les instances de microservices dans vos deux environnements (Compute Engine et GKE).

Utilisez Kiali pour voir une représentation visuelle du maillage de services :

  1. Dans Cloud Shell, recherchez l'adresse IP externe de la passerelle d'entrée Istio :

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Sur l'écran de connexion de Kiali, connectez-vous avec les identifiants suivants, si nécessaire :

    • Nom d'utilisateur : admin
    • Mot de passe : admin
  4. Exécutez une requête plusieurs fois pour la page principale de l'exemple de charge de travail :

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Avec cette commande, vous générez du trafic vers l'application Bookinfo. Le résultat attendu est une liste des codes HTTP renvoyés de chaque requête (200 OK dans ce cas) :

    200
    200
    200
    [...]
    

    Dans le tableau de bord des services Kiali, le trafic est réparti presque équitablement entre les instances de microservices exécutées dans Compute Engine et celles exécutées dans GKE (avec le suffixe -gke dans la première partie de l'identifiant de service). Cela est dû au fait que vous avez configuré les routes dans le service virtuel pour qu'elles aient le même poids.

    Si vous ne voyez pas le schéma, actualisez la page du tableau de bord Kiali.

    Tableau de bord affichant la répartition du trafic

Acheminer le trafic vers le cluster GKE uniquement

Lorsque vous êtes certain que le déploiement dans le cluster GKE a bien été effectué, vous pouvez mettre à jour les services et les services virtuels pour acheminer le trafic vers le cluster uniquement.

Le schéma suivant montre l'architecture cible du système pour cette section :

Acheminer le trafic vers le cluster GKE uniquement

  1. Dans Cloud Shell, arrêtez la commande de génération de trafic en appuyant sur Control+C.

  2. Mettez à jour les services et les services virtuels pour acheminer le trafic vers les instances de microservices du cluster GKE :

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-gke.yaml
    

Pour valider votre déploiement, inspectez le trafic dirigé vers toutes les instances de microservices dans vos deux environnements (Compute Engine et GKE).

Utilisez Kiali pour voir une représentation visuelle du maillage de services :

  1. Dans Cloud Shell, recherchez l'adresse IP externe de la passerelle d'entrée Istio :

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre

  3. Sur l'écran de connexion de Kiali, connectez-vous avec les identifiants suivants, si nécessaire :

    • Nom d'utilisateur : admin
    • Mot de passe : admin
  4. Exécutez une requête plusieurs fois pour la page principale de l'exemple de charge de travail :

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Avec cette commande, vous générez du trafic vers l'application Bookinfo. Le résultat attendu est une liste des codes HTTP renvoyés de chaque requête (200 OK dans ce cas) :

    200
    200
    200
    [...]
    

    Dans le tableau de bord des services Kiali, le trafic est en train d'être acheminé vers des instances de microservices exécutées dans le cluster GKE (avec le suffixe -gke dans la première partie de l'identifiant de service). Aucun trafic n'est acheminé vers les instances exécutées dans Compute Engine. Si vous ne voyez pas le schéma, actualisez la page du tableau de bord Kiali. Lorsque vous avez déployé deux instances de chaque microservice (l'une exécutée dans l'instance Compute Engine et l'autre dans le cluster GKE), vous avez configuré les services virtuels pour acheminer le trafic uniquement vers les instances de microservices exécutées dans le cluster GKE.

    Si vous ne voyez pas le schéma, actualisez la page du tableau de bord Kiali.

    Trafic acheminé vers des instances exécutées dans le cluster GKE uniquement

Supprimer l'ancien centre de données

Étant donné que l'ensemble du trafic est acheminé vers le cluster GKE, vous pouvez maintenant supprimer les entrées de service des microservices exécutés dans Compute Engine, et arrêter Docker Compose.

Le schéma suivant montre l'architecture cible du système pour cette section :

Architecture de suppression de l'ancien centre de données

  1. Dans Cloud Shell, arrêtez la commande de génération de trafic en appuyant sur Control+C.

  2. Supprimez les entrées de service avant de déployer d'autres services dans le maillage :

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  3. Arrêtez l'exemple de charge de travail en cours d'exécution avec Docker Compose :

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml down --remove-orphans -v'
    

Visualiser l'ensemble du maillage - Uniquement dans GKE

Dans cette section, vous validez votre déploiement en inspectant le trafic acheminé vers toutes les instances de microservices dans vos deux environnements (Compute Engine et GKE).

Utilisez Kiali pour voir une représentation visuelle du maillage de services :

  1. Dans Cloud Shell, recherchez l'adresse IP externe de la passerelle d'entrée Istio :

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Ouvrez un navigateur et accédez à l'URL suivante, où [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Sur l'écran de connexion de Kiali, connectez-vous avec les identifiants suivants, si nécessaire :

    • Nom d'utilisateur : admin
    • Mot de passe : admin
  4. Exécutez une requête plusieurs fois pour la page principale de l'exemple de charge de travail :

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Avec cette commande, vous générez du trafic vers l'application Bookinfo. Le résultat attendu est une liste des codes HTTP renvoyés de chaque requête (200 OK dans ce cas) :

    200
    200
    200
    [...]
    

    Dans le tableau de bord des services Kiali, vous ne devriez voir que les services pointant vers des instances du cluster GKE (avec le suffixe -gke dans la première partie de l'identifiant de service), tandis que les services pointant vers des instances exécutées dans Compute Engine ne font plus partie du maillage, puisque vous avez supprimé les entrées de services associées.

    Si vous ne voyez pas le schéma, actualisez la page du tableau de bord Kiali.

    Visualiser l'ensemble du maillage

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Dans la console GCP, accédez à la page Projets.

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer delete.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…