Geekly articles weekly

Préparation de l'application pour Istio


Istio est un outil pratique pour connecter, protéger et surveiller les applications distribuées. Istio utilise une variété de technologies pour lancer et gérer des logiciels à grande échelle, y compris des conteneurs pour empaqueter le code d'application et les dépendances pour le déploiement, et Kubernetes pour gérer ces conteneurs. Par conséquent, pour travailler avec Istio, vous devez savoir comment fonctionne une application avec plusieurs services basés sur ces technologies sans Istio. Si vous connaissez déjà ces outils et concepts, n'hésitez pas à ignorer ce guide et allez directement à l' installation d'Istio sur le moteur Google Kubernetes (GKE) ou à l'installation de l'extension Istio sur GKE .


Il s'agit d'un guide étape par étape où nous allons examiner l'ensemble du processus, du code source au conteneur sur GKE, afin que vous ayez une idée de base de ces technologies à l'aide d'un exemple. Vous verrez également comment Istio tire parti de ces technologies. On suppose que vous ne savez rien des conteneurs, Kubernetes, service mesh ou Istio.


Les tâches


Dans ce guide, vous effectuerez les tâches suivantes:


  1. Explorer une simple application hello world avec plusieurs services.
  2. Exécution de l'application à partir du code source.
  3. Emballage de l'application dans des conteneurs.
  4. Création d'un cluster Kubernetes
  5. Déployez des conteneurs sur un cluster.

Avant de commencer


Suivez les instructions pour activer l'API Kubernetes Engine:


  1. Accédez à la page Kubernetes Engine dans la console Google Cloud Platform.
  2. Créez ou sélectionnez un projet.
  3. Attendez que l'API et les services associés s'allument. Cela peut prendre plusieurs minutes.
  4. Assurez-vous que la facturation est configurée pour le projet Google Cloud Platform. Découvrez comment activer la facturation .

Dans ce guide, vous pouvez utiliser Cloud Shell, qui prépare la petite machine virtuelle g1 dans Google Compute Engine avec Linux basé sur Debian, ou un ordinateur Linux ou macOS.


Option A: utilisation de Cloud Shell


Avantages de l'utilisation de Cloud Shell:


  • Les environnements de développement Python 2 et Python 3 (y compris virtualenv ) sont entièrement personnalisés.
  • Les outils de ligne de commande gcloud , docker , git et kubectl que nous utiliserons sont déjà installés.
  • Vous avez le choix entre plusieurs éditeurs de texte :
    1. L'éditeur de code qui s'ouvre avec l'icône d'édition en haut de la fenêtre Cloud Shell.
    2. Emacs, Vim ou Nano qui s'ouvrent à partir de la ligne de commande dans Cloud Shell.

Pour utiliser Cloud Shell :


  1. Accédez à la console GCP.
  2. Cliquez sur le bouton Activer Cloud Shell en haut de la fenêtre de la console GCP.


Au bas de la console GCP, dans une nouvelle fenêtre, une session Cloud Shell s'ouvre avec une ligne de commande.



Option B: utilisation locale des outils de ligne de commande


Si vous travaillez sur un ordinateur avec Linux ou macOS, vous devez configurer et installer les composants suivants:


  1. Configurez votre environnement de développement Python 3 et Python 2 .


  2. Installez le SDK Cloud avec l' outil de ligne de commande gcloud .


  3. Installez kubectl , un outil en ligne de commande pour travailler avec Kubernetes .


    gcloud components install kubectl

  4. Installez Docker Community Edition (CE) . Vous utiliserez l'outil de ligne de commande docker pour créer des images de conteneur pour un exemple d'application.


  5. Installez l'outil de contrôle de version Git pour obtenir un exemple d'application avec GitHub.



Télécharger un exemple de code


  1. Téléchargez le code source de helloserver :


     git clone https://github.com/GoogleCloudPlatform/istio-samples

  2. Accédez à l'exemple de répertoire de code:


     cd istio-samples/sample-apps/helloserver


Explorer une application multiservice


