1. Présentation
Dans la première partie de l'atelier, vous avez créé une application ASP.NET Core, conteneurisée et déployée dans Google Kubernetes Engine (GKE) et configuré son trafic pour qu'il soit géré par Istio.
Dans cette deuxième partie de l'atelier, nous partons du principe que le cluster Kubernetes et l'application du premier atelier sont déjà en cours d'exécution. Vous verrez comment Istio peut vous aider à gérer, surveiller et sécuriser vos services avec un minimum de modifications du code. Plus précisément, vous explorerez les fonctionnalités d'Istio telles que les métriques, le traçage, la visualisation des services, la gestion dynamique du trafic, l'injection de pannes, etc.
Points abordés
- Interroger des métriques avec Prometheus
- Visualiser les métriques avec Grafana
- Créer une version de votre service
- Épingler un service à une version spécifique
- Découvrez comment répartir le trafic entre différentes versions.
- Injecter des erreurs dans les appels de service
Prérequis
Comment allez-vous utiliser ce tutoriel ?
Quel est votre niveau d'expérience avec Google Cloud Platform ?
<ph type="x-smartling-placeholder">2. Préparation
Configuration de l'environnement d'auto-formation
- Connectez-vous à Cloud Console, puis créez un projet ou réutilisez un projet existant. (Si vous n'avez pas encore de compte Gmail ou G Suite, vous devez en créer un.)
Mémorisez l'ID du projet. Il s'agit d'un nom unique permettant de différencier chaque projet Google Cloud (le nom ci-dessus est déjà pris ; vous devez en trouver un autre). Il sera désigné par le nom PROJECT_ID tout au long de cet atelier de programmation.
- Vous devez ensuite activer la facturation dans Cloud Console pour pouvoir utiliser les ressources Google Cloud.
L'exécution de cet atelier de programmation est très peu coûteuse, voire gratuite. Veillez à suivre les instructions de la section "Nettoyer" qui indique comment désactiver les ressources afin d'éviter les frais une fois ce tutoriel terminé. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai gratuit pour bénéficier d'un crédit de 300 $.
Démarrer Cloud Shell
Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, vous allez utiliser Google Cloud Shell dans cet atelier de programmation, un environnement de ligne de commande exécuté dans Google Cloud.
Activer Cloud Shell
- Dans Cloud Console, cliquez sur Activer Cloud Shell
.
Si vous n'avez encore jamais démarré Cloud Shell, un écran intermédiaire s'affiche en dessous de la ligne de séparation pour décrire de quoi il s'agit. Si tel est le cas, cliquez sur Continuer (cet écran ne s'affiche qu'une seule fois). Voici à quoi il ressemble :
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement nécessaires. Elle intègre un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier dans un simple navigateur ou sur votre Chromebook.
Une fois connecté à Cloud Shell, vous êtes en principe authentifié et le projet est défini avec votre ID de projet.
- Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Résultat de la commande
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
3. Tester l'application
Avant de démarrer l'atelier, assurez-vous que l'application fonctionne toujours avec l'atelier précédent. Pour rappel, voici comment vous voyez l'adresse IP externe et le port de la passerelle, qui sont listés sous EXTERNAL-IP:
kubectl get svc istio-ingressgateway -n istio-system
Pour afficher l'application, vous pouvez ouvrir votre navigateur et accéder à http://<gatewayurl>:
Si vous ne voyez pas l'application, revenez à l'atelier précédent pour vérifier que vous avez suivi toutes les étapes, et que l'application et Istio sont installés et fonctionnent correctement.
À ce stade, vous vous demandez peut-être quel est l'avantage d'Istio. En laissant Istio gérer le trafic de votre application, vous bénéficiez sans frais de fonctionnalités telles que des métriques, le traçage, la gestion dynamique du trafic, la visualisation des services, l'injection de pannes, etc.
Vous commencerez par explorer les métriques à l'étape suivante.
4. Métriques avec Grafana et Prometheus
Par défaut, Istio génère certaines métriques. Vous pouvez utiliser des modules complémentaires pour interroger et visualiser ces métriques par défaut.
Prometheus
Prometheus est une solution de surveillance Open Source. Vous pouvez utiliser Prometheus pour interroger les métriques générées par Istio, mais vous devez d'abord installer le module complémentaire Prometheus.
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.8/samples/addons/prometheus.yaml
Vérifiez que Prometheus est en cours d'exécution:
kubectl get svc prometheus -n istio-system NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE prometheus ClusterIP 10.31.243.62 <none> 9090/TCP 1d
Envoyez du trafic vers l'application en accédant à http://<gatewayurl> plusieurs fois ou en exécutant la commande curl.
Configurez le transfert de port pour l'interface utilisateur Prometheus:
kubectl -n istio-system port-forward $(kubectl -n istio-system get pod -l app=prometheus -o jsonpath='{.items[0].metadata.name}') 8080:9090
À présent, vous pouvez exécuter une requête en cliquant sur le bouton "Aperçu sur le Web" dans l'angle supérieur droit de Cloud Shell, puis sur Prévisualiser sur le port 8080:
L'interface utilisateur de Prometheus s'affiche dans un nouvel onglet:
Pour en savoir plus sur Prometheus, consultez la page Interroger des métriques avec Prometheus.
Grafana
Grafana est un autre module complémentaire permettant de visualiser les métriques.
Installez Grafana. Remplacez istio-version par votre version actuelle d'Istio, par exemple 1.0.3-gke.3:
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.8/samples/addons/grafana.yaml
Vérifiez que Grafana est en cours d'exécution:
kubectl get svc grafana -n istio-system NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE grafana ClusterIP 10.31.248.230 <none> 3000/TCP 1d
Envoyez du trafic vers l'application en accédant à http://<gatewayurl> plusieurs fois ou en exécutant la commande curl.
Configurez le transfert de port pour l'interface utilisateur de Grafana:
kubectl -n istio-system port-forward $(kubectl -n istio-system get pod -l app=grafana -o jsonpath='{.items[0].metadata.name}') 8080:3000
Vous pouvez consulter les tableaux de bord de Grafana en accédant à "Aperçu sur le Web" :
Pour en savoir plus sur Granfana, consultez Visualiser des métriques avec Grafana.
5. Créer une nouvelle version de l'application
À un moment donné, l'application que vous avez déployée en production nécessitera des corrections de bugs ou l'ajout de nouvelles fonctionnalités. Voyons à quoi ressemble ce processus.
Commençons par modifier l'application. Ouvrez l'éditeur de code à partir de Cloud Shell.
Accédez à Index.cshtml sous HelloWorldAspNetCore > Views > Home et mettez à jour l'un des messages du carrousel.
Recherchez la ligne suivante:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core
Remplacez-le par le message suivant :
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud
Enregistrez les modifications, puis revenez à Cloud Shell. Dans HelloWorldAspNetCore,, créez l'image Docker:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
Transférez ensuite les données vers Container Registry:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2
Après avoir transféré l'image de conteneur, vous pourrez déployer la nouvelle version à l'étape suivante.
6. Créer le déploiement
Pour déployer la nouvelle version, vous devez d'abord créer un déploiement pour celle-ci dans Kubernetes. Ajoutez le code suivant à la fin du fichier aspnetcore.yaml:
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: aspnetcore-v2
spec:
replicas: 1
selector:
matchLabels:
app: aspnetcore
version: v2
template:
metadata:
labels:
app: aspnetcore
version: v2
spec:
containers:
- name: aspnetcore
image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v2
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8080
Déployez la nouvelle version sur l'espace de noms par défaut à l'aide de kubectl:
kubectl apply -f aspnetcore.yaml
service "aspnetcore" unchanged deployment.extensions "aspnetcore-v1" unchanged deployment.extensions "aspnetcore-v2" created
Vérifiez que les pods attendus sont en cours d'exécution:
kubectl get pods
NAME READY STATUS RESTARTS AGE aspnetcore-v1-6cf64748-mddb 2/2 Running 0 34s aspnetcore-v2-5d765db-l9xmg 2/2 Running 0 1m
Testez à nouveau l'application. Obtenez l'adresse IP externe de la passerelle:
kubectl get svc istio-ingressgateway -n istio-system
Il est répertorié sous EXTERNAL-IP. Ouvrez un navigateur en navigation privée et accédez à http://<replace-with-external-ip>.
Lorsque vous actualisez la page, le message "En savoir plus sur la création d'applications Web avec ASP.NET Core" s'affiche parfois :
Dans d'autres cas, le message "Découvrez comment créer des applications Web avec ASP.NET Core sur Google Cloud" s'affiche :
En effet, les déploiements v1 et v2 sont exposés derrière le même service Kubernetes (aspnetcore-service) et le VirtualService que vous avez créé dans l'atelier précédent (aspnetcore-virtualservice) utilise ce service en tant qu'hôte.
À l'étape suivante, vous allez épingler le service au déploiement v2 à l'aide d'une règle DestinationRule.
7. Épingler votre service à la nouvelle version
Au cours de cette étape, vous allez épingler votre service pour qu'il utilise le déploiement v2. Pour ce faire, utilisez une règle DestinationRule. Une règle DestinationRule configure l'ensemble des stratégies à appliquer à une requête après qu'une opération de routage VirtualService s'est produite.
Une règle DestinationRule définit également des sous-ensembles adressables, c'est-à-dire des versions nommées de l'hôte de destination correspondant. Ces sous-ensembles sont utilisés dans les spécifications de routage de VirtualService lors de l'envoi de trafic vers des versions spécifiques du service.
Créez un fichier appelé aspnetcore-destinationrule.yaml :
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
name: aspnetcore-destinationrule
spec:
host: aspnetcore-service
trafficPolicy:
tls:
mode: ISTIO_MUTUAL
subsets:
- name: v1
labels:
version: v1
- name: v2
labels:
version: v2
Créez ensuite la règle DestinationRule. Cette opération crée deux sous-ensembles (v1 et v2) que vous pouvez utiliser à partir du service virtuel:
kubectl apply -f aspnetcore-destinationrule.yaml
destinationrule.networking.istio.io "aspnetcore-destionationrule" created
Revenez maintenant au fichier aspnetcore-virtualservice.yaml pour mettre à jour le service virtuel afin d'utiliser le sous-ensemble v2:
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: aspnetcore-virtualservice
spec:
hosts:
- "*"
gateways:
- aspnetcore-gateway
http:
- route:
- destination:
host: aspnetcore-service
subset: v2
Mettez à jour le service virtuel:
kubectl apply -f aspnetcore-virtualservice.yaml
Ouvrez votre navigateur et accédez à http://<replace-with-external-ip>.. Même après plusieurs actualisations, le message "En savoir plus sur la création d'applications Web avec ASP.NET Core sur Google Cloud" doit s'afficher :
8. Répartir le trafic entre les versions
Dans certains cas, vous souhaiterez peut-être répartir le trafic entre les versions à des fins de test. Par exemple, vous pouvez envoyer 75% du trafic vers la version v1 et 25% du trafic vers la version v2 du service. Pour ce faire, vous pouvez facilement le faire avec Istio. Créez un fichier aspnetcore-virtualservice-weights.yaml pour faire référence aux deux sous-ensembles avec des pondérations différentes:
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: aspnetcore-virtualservice
spec:
hosts:
- "*"
gateways:
- aspnetcore-gateway
http:
- route:
- destination:
host: aspnetcore-service
subset: v1
weight: 75
- destination:
host: aspnetcore-service
subset: v2
weight: 25
Mettez à jour le service virtuel:
kubectl apply -f aspnetcore-virtualservice-weights.yaml
Lorsque vous actualisez le navigateur, vous devriez voir les versions v1 et v2 diffusées avec un ratio d'environ 3:1.
Pour en savoir plus, consultez la section Répartition du trafic dans Istio.
9. Injecter des défaillances
Une autre tâche de développement utile pour les tests consiste à injecter des pannes ou des retards dans le trafic et à observer le comportement des services en réponse.
Par exemple, vous pouvez renvoyer une réponse à une requête incorrecte (HTTP 400) pour 50% du trafic vers la version v1. Créez un fichier aspnetcore-virtualservice-fault-abort.yaml correspondant à ce qui suit:
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: aspnetcore-virtualservice
spec:
hosts:
- "*"
gateways:
- aspnetcore-gateway
http:
- fault:
abort:
percentage:
value: 50
httpStatus: 400
route:
- destination:
host: aspnetcore-service
subset: v1
Mettez à jour le service virtuel:
kubectl apply -f aspnetcore-virtualservice-fault-abort.yaml
Maintenant, lorsque vous actualisez le navigateur, vous devriez voir que la moitié du temps, le service v1 renvoie un code de réponse HTTP 400.
Ou peut-être souhaitez-vous ajouter un délai de cinq secondes aux requêtes. Créez un fichier aspnetcore-virtualservice-fault-delay.yaml correspondant à ce qui suit:
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: aspnetcore-virtualservice
spec:
hosts:
- "*"
gateways:
- aspnetcore-gateway
http:
- fault:
delay:
fixedDelay: 5s
percentage:
value: 100
route:
- destination:
host: aspnetcore-service
subset: v1
Mettez à jour le service virtuel:
kubectl apply -f aspnetcore-virtualservice-fault-delay.yaml
Maintenant, lorsque vous actualisez le navigateur, vous devriez voir que les requêtes sont retardées de 5 secondes.
Pour en savoir plus sur les fonctionnalités d'Istio telles que les délais avant expiration, les nouvelles tentatives, les règles conditionnelles, les disjoncteurs et plus encore, consultez la page Fonctionnalités de gestion du trafic.
10. Félicitations !
Nous espérons que cet atelier vous a donné un aperçu de ce qu'Istio peut apporter à vos services dès la première utilisation. Pour en savoir plus sur Istio et GKE.
Étapes suivantes
- En savoir plus sur Istio.
- Apprenez-en plus sur Kubernetes.
- Apprenez-en plus sur Google Kubernetes Engine.
- Obtenez plus d'informations sur .NET sur Google Cloud Platform.
Licence
Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.
11. Nettoyage
Vous pouvez supprimer l'application et désinstaller Istio, ou simplement supprimer le cluster Kubernetes.
Supprimer l'application
Pour supprimer l'application:
kubectl delete -f aspnetcore-gateway.yaml kubectl delete -f aspnetcore-virtualservice.yaml kubectl delete -f aspnetcore-destinationrule.yaml kubectl delete -f aspnetcore.yaml
Pour vérifier que l'application a disparu:
kubectl get gateway kubectl get virtualservices kubectl get destinationrule kubectl get pods
Désinstaller Istio
Pour supprimer Istio:
kubectl delete -f install/kubernetes/istio-demo-auth.yaml
Pour vérifier qu'Istio a bien été supprimé:
kubectl get pods -n istio-system
Supprimer un cluster Kubernetes
gcloud container clusters delete hello-dotnet-cluster