ProHoster > Blog > administration > Préparer une candidature pour Istio

Préparer une candidature pour Istio

Préparer une candidature pour Istio

Istio est un outil pratique pour connecter, sécuriser et surveiller les applications distribuées. Istio utilise diverses technologies pour exécuter et gérer des logiciels à grande échelle, notamment des conteneurs pour empaqueter le code d'application et les dépendances à déployer, 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 ces outils et concepts vous sont déjà familiers, n'hésitez pas à sauter ce tutoriel et à passer directement à la section Installer Istio sur Google Kubernetes Engine (GKE) ou installer une extension Istio sur GKE.

Il s'agit d'un guide étape par étape dans lequel nous parcourirons l'ensemble du processus, du code source au conteneur GKE, pour vous donner une compréhension de base de ces technologies à travers un exemple. Vous découvrirez également comment Istio exploite la puissance de ces technologies. Cela suppose que vous ne connaissez rien aux conteneurs, à Kubernetes, aux maillages de services ou à Istio.

Tâches

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

  1. Apprendre une application simple Hello World avec plusieurs services.
  2. Exécutez l'application à partir du code source.
  3. Conditionnement de l'application dans des conteneurs.
  4. Création d'un cluster Kubernetes.
  5. Déployer des conteneurs dans un cluster.

Avant de commencer

Suivez les instructions pour activer l'API Kubernetes Engine :

  1. Aller à Page du moteur Kubernetes dans la console Google Cloud Platform.
  2. Créez ou sélectionnez un projet.
  3. Attendez que l'API et les services associés soient activés. Cela peut prendre quelques minutes.
  4. Assurez-vous que la facturation est configurée pour votre projet Google Cloud Platform. Découvrez comment activer la facturation.

Dans ce tutoriel, vous pouvez utiliser Cloud Shell, qui prépare la machine virtuelle g1-small dans Google Compute Engine avec Linux basé sur Debian ou un ordinateur 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) sont entièrement configurés.
  • Outils de ligne de commande gcloud, docker, jet и kubectl, que nous utiliserons sont déjà installés.
  • Vous en avez plusieurs à choisir éditeurs de texte:
    1. Éditeur de code, qui s'ouvre avec l'icône de modification en haut de la fenêtre Cloud Shell.
    2. Emacs, Vim ou Nano, qui s'ouvrent depuis la ligne de commande dans Cloud Shell.

Utiliser Cloud Shell:

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

Préparer une candidature pour Istio

Dans la partie inférieure Console GCP Une session Cloud Shell avec une ligne de commande s'ouvrira dans une nouvelle fenêtre.

Préparer une candidature pour Istio

Option B : utilisation locale des outils de ligne de commande

Si vous travaillez sur un ordinateur exécutant Linux ou macOS, vous devrez configurer et installer les composants suivants :

  1. Personnaliser Environnement de développement Python 3 et Python 2.

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

  3. Fixer kubectl - outil de ligne de commande pour travailler avec Kubernetes.

    gcloud components install kubectl

  4. Fixer Édition communautaire Docker (CE). Vous utiliserez l'outil de ligne de commande dockerpour créer des images de conteneur pour l'exemple d'application.

  5. Installer l'outil Contrôle de version Gitpour obtenir l’exemple d’application sur GitHub.

Télécharger un exemple de code

  1. Téléchargez le code source bonjour le serveur:

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

  2. Accédez au répertoire d'exemple de code :

    cd istio-samples/sample-apps/helloserver

Explorer une application avec plusieurs services

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

  • serveur: serveur simple avec un seul point de terminaison OBTENIR, /, qui affiche "hello world" sur la console.
  • générateur de charge: script qui envoie du trafic vers serveur, avec un nombre configurable de requêtes par seconde.

Préparer une candidature pour Istio

Exécuter une application à partir du code source

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

python3 server/server.py

Lorsque vous exécutez serveur ce qui suit s'affiche :

INFO:root:Starting server...

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

curl http://localhost:8080

réponses du serveur :

Hello World!

4) Depuis le répertoire où vous avez téléchargé l'exemple de code, accédez au répertoire qui contient générateur de charge:

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) Lancement virtualenv:

virtualenv --python python3 env

7) Activez l'environnement virtuel :

source env/bin/activate

8) Définir les exigences pour générateur de charge:

pip3 install -r requirements.txt

9) Lancement générateur de charge:

python3 loadgen.py