L'exemple d'application est écrit en Python et se compose de deux composants qui interagissent avec REST :


  • serveur : un serveur simple avec un point d'extrémité GET, / , qui affiche "hello world" sur la console.
  • loadgen : un script qui envoie du trafic vers le serveur , avec un nombre configurable de requêtes par seconde.


Exécution d'une application à partir de la source


Pour découvrir un exemple d'application, exécutez-le dans Cloud Shell ou sur un ordinateur.
1) Dans le répertoire istio-samples / sample-apps / helloserver , exécutez le serveur :


 python3 server/server.py

Au démarrage du serveur , les informations suivantes s'affichent:


 INFO:root:Starting server...

2) Ouvrez une autre fenêtre de terminal pour envoyer des requêtes au serveur . Si vous utilisez Cloud Shell, cliquez sur l'icône d'ajout pour ouvrir une autre session.
3) Envoyez une demande au serveur :


 curl http://localhost:8080

réponses du serveur:


 Hello World!

4) Dans le répertoire où vous avez téléchargé l'exemple de code, accédez au répertoire contenant loadgen :


 cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen

5) Créez les variables d'environnement suivantes:


 export SERVER_ADDR=http://localhost:8080 export REQUESTS_PER_SECOND=5

6) Exécutez virtualenv :


 virtualenv --python python3 env

7) Activez l'environnement virtuel:


 source env/bin/activate

8) Définissez les exigences pour loadgen :


 pip3 install -r requirements.txt

9) Exécutez loadgen :


 python3 loadgen.py

Au démarrage, loadgen affiche le message suivant:


 Starting loadgen: 2019-05-20 10:44:12.448415 5 request(s) complete to http://localhost:8080

Dans une autre fenêtre de terminal, le serveur affiche les messages suivants à la console:


 127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET request, Path: / Headers: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*

Du point de vue du réseau, l'application entière s'exécute sur le même hôte (ordinateur local ou machine virtuelle Cloud Shell). Par conséquent, vous pouvez utiliser localhost pour envoyer des demandes au serveur .
10) Pour arrêter loadgen et le serveur , entrez Ctrl-c dans chaque fenêtre de terminal.
11) Dans la fenêtre du terminal loadgen, désactivez l'environnement virtuel:


 deactivate

Emballage de l'application dans des conteneurs


Pour exécuter l'application sur GKE, vous devez empaqueter l'exemple d'application - serveur et loadgen - dans des conteneurs . Un conteneur est un moyen de compresser une application pour l'isoler de l'environnement.


Pour emballer l'application dans un conteneur, vous avez besoin d'un Dockerfile . Un Dockerfile est un fichier texte qui définit des commandes pour construire le code source d'une application et ses dépendances dans une image Docker. Après la génération, vous téléchargez l'image dans le registre de conteneurs, par exemple, le Docker Hub ou le registre de conteneurs .


