🥇Préparation de l'application pour Istio

Istio est un outil pratique pour connecter, protéger et surveiller des applications distribuées. Istio utilise différentes technologies pour déployer et gérer des logiciels à grande échelle, y compris des conteneurs pour emballer le code de l'application et ses dépendances pour le déploiement, et Kubernetes pour gérer ces conteneurs. Par conséquent, pour travailler avec Istio, vous devez comprendre comment fonctionne une application multservices basée sur ces technologies. sans Istio. Si ces outils et concepts vous sont déjà familiers, n'hésitez pas à sauter ce guide et à passer directement à la section. Installation d'Istio sur Google Kubernetes Engine (GKE) ou installation de l'extension Istio sur GKE.

Ce guide étape par étape vous présentera l'ensemble du processus, de la source à l'image du conteneur sur GKE, afin de vous donner une vue d'ensemble de ces technologies par l'exemple. Vous verrez également comment Istio tire parti de ces technologies. Il est supposé que vous ne savez rien sur les conteneurs, Kubernetes, le maillage de services ou Istio.

Objectifs

Dans ce guide, vous réaliserez les tâches suivantes :

Explorer une application hello world avec plusieurs services.
Lancer l'application à partir du code source.
Emballer l'application dans des conteneurs.
Créer un cluster Kubernetes.
Déployer des conteneurs dans le cluster.

Avant de commencer

Suivez les instructions pour activer l'API Kubernetes Engine :

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

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

Option A : utiliser Cloud Shell

Avantages de l'utilisation de Cloud Shell :

Environnements de développement Python 2 et Python 3 (y compris virtualenv) complètement configurés.
Outils en ligne de commande gcloud, docker, git et kubectl, que nous allons utiliser, sont déjà installés.
Vous avez le choix entre plusieurs éditeurs de texte:
1. É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:

Allez dans la console GCP.
Cliquez sur le bouton Activer Cloud Shell (Activer Cloud Shell) en haut de la fenêtre de la console GCP.

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

Option B : utiliser les outils de ligne de commande localement

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

Configurez un environnement de développement Python 3 et Python 2.
Installez le Cloud SDK avec l'outil de ligne de commande gcloud.
Installez kubectl — outil de ligne de commande pour travailler avec Kubernetes.
```
gcloud components install kubectl
```
Installez Docker Community Edition (CE). Vous utiliserez l'outil de ligne de commande docker, pour créer des images de conteneurs pour l'exemple d'application.
Installez l'outil de contrôle de version Git, pour obtenir l'exemple d'application à partir de GitHub.

Téléchargement de l'exemple de code

Téléchargez le code source helloserver:

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

Accédez au répertoire de l'exemple de code :
```
cd istio-samples/sample-apps/helloserver
```

Exploration de l'application avec plusieurs services

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

serveur: un serveur simple avec un point de terminaison GET, /, qui affiche « hello world » dans la console.
loadgen: un script qui envoie du trafic vers serveur, avec un nombre configurable de requêtes par seconde.

Exécution de l'application à partir du code source

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

python3 server/server.py

Lors de l'exécution, le message suivant s'affiche : serveur INFO:root:Starting server...

2) Ouvrez une autre fenêtre de terminal pour envoyer des requêtes à

. Si vous utilisez Cloud Shell, cliquez sur l'icône d'ajout pour ouvrir une autre session. serveur3) Envoyez une requête à
curl http://localhost:8080 serveur:

le serveur répond :

4) À partir du répertoire où vous avez téléchargé l'exemple de code, accédez au répertoire contenant

Hello World!

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

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

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

6) Exécutez

virtualenv --python python3 env virtualenv:

7) Activez l'environnement virtuel :

source env/bin/activate

8) Installez les dépendances pour

pip3 install -r requirements.txt loadgen:

9) Exécutez

python3 loadgen.py loadgen:

affiche environ le message suivant :

Lors de l'exécution, le message suivant s'affiche : loadgen Starting loadgen: 2019-05-20 10:44:12.448415 5 request(s) complete to http://localhost:8080

Dans une autre fenêtre de terminal