Lorsque vous exécutez générateur de charge affiche quelque chose comme 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 serveur affiche les messages suivants sur 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'ensemble de l'application s'exécute sur un seul hôte (ordinateur local ou machine virtuelle Cloud Shell). Vous pouvez donc utiliser localhostenvoyer des demandes à serveur.
10) Pour arrêter générateur de charge и serveur, Entrer Ctrl-c dans chaque fenêtre de terminal.
11) Dans la fenêtre du terminal générateur de charge désactiver l'environnement virtuel :

deactivate

Conditionner une application dans des conteneurs

Pour exécuter l'application sur GKE, vous devez empaqueter l'exemple d'application - serveur и générateur de charge - dans conteneurs. Un conteneur est un moyen de packager une application pour l’isoler de son environnement.

Pour empaqueter une application dans un conteneur, vous avez besoin Dockerfile. Dockerfile est un fichier texte qui définit les commandes permettant de créer le code source de l'application et ses dépendances dans Image Docker. Une fois créée, vous téléchargez l'image dans un registre de conteneurs tel que Docker Hub ou Registre des conteneurs.

L'exemple a déjà Dockerfile pour serveur и générateur de charge avec toutes les commandes nécessaires pour collecter des images. Ci-dessous - 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/*

# 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" ]

  • Équipe DE python : 3-slim comme base demande à Docker d'utiliser la dernière version Image Python 3 comme base.
  • Équipe COPIE. . copie les fichiers sources dans le répertoire de travail actuel (dans notre cas uniquement serveur.py) au système de fichiers du conteneur.
  • POINT D'ACCÈS 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 serveur.py à partir du code source.
  • Équipe EXPOSER indique que serveur attend les données via le port 8080. Cette équipe n'est pas fournit des ports. Il s'agit d'une sorte de documentation nécessaire pour ouvrir le port 8080 lors du démarrage du conteneur.

Préparer la conteneurisation de votre application

1) Définissez les variables d'environnement suivantes. Remplacer ID_PROJET à votre ID de projet GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Utiliser des valeurs ID_PROJET и GCR_REPO vous marquez l'image Docker lorsque vous la créez et la transférez vers un registre de conteneurs privé.

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

gcloud config set project $PROJECT_ID

3) Définir 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 Container Registry est activé dans le projet GCP.

gcloud services enable containerregistry.googleapis.com

Serveur de conteneurisation

  1. Allez dans le répertoire où se trouve l'exemple serveur:

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

  2. Assemblez l'image en utilisant Dockerfile et les 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 la balise Docker. Il s'agit du nom de l'image que vous utilisez lors du déploiement du conteneur.

  1. Téléchargez l'image dans Container Registry : 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Conteneurisation de Loadgen

1) Allez dans le répertoire où se trouve l'exemple générateur de charge:

cd ../loadgen

2) Récupérez l'image :

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

3) Téléchargez l'image dans Container Registry :

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

Afficher une liste d'images

Examinez la liste des images dans le référentiel et vérifiez que les images ont été téléchargées :

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

La commande affiche les noms des images nouvellement téléchargé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 une machine virtuelle Cloud Shell ou sur un ordinateur avec la commande docker courir. Mais dans un environnement de production, vous avez besoin d’un moyen d’orchestrer les conteneurs de manière centralisée. Par exemple, vous avez besoin d'un système qui garantit que les conteneurs sont toujours en cours d'exécution, et vous avez besoin d'un moyen d'augmenter et de faire tourner des instances de conteneurs supplémentaires si le trafic augmente.

Pour exécuter des applications conteneurisées, vous pouvez utiliser GKE. GKE est une plate-forme d'orchestration de conteneurs qui regroupe des machines virtuelles dans un cluster. Chaque machine virtuelle est appelée un nœud. 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éer un cluster GKE :

1) Créez un cluster :

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

Équipe gcloud crée un cluster prêt à l'emploi dans le projet GCP et la zone par défaut que vous avez spécifiés. Pour exécuter Istio, nous vous recommandons d'avoir au moins 4 nœuds et une machine virtuelle n1-standard-2.

L'équipe crée le cluster en quelques minutes. Lorsque le cluster est prêt, la commande affiche quelque chose comme ceci сообщение.

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

gcloud container clusters get-credentials istioready

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

kubectl get nodes

La commande produit 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 une application sur GKE :

Préparer une candidature pour Istio