L'exemple a déjà un Dockerfile pour le serveur et loadgen avec toutes les commandes nécessaires pour assembler les images. Voici le Dockerfile pour le serveur :


 FROM python:3-slim as base FROM base as builder RUN apt-get -qq update \ && apt-get install -y --no-install-recommends \ g++ \ && rm -rf /var/lib/apt/lists/* # Enable unbuffered logging FROM base as final ENV PYTHONUNBUFFERED=1 RUN apt-get -qq update \ && apt-get install -y --no-install-recommends \ wget WORKDIR /helloserver # Grab packages from builder COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/ # Add the application COPY . . EXPOSE 8080 ENTRYPOINT [ "python", "server.py" ]

  • La commande FROM python: 3-slim as base indique à Docker d'utiliser la dernière image Python 3 comme base.
  • Équipe COPY. . copie les fichiers source dans le répertoire de travail actuel (dans notre cas uniquement server.py ) dans le système de fichiers conteneur.
  • ENTRYPOINT définit la commande utilisée pour démarrer le conteneur. Dans notre cas, cette commande est presque la même que celle que vous avez utilisée pour exécuter server.py à partir du code source.
  • La commande EXPOSE indique que le serveur écoute sur le port 8080 . Cette commande ne fournit pas de ports . Il s'agit d'une sorte de documentation nécessaire pour ouvrir le port 8080 au démarrage du conteneur.

Préparation de la conteneurisation des applications


1) Définissez les variables d'environnement suivantes. Remplacez PROJECT_ID par votre identifiant de projet GCP.


 export PROJECT_ID="PROJECT_ID" 

 export GCR_REPO="preparing-istio"

À l'aide des valeurs PROJECT_ID et GCR_REPO, vous balisez l'image Docker lorsque vous la collectez et l'envoyez au registre de conteneurs privé.


2) Définissez le projet GCP par défaut pour l' outil de ligne de commande gcloud .


 gcloud config set project $PROJECT_ID

3) Définissez la zone par défaut pour l' outil de ligne de commande gcloud .


 gcloud config set compute/zone us-central1-b

4) Assurez-vous que le service de registre de conteneurs est inclus dans le projet GCP.


 gcloud services enable containerregistry.googleapis.com

Serveur de conteneurisation


  1. Accédez au répertoire où se trouve l'exemple de serveur :


     cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

  2. Créez l'image à l' aide des variables Dockerfile et d'environnement que vous avez définies précédemment:


     docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .


L' option -t représente la balise Docker. Il s'agit du nom de l'image que vous utilisez lors du déploiement du conteneur.


  1. Envoyez l'image au registre des conteneurs:
     docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Conteneurisation loadgen


1) Allez dans le répertoire où se trouve l'exemple loadgen :


 cd ../loadgen

2) Assemblez l'image:


 docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) Envoyez l'image au registre des conteneurs:


 docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Afficher une liste d'images


Parcourez la liste des images dans le référentiel et assurez-vous que les images sont envoyées:


 gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

La commande affiche les noms des images qui viennent d'être envoyées:


 NAME gcr.io/PROJECT_ID/preparing-istio/helloserver gcr.io/PROJECT_ID/preparing-istio/loadgen

Création d'un cluster GKE


Ces conteneurs peuvent être exécutés sur la machine virtuelle Cloud Shell ou sur l'ordinateur avec la commande docker run . Mais dans un environnement de production, vous avez besoin d'un moyen d'orchestrer de manière centralisée les conteneurs. Par exemple, nous avons besoin d'un système qui garantit que les conteneurs fonctionnent toujours, et nous avons besoin d'un moyen de zoomer et de lancer des instances supplémentaires de conteneurs si le trafic augmente.


Vous pouvez utiliser GKE pour exécuter des applications de conteneur. GKE est une plate-forme d'orchestration de conteneurs qui regroupe les machines virtuelles. Chaque machine virtuelle est appelée hôte. Les clusters GKE sont basés sur le système de gestion de cluster open source Kubernetes. Kubernetes fournit des mécanismes pour interagir avec le cluster.


Création d'un cluster GKE:


1) Créez un cluster:


 gcloud container clusters create istioready \ --cluster-version latest \ --machine-type=n1-standard-2 \ --num-nodes 4

La commande gcloud crée un cluster istioready dans le projet GCP et la zone par défaut que vous avez spécifiée. Pour démarrer Istio, nous vous recommandons d'avoir au moins 4 nœuds et une machine virtuelle n1-standard-2 .


L'équipe crée un cluster pendant plusieurs minutes. Lorsque le cluster est prêt, la commande émet un message similaire.


2) Spécifiez les informations d'identification dans l' outil de ligne de commande kubectl pour l'utiliser pour gérer le cluster:


 gcloud container clusters get-credentials istioready

3) Vous pouvez maintenant communiquer avec Kubernetes via kubectl . Par exemple, avec la commande suivante, vous pouvez connaître l'état des nœuds:


 kubectl get nodes

La commande affiche une liste de nœuds:


 NAME STATUS ROLES AGE VERSION gke-istoready-default-pool-dbeb23dc-1vg0 Ready <none> 99s v1.13.6-gke.13 gke-istoready-default-pool-dbeb23dc-36z5 Ready <none> 100s v1.13.6-gke.13 gke-istoready-default-pool-dbeb23dc-fj7s Ready <none> 99s v1.13.6-gke.13 gke-istoready-default-pool-dbeb23dc-wbjw Ready <none> 99s v1.13.6-gke.13

Concepts clés de Kubernetes


Le schéma montre l'application sur GKE:



Avant de déployer des conteneurs sur GKE, examinez les concepts clés de Kubernetes. Il y a des liens à la fin si vous voulez en savoir plus.


  • Noeuds et clusters . Dans GKE, un nœud est une machine virtuelle. Sur d'autres plates-formes Kubernetes, l'hôte peut être un ordinateur ou une machine virtuelle. Un cluster est une collection de nœuds qui peut être considérée comme un tout et où vous déployez une application conteneurisée.
  • Pods . Dans Kubernetes, les conteneurs s'exécutent dans des modules. Un pod dans Kubernetes est une unité indivisible. Un pod contient un ou plusieurs conteneurs. Vous déployez le serveur et les conteneurs loadgen dans des modules distincts. Lorsqu'il y a plusieurs conteneurs dans un pod (par exemple, un serveur d'applications et un serveur proxy ), les conteneurs sont gérés comme un seul objet et partagent les ressources du pod.
  • Déploiement . Dans Kubernetes, le déploiement est un objet qui est une collection de pods identiques. Le déploiement exécute plusieurs répliques de pods répartis sur les nœuds du cluster. Le déploiement remplace automatiquement les pods qui échouent ou ne répondent pas.
  • Service Kubernetes . Lorsque vous exécutez le code d'application dans GKE, la connexion entre loadgen et le serveur change. Lorsque vous avez démarré les services sur la machine virtuelle Cloud Shell ou sur l'ordinateur, vous avez envoyé des demandes au serveur sur localhost: 8080 . Après le déploiement sur GKE, les pods s'exécutent sur les nœuds disponibles. Par défaut, vous ne pouvez pas contrôler sur quel pod hôte s'exécute, les pods n'ont donc pas d'adresse IP permanente.
    Pour obtenir l'adresse IP du serveur , vous devez définir l'abstraction du réseau au-dessus des pods. Il s'agit du service Kubernetes . Le service Kubernetes fournit un point de terminaison permanent pour un ensemble de modules. Il existe plusieurs types de services . le serveur utilise un LoadBalancer , qui fournit une adresse IP externe pour contacter le serveur depuis l'extérieur du cluster.
    Kubernetes dispose également d'un système DNS intégré qui attribue des noms DNS (par exemple, helloserver.default.cluster.local ) aux services. Grâce à cela, les pods du cluster communiquent avec d'autres pods du cluster à une adresse fixe. Le nom DNS ne peut pas être utilisé en dehors du cluster, comme sur Cloud Shell ou sur un ordinateur.

Manifestes Kubernetes


Lorsque vous avez démarré l'application à partir du code source, vous avez utilisé la commande impérative python3


server.py


L'impératif implique le verbe: "faites-le".


Kubernetes utilise un modèle déclaratif . Cela signifie que nous ne disons pas à Kubernetes ce qui doit être fait exactement, mais décrivons l'état souhaité. Par exemple, Kubernetes démarre et arrête les modules si nécessaire, de sorte que l'état réel du système soit tel que souhaité.


Vous spécifiez l'état souhaité dans les manifestes ou les fichiers YAML . Le fichier YAML contient des spécifications pour un ou plusieurs objets Kubernetes.


L'exemple contient le fichier YAML pour le serveur et loadgen . Chaque fichier YAML indique l'état souhaité de l'objet de déploiement et du service Kubernetes.


server.yaml


 apiVersion: apps/v1 kind: Deployment metadata: name: helloserver spec: selector: matchLabels: app: helloserver replicas: 1 template: metadata: labels: app: helloserver spec: terminationGracePeriodSeconds: 5 restartPolicy: Always containers: - name: main image: gcr.io/google-samples/istio/helloserver:v0.0.1 imagePullPolicy: Always

  • kind indique le type d'objet.
  • metadata.name indique le nom du déploiement.
  • La première spécification de champ contient une description de l'état souhaité.
  • spec.replicas indique le nombre souhaité de pods.
  • La section spec.template définit le modèle de pod . Dans la spécification des pods, il y a un champ d' image où le nom de l'image à extraire du registre de conteneurs est indiqué.

Le service est défini comme suit:


 apiVersion: v1 kind: Service metadata: name: hellosvc spec: type: LoadBalancer selector: app: helloserver ports: - name: http port: 80 targetPort: 8080

  • LoadBalancer : les clients envoient des requêtes à l'adresse IP de l'équilibreur de charge, qui a une adresse IP fixe et qui est accessible depuis l'extérieur du cluster.
  • targetPort : comme vous vous en souvenez, la commande EXPOSE 8080 dans le Dockerfile n'a pas fourni de ports. Vous fournissez le port 8080 afin de pouvoir atteindre le conteneur du serveur depuis l'extérieur du cluster. Dans notre cas, hellosvc.default.cluster.local: 80 (nom abrégé: hellosvc ) correspond au port 8080 de l' adresse IP du pod helloserver .
  • port : il s'agit du numéro de port auquel les autres services du cluster enverront des demandes.

loadgen.yaml


L'objet de déploiement dans loadgen.yaml est similaire à server.yaml . La différence est que l'objet de déploiement contient une section env . Il définit les variables d'environnement dont loadgen a besoin et que vous définissez lorsque vous avez démarré l'application à partir du code source.


 apiVersion: apps/v1 kind: Deployment metadata: name: loadgenerator spec: selector: matchLabels: app: loadgenerator replicas: 1 template: metadata: labels: app: loadgenerator spec: terminationGracePeriodSeconds: 5 restartPolicy: Always containers: - name: main image: gcr.io/google-samples/istio/loadgen:v0.0.1 imagePullPolicy: Always env: - name: SERVER_ADDR value: "http://hellosvc:80/" - name: REQUESTS_PER_SECOND value: "10" resources: requests: cpu: 300m memory: 256Mi limits: cpu: 500m memory: 512Mi

Étant donné que loadgen n'accepte pas les demandes entrantes, ClusterIP est spécifié pour le champ type . Ce type fournit une adresse IP fixe que les services du cluster peuvent utiliser, mais cette adresse IP n'est pas fournie aux clients externes.


 apiVersion: v1 kind: Service metadata: name: loadgensvc spec: type: ClusterIP selector: app: loadgenerator ports: - name: http port: 80 targetPort: 8080

Déployer des conteneurs dans GKE


1) Accédez au répertoire où se trouve l'exemple de serveur :


 cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

2) Ouvrez server.yaml dans un éditeur de texte.
3) Remplacez le nom dans le champ d' image par le nom de votre image Docker.


 image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

Remplacez PROJECT_ID par l'identifiant de votre projet GCP.
4) Enregistrez et fermez server.yaml .
5) Développez le fichier YAML dans Kubernetes:


 kubectl apply -f server.yaml

Une fois terminée, la commande émet le code suivant:


 deployment.apps/helloserver created service/hellosvc created

6) Allez dans le répertoire où se trouve loadgen :


 cd ../loadgen

7) Ouvrez loadgen.yaml dans un éditeur de texte.
8) Remplacez le nom dans le champ d' image par le nom de votre image Docker.


 image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

Remplacez PROJECT_ID par l'identifiant de votre projet GCP.
9) Enregistrez et fermez loadgen.yaml , fermez l'éditeur de texte.
10) Développez le fichier YAML dans Kubernetes:


 kubectl apply -f loadgen.yaml

Une fois terminée, la commande émet le code suivant:


 deployment.apps/loadgenerator created service/loadgensvc created

11) Vérifiez l'état des foyers:


 kubectl get pods

La commande affiche l'état:


 NAME READY STATUS RESTARTS AGE helloserver-69b9576d96-mwtcj 1/1 Running 0 58s loadgenerator-774dbc46fb-gpbrz 1/1 Running 0 57s

12) Extrayez les journaux d'application du pod loadgen . Remplacez POD_ID par l'identifiant de la réponse précédente.


 kubectl logs loadgenerator-POD_ID

13) Obtenez les IP hellosvc externes:


 kubectl get service

La réponse de la commande ressemble à ceci:


 NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hellosvc LoadBalancer 10.81.15.158 192.0.2.1 80:31127/TCP 33m kubernetes ClusterIP 10.81.0.1 <none> 443/TCP 93m loadgensvc ClusterIP 10.81.15.155 <none> 80/TCP 4m52s

14) Envoyez une demande à hellosvc : remplacez EXTERNAL_IP par l'adresse IP externe de hellosvc .


 curl http://EXTERNAL_IP

Tackle Istio


Vous avez déjà déployé une application sur GKE. loadgen peut utiliser Kubernetes DNS ( hellosvc: 80 ) pour envoyer des requêtes au serveur , et vous pouvez envoyer des requêtes au serveur à une adresse IP externe. Bien que Kubernetes possède de nombreuses fonctionnalités, certaines informations sur les services font défaut:


  • Comment les services interagissent-ils? Quelle est la relation entre les services? Comment est le trafic entre les services? Vous savez que loadgen envoie des requêtes au serveur , mais imaginez que vous ne savez rien de l'application. Pour répondre à ces questions, nous regardons la liste des foyers en cours d'exécution dans GKE.
  • Mesures . Combien de temps le serveur répond-il à une demande entrante? Combien de requêtes par seconde vont au serveur? Donne-t-il des messages d'erreur?
  • Informations de sécurité . Le trafic entre loadgen et le serveur est-il simplement via HTTP ou mTLS ?

Istio répond à toutes ces questions. Pour ce faire, Istio place un proxy side-car Envoy dans chaque pod. Le proxy Envoy intercepte tout le trafic entrant et sortant vers les conteneurs d'applications. Cela signifie que le serveur et loadgen reçoivent les proxys side-car Envoy et que tout le trafic de loadgen vers le serveur passe par les proxies Envoy.


Les connexions entre les proxys Envoy forment un maillage de service. L'architecture de maillage de service fournit une couche de contrôle sur Kubernetes.



Une fois les proxys Envoy exécutés dans leurs conteneurs, Istio peut être installé au-dessus du cluster GKE, presque sans changer le code d'application. Mais vous avez fait un peu de travail pour préparer l'application pour la gestion en utilisant Istio:


  • Services pour tous les conteneurs. Les déploiements serveur et loadgen sont liés par le service Kubernetes. Même loadgen , qui ne reçoit pas les demandes entrantes, dispose d'un service.
  • Les ports des services doivent avoir des noms. Bien que les ports de service puissent être laissés sans nom dans GKE, Istio nécessite un nom de port conformément à son protocole. Dans le fichier YAML, le port du serveur est appelé http car le serveur utilise le protocole HTTP . Si le service utilisait gRPC , vous nommeriez le port grpc .
  • Les déploiements sont marqués. Par conséquent, vous pouvez utiliser les fonctionnalités de gestion du trafic d'Istio, par exemple, pour partager le trafic entre les versions du même service.

Installer Istio


Il existe deux façons d'installer Istio. Vous pouvez activer l'extension Istio sur GKE ou installer la version open source d'Istio sur un cluster. Avec Istio sur GKE, vous pouvez facilement gérer l'installation et la mise à niveau d'Istio dans le cadre du cycle de vie du cluster GKE. Si vous avez besoin de la dernière version d'Istio ou de plus de contrôle sur la configuration du panneau de configuration Istio, installez la version open source au lieu de l'extension Istio sur GKE. Pour décider de l'approche, lisez l'article Ai-je besoin d'Istio sur GKE? .


Sélectionnez une option, étudiez le manuel approprié et suivez les instructions pour installer Istio sur le cluster. Si vous souhaitez utiliser Istio avec votre application nouvellement déployée, activez l'incorporation de sidecar pour l'espace de noms par défaut .


Le nettoyage


Pour éviter de facturer votre compte Google Cloud Platform pour les ressources que vous avez utilisées dans ce guide, supprimez le cluster de conteneurs lors de l'installation d'Istio et de jouer avec l'exemple d'application. Cela supprimera toutes les ressources de cluster, telles que les instances de calcul, les disques et les ressources réseau.


Et ensuite?


Source: https://habr.com/ru/post/fr469515/

More articles:


All Articles