affiche environ les messages suivants dans la console : serveur 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: */*

127.0.0.1 - - [21/Juin/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:Demande GET,
Chemin: /
En-têtes:
Hôte: localhost:8080
Agent-utilisateur: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Du point de vue du réseau, toute l'application fonctionne sur un seul hôte (ordinateur local ou machine virtuelle Cloud Shell). Il est donc possible d'utiliser localhost, pour envoyer des requêtes à serveur.
10) Pour arrêter loadgen et serveur, entrez Ctrl-c dans chaque fenêtre de terminal.
11) Dans la fenêtre de terminal loadgen désactivez l'environnement virtuel :

deactivate

Emballage de l'application dans des conteneurs

Pour exécuter l'application sur GKE, il faut emballer l'exemple d'application — serveur et loadgen — dans conteneurs. Un conteneur est un moyen d'emballer l'application pour l'isoler de son environnement.

Pour emballer l'application dans un conteneur, il faut Dockerfile. Dockerfile — c'est un fichier texte qui définit les commandes pour construire le code source de l'application et ses dépendances en une image Docker. Après la construction, vous téléchargez l'image dans un registre de conteneurs, comme Docker Hub ou Container Registry.

L'exemple contient déjà Dockerfile pour serveur et loadgen avec toutes les commandes nécessaires pour construire des images. Voici un exemple : Dockerfile pour 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/*

# Activer la journalisation sans tampon
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Récupérer les paquets du builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Ajouter l'application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

Commande FROM python:3-slim as base permet à Docker d'utiliser la dernière image de Python 3 comme base.
Commande COPY . . copie les fichiers source dans le répertoire de travail actuel (dans notre cas, uniquement server.py) dans le système de fichiers du conteneur.
ENTRYPOINT définit la commande qui est utilisée pour exécuter le conteneur. Dans notre cas, cette commande est presque identique à celle que vous avez utilisée pour exécuter server.py à partir du code source.
Commande EXPOSE indique que serveur s'attend à recevoir des données via le port 8080. Cette commande ne fournit pas de ports. C'est une sorte de documentation nécessaire pour ouvrir le port 8080 lors du démarrage du conteneur.

Préparation à la conteneurisation de l'application

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

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Avec les valeurs PROJECT_ID et GCR_REPO vous étiquetez l'image Docker lorsque vous la construisez et l'envoyez à un registre de conteneurs privé.

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

gcloud config set project $PROJECT_ID

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

gcloud config set compute/zone us-central1-b

4) Assurez-vous que le service Container Registry est activé dans le projet GCP.

gcloud services enable containerregistry.googleapis.com

Containerisation du serveur

Accédez au répertoire contenant l'exemple serveur:

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

Construisez l'image à l'aide de Dockerfile et des variables d'environnement que vous avez définies précédemment :
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Paramètre -t représente le tag Docker. C'est le nom de l'image que vous utilisez lors du déploiement du conteneur.

Envoyez l'image vers le Container Registry :

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

Containerisation du loadgen

1) Accédez au répertoire contenant l'exemple loadgen:

cd ../loadgen

2) Construisez l'image :

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

3) Envoyez l'image vers le Container Registry :

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

Afficher la liste des images

Vérifiez la liste des images dans le dépôt et assurez-vous que les images ont été envoyées :

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

La commande retourne les noms des images récemment envoyées :

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

Création d'un cluster GKE.

Ces conteneurs pourraient être exécutés sur une machine virtuelle Cloud Shell ou sur un ordinateur avec la commande docker run. Mais en production, un moyen d'orchestration centralisée des conteneurs est nécessaire. Par exemple, un système est nécessaire pour s'assurer que les conteneurs fonctionnent toujours, et il faut un moyen d'augmenter l'échelle et de lancer des instances supplémentaires des conteneurs en cas d'augmentation du trafic.

Pour exécuter des applications conteneurisées, vous pouvez utiliser GKE. GKE est une plateforme d'orchestration des conteneurs qui regroupe des machines virtuelles en un cluster. Chaque machine virtuelle est appelée un nœud. Les clusters GKE sont basés sur le système open source de gestion des clusters Kubernetes. Kubernetes fournit des mécanismes d'interaction 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

Commande gcloud crée un cluster istioready dans le projet GCP et dans la zone par défaut que vous avez indiquée. Pour exécuter Istio, il est recommandé d'avoir au moins 4 nœuds et une machine virtuelle n1-standard-2.

La commande crée le cluster en quelques minutes. Lorsque le cluster est prêt, la commande retourne quelque chose de similaire message.

2) Indiquez les informations d'identification dans l'outil en ligne de commande kubectl, afin de gérer le cluster :

gcloud container clusters get-credentials istioready

3) Vous pouvez maintenant communiquer avec Kubernetes via kubectl. Par exemple, la commande suivante peut être utilisée pour vérifier l'état des nœuds :

kubectl get nodes

La commande retourne la liste des nœuds :

NOM                                       ÉTAT   RÔLES    ÂGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Prêt       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Prêt       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Prêt       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Prêt       99s    v1.13.6-gke.13

Concepts clés de Kubernetes

Le schéma montre une application sur GKE :

Avant de déployer des conteneurs sur GKE, familiarisez-vous avec les concepts clés de Kubernetes. À la fin, il y a des liens si vous souhaitez en savoir plus.

Nœuds et clusters. Dans GKE, un nœud est une machine virtuelle. Sur d'autres plateformes Kubernetes, un nœud peut être un ordinateur ou une machine virtuelle. Un cluster est un ensemble de nœuds que l'on peut considérer comme un tout, où vous déployez une application conteneurisée.
Pods. Dans Kubernetes, les conteneurs s'exécutent dans des pods. Un pod dans Kubernetes est une unité indivisible. Un pod contient un ou plusieurs conteneurs. Vous déployez les conteneurs server et loadgen dans des pods séparés. Lorsque plusieurs conteneurs se trouvent dans un pod (par exemple, le serveur d'application et proxy), les conteneurs sont gérés comme un seul objet et partagent les ressources du pod.
Déploiements. Dans Kubernetes, un déploiement est un objet représentant un ensemble de pods identiques. Un déploiement exécute plusieurs répliques de pods, réparties sur les nœuds du cluster. Le déploiement remplace automatiquement les pods qui échouent ou qui ne répondent pas.
Service Kubernetes. Lorsque vous exécutez le code de l'application sur GKE, la connexion entre loadgen et serveur. Lorsque vous avez lancé des services sur une machine virtuelle Cloud Shell ou sur un ordinateur, vous envoyiez des requêtes à serveur à l'adresse 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 gérer quel nœud exécute un pod, donc les pods n'ont pas d'adresses IP permanentes.
Pour obtenir une adresse IP pour serveur, il faut définir une abstraction réseau au-dessus des pods. C'est ce qu'est le service Kubernetes. Le service Kubernetes fournit un point d'accès permanent pour un ensemble de pods. Il existe plusieurs types de services. serveur utilise LoadBalancer, qui fournissent une adresse IP externe pour se connecter à serveur depuis l'extérieur du cluster.
De plus, Kubernetes dispose d'un système DNS intégré qui attribue des noms DNS (par exemple, helloserver.default.cluster.local) services. Grâce à cela, les pods à l'intérieur d'un cluster peuvent se connecter à d'autres pods dans le cluster via une adresse permanente. Le nom DNS ne peut pas être utilisé en dehors du cluster, par exemple dans Cloud Shell ou sur un ordinateur.

Manifestes Kubernetes

Lorsque vous avez lancé l'application à partir du code source, vous avez utilisé une commande impérative python3

server.py

L'impérativité implique un verbe : « faites cela ».

Kubernetes utilise un modèle déclaratif. Cela signifie que nous ne disons pas à Kubernetes ce qu'il faut faire, mais décrivons l'état souhaité. Par exemple, Kubernetes démarre et arrête des pods au besoin pour que l'état réel du système corresponde à l'état désiré.

L'état souhaité est spécifié dans les manifestes, ou fichiers YAML. Le fichier YAML contient des spécifications pour un ou plusieurs objets Kubernetes.

L'exemple contient un fichier YAML pour 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.
Le premier champ spec contient la description de l'état souhaité.
spec.replicas indique le nombre souhaité de pods.
Section spec.template définit le modèle du pod. Dans la spécification des pods, il y a un champ image, qui indique le nom de l'image à extraire du Container Registry.

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 du load balancer, qui a une adresse IP permanente et qui est accessible depuis l'extérieur du cluster.
targetPort: comme vous vous en souvenez, la commande EXPOSE 8080 dans Dockerfile ne fournissait pas de ports. Vous exposez le port 8080, afin de pouvoir se connecter au conteneur serveur de l'extérieur du cluster. Dans notre cas, hellosvc.default.cluster.local:80 (nom court : hellosvc) correspond au port 8080 L'adresse IP du pod helloserver.
port: c'est le numéro de port où les autres services du cluster enverront des requêtes.

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. Elle définit les variables d'environnement nécessaires loadgen et que vous avez défini lors du lancement de 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

Un loadgen n'accepte pas les demandes entrantes, pour le champ type est spécifié ClusterIP. Ce type fournit une adresse IP permanente qui peut être utilisée par les services dans le cluster, 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éploiement des conteneurs sur GKE

1) Accédez au répertoire contenant l'exemple 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 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éployez le fichier YAML dans Kubernetes :

kubectl apply -f server.yaml

Après l'exécution réussie, la commande renvoie le code suivant :

deployment.apps/helloserver created
service/hellosvc created

6) Accédez au répertoire où se trouve loadgen:

cd ../loadgen

7) Ouvrez loadgen.yaml dans un éditeur de texte.
8) Remplacez le nom dans le champ 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éployez le fichier YAML dans Kubernetes :

kubectl apply -f loadgen.yaml

Après l'exécution réussie, la commande renvoie le code suivant :

deployment.apps/loadgenerator created
service/loadgensvc created

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

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) Récupérez les journaux de l'application à partir du pod loadgen. Remplacez POD_ID par l'identifiant de la réponse précédente.

kubectl logs loadgenerator-POD_ID

13) Obtenez les adresses IP externes hellosvc:

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                443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155             80/TCP         4m52s

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

curl http://EXTERNAL_IP

Passons à Istio

Vous avez déjà une application déployée sur GKE. loadgen peut utiliser le DNS Kubernetes (hellosvc:80), pour envoyer des requêtes à serveur, et vous pouvez envoyer des requêtes à serveur par l'adresse IP externe. Bien que Kubernetes ait 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 le trafic passe-t-il entre les services ? Vous savez que loadgen envoie des requêtes à serveur, mais imaginez que vous ne sachiez rien de l'application. Pour répondre à ces questions, examinons la liste des pods en cours d'exécution dans GKE.
Métriques. Combien de temps serveur répond à la requête entrante ? Combien de requêtes par seconde arrivent sur le serveur ? Émet-il des messages d'erreur ?
Informations sur la sécurité. Le trafic entre loadgen et serveur passe simplement par . L'augmentation de la performance de Nginx est due à l'utilisation d'une architecture asynchrone gérée par événements, contrairement à un modèle multithread. Cela, combiné à un haut niveau de parallélisme, permet à Nginx de traiter les requêtes avec une mémoire minimale. Cela fait de Nginx une excellente solution pour les serveurs web, qu'il s'agisse de gros ou de petits volumes de trafic. Nginx est une solution mature et entièrement documentée, permettant une configuration facile selon vos besoins. Les développeurs utilisent également Nginx comme proxy inverse pour ou par mTLS?

Toutes ces questions trouvent réponse grâce à Istio. Pour cela, Istio place un proxy sidecar Envoy dans chaque pod. Le proxy Envoy intercepte tout le trafic entrant et sortant vers les conteneurs de l'application. Cela signifie que serveur et loadgen reçoivent par le proxy sidecar Envoy, et tout le trafic de loadgen sur serveur passe par le proxy Envoy.

Les connexions entre les proxies Envoy forment un réseau de services. L'architecture de ce réseau de services offre un niveau de contrôle au-dessus de Kubernetes.

Étant donné que les proxies Envoy s'exécutent dans leurs propres conteneurs, Istio peut être installé au-dessus du cluster GKE sans modifier le code de l'application. Mais vous avez dû faire un certain travail pour préparer l'application à être gérée par Istio :

Services pour chaque conteneur. Chaque déploiement serveur et loadgen est associé à un service Kubernetes. Même celui loadgen, qui ne reçoit pas de requêtes entrantes, a un service.
Les ports dans les services doivent avoir des noms. Bien que dans GKE, les ports des services puissent rester sans nom, Istio exige qu'un nom de port soit spécifié en fonction de son protocole. Dans le fichier YAML, le port pour serveur appelé http, car le serveur utilise le protocole . L'augmentation de la performance de Nginx est due à l'utilisation d'une architecture asynchrone gérée par événements, contrairement à un modèle multithread. Cela, combiné à un haut niveau de parallélisme, permet à Nginx de traiter les requêtes avec une mémoire minimale. Cela fait de Nginx une excellente solution pour les serveurs web, qu'il s'agisse de gros ou de petits volumes de trafic. Nginx est une solution mature et entièrement documentée, permettant une configuration facile selon vos besoins. Les développeurs utilisent également Nginx comme proxy inverse pour. Si service utilisait gRPC, vous appelleriez le port grpc.
Les déploiements sont marqués. Cela vous permet d'utiliser les fonctionnalités de gestion du trafic d'Istio, comme la répartition du trafic entre les versions d'un même service.

Installation d'Istio

Istio peut être installé de deux manières. Vous pouvez activer l'extension Istio sur GKE ou installer la version open-source d'Istio sur le cluster. Avec Istio sur GKE, il est facile de gérer l'installation et la mise à niveau d'Istio dans le cycle de vie du cluster GKE. Si vous avez besoin de la toute dernière version d'Istio ou d'un plus grand contrôle sur la configuration du tableau de bord Istio, installez la version open-source plutôt que l'extension Istio sur GKE. Pour choisir l'approche, lisez l'article Ai-je besoin d'Istio sur GKE ?.

Choisissez une option, consultez le guide correspondant et suivez les instructions pour installer Istio sur le cluster. Si vous souhaitez utiliser Istio avec une application nouvellement déployée, activez l'implémentation des sidecars pour l'espace de noms default.

Nettoyage

Pour éviter que des frais ne soient facturés par votre compte Google Cloud Platform pour les ressources que vous avez utilisées dans ce guide, supprimez le cluster de conteneurs lorsque vous avez installé Istio et que vous avez fini de tester l'exemple d'application. Cela supprimera toutes les ressources du cluster, telles que les instances de calcul, les disques et les ressources réseau.

Et après ?

Découvrez les technologies suivantes :
Découvrez les outils suivants :
Découvrez les concepts de Kubernetes :
1. Clusters
2. Nœuds
3. Pods
4. Services
5. Déploiement

Source : habr.com