Avant de déployer des conteneurs dans GKE, découvrez les concepts clés de Kubernetes. Il y a des liens à la toute fin 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 qui peuvent être considérés comme une unité unique dans laquelle vous déployez une application conteneurisée.
  • Gousses. 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 des conteneurs de serveurs et générateur de charge dans des cosses séparées. Lorsqu'il y a plusieurs conteneurs dans un pod (par exemple, un serveur d'applications et Serveur proxy), les conteneurs sont gérés comme une entité unique et partagent les ressources du pod.
  • Déploiements. Dans Kubernetes, un déploiement est un objet qui est une collection de pods identiques. Le déploiement lance plusieurs réplicas de pods distribués sur les nœuds du cluster. Le déploiement remplace automatiquement les pods en panne ou qui ne répondent pas.
  • Service Kubernetes. Lors de l'exécution du code d'application dans GKE, la connexion entre générateur de charge и serveur. Lorsque vous avez démarré des services sur une machine virtuelle ou un bureau Cloud Shell, vous avez envoyé des requêtes à serveur по адресу localhost: 8080. Une fois déployés sur GKE, les pods sont exécutés sur les nœuds disponibles. Par défaut, vous n'avez aucun contrôle sur le nœud sur lequel le pod s'exécute, vous gousses pas d'adresses IP permanentes.
    Pour obtenir une adresse IP pour serveur, vous devez définir une abstraction réseau au-dessus des pods. C'est ce que c'est Service Kubernetes. Le service Kubernetes fournit un point de terminaison persistant pour un ensemble de pods. Il y a un peu types de prestations. serveur utilise Équilibreur de charge, qui fournit une adresse IP externe à contacter serveur de l’extérieur du cluster.
    Kubernetes dispose également d'un système DNS intégré qui attribue des noms DNS (par exemple, bonjourserver.default.cluster.local) prestations de service. Grâce à cela, les pods du cluster communiquent avec les autres pods du cluster à une adresse constante. Le nom DNS ne peut pas être utilisé en dehors du cluster, comme dans Cloud Shell ou sur un ordinateur.

Kubernetes se manifeste

Lorsque vous avez exécuté l'application à partir des sources, vous avez utilisé la commande impérative python3

serveur.py

L'impératif implique un verbe : « fais ceci ».

Utilisations de Kubernetes modèle déclaratif. Cela signifie que nous ne disons pas exactement à Kubernetes quoi faire, mais décrivons plutôt l'état souhaité. Par exemple, Kubernetes démarre et arrête les pods selon les besoins pour maintenir l'état réel du système cohérent avec l'état souhaité.

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

L'exemple contient un fichier YAML pour serveur и générateur de charge. Chaque fichier YAML spécifie l'état souhaité de l'objet de déploiement et du service Kubernetes.

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

  • genre indique le type de l'objet.
  • métadonnées.nom spécifie le nom du déploiement.
  • Premier champ spec contient une description de l’état souhaité.
  • spec.réplicas indique le nombre de dosettes souhaité.
  • Section spécification.modèle définit un modèle de pod. Il y a un champ dans la spécification du pod image, qui spécifie le nom de l'image qui doit être extraite de Container Registry.

La prestation est définie comme suit :

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

  • Équilibreur de charge: les clients envoient des requêtes à l'adresse IP de l'équilibreur de charge, qui possède une adresse IP persistante et est accessible depuis l'extérieur du cluster.
  • portcible: comme vous vous en souvenez, l'équipe EXPOSER 8080 в Dockerfile n'a pas fourni de ports. Vous fournissez le port 8080afin que vous puissiez contacter le conteneur serveur en dehors du cluster. Dans notre cas hellosvc.default.cluster.local:80 (nom court: bonjourvc) correspond au port 8080 Adresses IP des pods bonjour le serveur.
  • port: Il s'agit du numéro de port auquel les autres services du cluster enverront des requêtes.

loadgen.yaml

Objet de déploiement vers loadgen.yaml ressemble à serveur.yaml. La différence est que l'objet de déploiement contient une section env. Il définit les variables d'environnement nécessaires générateur de charge et que vous avez installé lors de l'exécution de l'application à partir des sources.

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

Heure générateur de charge n'accepte pas les demandes entrantes, pour le champ type indiqué ClusterIP. Ce type fournit une adresse IP persistante que les services du cluster peuvent utiliser, mais cette adresse IP n'est pas exposée 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) Allez dans le répertoire où se trouve l'exemple serveur:

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

2) Ouvert serveur.yaml dans un éditeur de texte.
3) Remplacez le nom dans le champ image au nom de votre image Docker.

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

Remplacer ID_PROJET à votre ID de projet GCP.
4) Enregistrez et fermez serveur.yaml.
5) Déployez le fichier YAML sur Kubernetes :

kubectl apply -f server.yaml

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

deployment.apps/helloserver created
service/hellosvc created

6) Allez dans le répertoire où générateur de charge:

cd ../loadgen

7) Ouvert loadgen.yaml dans un éditeur de texte.
8) Remplacez le nom dans le champ image au nom de votre image Docker.

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

Remplacer ID_PROJET à votre ID de projet GCP.
9) Enregistrez et fermez loadgen.yaml, fermez l'éditeur de texte.
10) Déployez le fichier YAML sur Kubernetes :

kubectl apply -f loadgen.yaml

Une fois terminée, la commande produit 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) Extraire les journaux d'application du pod générateur de charge. Remplacer POD_ID à l'identifiant de la réponse précédente.

kubectl logs loadgenerator-POD_ID

13) Obtenir des adresses IP externes bonjourvc:

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 à bonjourvc: remplacer EXTERNAL_IP vers une adresse IP externe bonjourvc.

curl http://EXTERNAL_IP

Allons affronter Istio

Vous disposez déjà d'une application déployée sur GKE. générateur de charge peut utiliser le DNS Kubernetes (bonjourvc:80) pour envoyer des demandes à serveuret vous pouvez envoyer des demandes à serveur par adresse IP externe. Bien que Kubernetes possède de nombreuses fonctionnalités, certaines informations manquent sur les services :

  • Comment les services interagissent-ils ? Quelles sont les relations entre les services ? Comment se déroule le trafic entre les services ? Êtes-vous conscient que générateur de charge envoie des demandes à serveur, mais imaginez que vous ne savez rien de l'application. Pour répondre à ces questions, examinons la liste des pods en cours d'exécution dans GKE.
  • Métrique. Combien de temps serveur répond à une demande entrante ? Combien de requêtes par seconde sont reçues par le serveur ? Est-ce que ça donne des messages d'erreur ?
  • Information de sécurité. Trafic entre générateur de charge и serveur passe juste à travers HTTP ou par mTLS?

Istio répond à toutes ces questions. Pour ce faire, Istio place un proxy side-car Envoyé dans chaque gousse. Le proxy Envoy intercepte tout le trafic entrant et sortant vers les conteneurs d'applications. Cela signifie que serveur и générateur de charge recevoir via le proxy side-car Envoy et tout le trafic de générateur de charge к serveur passe par le proxy Envoy.

Les connexions entre les proxys Envoy forment un maillage de services. L'architecture de maillage de services fournit une couche de contrôle au-dessus de Kubernetes.

Préparer une candidature pour Istio

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

  • Services pour tous les conteneurs. Vers les déploiements serveur и générateur de charge lié au service Kubernetes. Même générateur de charge, qui ne reçoit pas de demandes entrantes, il existe un service.
  • Les ports des services doivent avoir des noms. Bien que les ports de service puissent ne pas être nommés dans GKE, Istio vous demande de spécifier nom du port conformément à son protocole. Dans le fichier YAML, le port pour serveur Il a appelé httpparce que le serveur utilise le protocole HTTP. Si service utilisé gRPC, vous nommeriez le port grpc.
  • Les déploiements sont signalés. Par conséquent, vous pouvez utiliser les fonctionnalités de gestion du trafic d'Istio, telles que la répartition du trafic entre les versions du même service.

Installation

Il existe deux manières d'installer Istio. Peut activer Istio sur l'extension GKE ou installer la version open source d'Istio sur le cluster. Avec Istio sur GKE, vous pouvez facilement gérer les installations et les mises à niveau d'Istio tout au long du cycle de vie du cluster GKE. Si vous souhaitez bénéficier de la dernière version d'Istio ou d'un meilleur contrôle sur la configuration de votre 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, consultez le guide approprié et suivez les instructions pour installer Istio sur votre cluster. Si vous souhaitez utiliser Istio avec votre application nouvellement déployée, activer la mise en œuvre du side-car pour l'espace de noms défaut.

nettoyage

Pour éviter d'être facturé sur votre compte Google Cloud Platform pour les ressources que vous avez utilisées dans ce didacticiel, supprimez le cluster de conteneurs une fois que vous avez installé Istio et joué avec l'exemple d'application. Cela supprimera toutes les ressources du cluster, telles que les instances de calcul, les disques et les ressources réseau.

Quelle est la prochaine?

Source: habr.com

Ajouter un commentaire