🥇Applicatie voorbereiden voor Istio

Istio is een gebruiksvriendelijke tool voor het verbinden, beveiligen en monitoren van gedistribueerde applicaties. Istio maakt gebruik van verschillende technologieën voor het grootschalig implementeren en beheren van software, waaronder containers voor het verpakken van de applicatiecode en afhankelijkheden voor implementatie, en Kubernetes voor het beheer van deze containers. Daarom moet je weten hoe een applicatie met meerdere services die op deze technologieën is gebaseerd, werkt. zonder Istio. Als je al bekend bent met deze tools en concepten, sla deze handleiding dan gerust over en ga direct naar het gedeelte. Istio installeren op Google Kubernetes Engine (GKE) of het installeren van de extensie Istio op GKE.

Dit is een stapsgewijze handleiding waarin we het gehele proces van broncode naar container op GKE bekijken, zodat je een basisbegrip van deze technologieën op basis van een voorbeeld krijgt. Je zult ook zien hoe Istio gebruikmaakt van de mogelijkheden van deze technologieën. Er wordt aangenomen dat je niets weet over containers, Kubernetes, service mesh of Istio.

Taken

In deze handleiding voer je de volgende taken uit:

Verkenning van een eenvoudige hello world-applicatie met meerdere services.
Starten van de applicatie uit de broncode.
Verpakken van de applicatie in containers.
Creëren van een Kubernetes-cluster.
Implementeren van containers in het cluster.

Voordat je begint

Volg de instructies om de Kubernetes Engine API in te schakelen:

Ga naar de Kubernetes Engine-pagina in de Google Cloud Platform-console.
Creëer of selecteer een project.
Wacht totdat de API en verwante diensten zijn ingeschakeld. Dit kan enkele minuten duren.
Zorg ervoor dat de facturering is ingesteld voor het Google Cloud Platform-project. Leer hoe je facturering inschakelt..

In deze handleiding kun je Cloud Shell gebruiken, die een virtuele machine voorbereidt. g1-small op Google Compute Engine met Debian-gebaseerde Linux, of een computer met Linux of macOS.

Optie A: gebruik maken van Cloud Shell

Voordelen van het gebruik van Cloud Shell:

Ontwikkelomgevingen voor Python 2 en Python 3 (inclusief virtualenv) zijn volledig geconfigureerd.
De commandoregeltools gcloud, docker, git en kubectl, die we gaan gebruiken, zijn al geïnstalleerd.
Je hebt de keuze uit verschillende teksteditors.:
1. Code-editor, die opent met het bewerkingspictogram bovenaan het Cloud Shell-venster.
2. Emacs, Vim of Nano, die openen vanuit de commandoregel in Cloud Shell.

Om gebruik te maken van Cloud Shell:

Ga naar de GCP-console.
Klik op de knop Activeer Cloud Shell. (Cloud Shell activeren) in de bovenkant van het GCP-consolevenster.

Onderin GCP-console geopend in een nieuw venster met een Cloud Shell-sessie met een opdrachtregel.

Optie B: gebruik van de opdrachtregeltools lokaal

Als je werkt op een computer met Linux of macOS, moet je de volgende componenten instellen en installeren:

Configureer de ontwikkelomgeving Python 3 en Python 2.
Installeer de Cloud SDK met de opdrachtregeltool gcloud.
Installeer kubectl — de opdrachtregeltool voor interactie met Kubernetes.
```
gcloud components install kubectl
```
Installeer Docker Community Edition (CE). Je zult de opdrachtregeltool gebruiken docker, om containerbeelden voor het voorbeeldapplicatie te maken.
Installeer de tool versiebeheer Git, om het voorbeeldapplicatie van GitHub te krijgen.

Voorbeeldcode downloaden

Download de broncode helloserver:

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

Ga naar de map met voorbeeldcode:

cd istio-samples/sample-apps/helloserver

Verken een applicatie met meerdere services

Het voorbeeldapplicatie is geschreven in Python en bestaat uit twee componenten die communiceren via REST:

server: een eenvoudige server met één eindpunt GET, /, die "hello world" naar de console schrijft.
loadgen: een script dat verkeer naar server, met een instelbaar aantal verzoeken per seconde, stuurt.

Start de applicatie vanuit de broncode

Om het voorbeeldapplicatie te verkennen, start je het in Cloud Shell of op je computer.
1) In de map istio-samples/sample-apps/helloserver voer uit server:

python3 server/server.py

Bij het uitvoeren verschijnt het volgende: server INFO:root:Server starten...

2) Open een ander terminalvenster om verzoeken naar

. Als je Cloud Shell gebruikt, klik op het plusteken om een andere sessie te openen. server3) Stuur een verzoek naar
curl http://localhost:8080 server:

de server reageert:

Hello World!

4) Ga vanuit de map waar je de voorbeeldcode hebt gedownload naar de map die bevat

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

5) Maak de volgende omgevingsvariabelen aan:

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

6) Start

virtualenv --python python3 env virtualenv:

7) Activeer de virtuele omgeving:

source env/bin/activate

8) Installeer de vereisten voor

pip3 install -r requirements.txt loadgen:

9) Start

python3 loadgen.py loadgen:

geeft ongeveer het volgende bericht weer:

Bij het uitvoeren verschijnt het volgende: loadgen Starten loadgen: 2019-05-20 10:44:12.448415 5 verzoek(en) voltooid naar http://localhost:8080

In een ander terminalvenster

geeft ongeveer de volgende berichten weer: server 127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET verzoek, Pad: / Headers: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*

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

Vanuit het netwerkperspectief draait de hele applicatie op één host (lokale computer of virtuele machine Cloud Shell). Daarom kunt u localhost, verzoeken indienen bij server.
10) Om te stoppen, typt u loadgen en serverCtrl-c in elk terminalvenster. 11) In het terminalvenster deactiveert u de virtuele omgeving:
deactivate loadgen Applicatie verpakken in containers

Om de applicatie op GKE uit te voeren, moet u een voorbeeldapplicatie verpakken —

containers

. Een container is een manier om een applicatie te verpakken, zodat deze van de omgeving is geïsoleerd. server en loadgen — tot containers. Een container is een manier om een applicatie te verpakken, zodat deze van de omgeving is geïsoleerd.

Om de applicatie in een container te verpakken, heeft u Dockerfile. Dockerfile een tekstbestand nodig waarin de commando's worden gedefinieerd om de broncode van de applicatie en de afhankelijkheden in een Docker-image. Na het bouwen laadt u de image naar een containerregister, zoals Docker Hub of Container Registry.

Het voorbeeld heeft al Dockerfile voor server en loadgen met alle benodigde commando's om de afbeeldingen te bouwen. Hieronder: Dockerfile voor server:

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/*

# Schakel onbewerkte logging in
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Pak pakketten van de builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Voeg de applicatie toe
COPY . .

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

Opdracht FROM python:3-slim as base dwingt Docker om de laatste Python 3 image als basis te gebruiken.
Opdracht COPY. . kopieert de bronbestanden naar de huidige werkdirectory (in ons geval alleen server.py) naar het bestandssysteem van de container.
ENTRYPOINT definieert de commando die wordt gebruikt om de container te starten. In ons geval komt dit commando bijna overeen met het commando dat u gebruikte om te starten server.py uit de broncode.
Opdracht EXPOSE geeft aan dat server gegevens via poort verwacht. 8080. Dit commando biedt geen poorten aan. Dit is iets als de documentatie die nodig is om de poort te openenbij het starten van de container. 8080 Voorbereiden op het containeriseren van de applicatie

1) Stel de volgende omgevingsvariabelen in. Vervang

door uw GCP-project-ID. PROJECT_ID export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Met de waarden van

GCR_REPO PROJECT_ID en merkt u de Docker-image wanneer u deze bouwt en naar het privé Container Registry verzendt. 2) Stel het standaard GCP-project in voor de commandoregeltool

gcloud config set project $PROJECT_ID gcloud.

3) Stel de standaardzone in voor de commandoregeltool

gcloud config set compute/zone us-central1-b gcloud.

4) Zorg ervoor dat de service Container Registry is ingeschakeld in het GCP-project.

gcloud services enable containerregistry.googleapis.com

gcloud services enable containerregistry.googleapis.com

Containerisatie server

Ga naar de map waar het voorbeeld zich bevindt server:

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

Bouw de afbeelding met behulp van Dockerfile en de omgevingsvariabelen die je eerder hebt gedefinieerd:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameter -t vertegenwoordigt de Docker-tag. Dit is de naam van de afbeelding die je gebruikt bij het implementeren van de container.

Stuur de afbeelding naar de Container Registry:

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

Containerisatie loadgen

1) Ga naar de map waar het voorbeeld zich bevindt loadgen:

cd ../loadgen

2) Bouw de afbeelding:

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

3) Stuur de afbeelding naar de Container Registry:

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

Bekijk de lijst met afbeeldingen

Bekijk de lijst met afbeeldingen in de repository en zorg ervoor dat de afbeeldingen zijn verstuurd:

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

Het commando geeft de namen van de zojuist verzonden afbeeldingen:

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

Een GKE-cluster maken.

Deze containers zouden kunnen worden uitgevoerd op een virtuele machine Cloud Shell of op een computer met het commando docker run. Maar in een productieomgeving is een manier nodig om containers centraal te orkestreren. Bijvoorbeeld is er een systeem nodig dat ervoor zorgt dat containers altijd draaien, en er is een manier nodig om te schalen en extra exemplaren van containers te starten als de verkeersstroom toeneemt.

Voor het draaien van containerapplicaties kan je gebruiken GKE. GKE is een containerorkestratieplatform dat virtuele machines in een cluster verenigt. Elke virtuele machine wordt een node genoemd. GKE-clusters zijn gebaseerd op het open-source clusterbeheersysteem Kubernetes. Kubernetes biedt mechanismen voor interactie met het cluster.

Een GKE-cluster maken:

1) Maak een cluster aan:

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

Opdracht gcloud maakt een istioready-cluster in het GCP-project en de standaardzone die je hebt opgegeven. Om Istio te draaien, is het raadzaam om ten minste 4 nodes en een virtuele machine te hebben. n1-standard-2.

Het commando maakt het cluster in enkele minuten aan. Wanneer het cluster gereed is, geeft het commando iets dergelijks terug. een bericht.

2) Geef de token in de commandoregeltool op kubectl, zodat je het cluster kunt beheren:

gcloud container clusters get-credentials istioready

3) Nu kan je met Kubernetes communiceren via kubectl. Bijvoorbeeld, het volgende commando kan de status van de nodes opvragen:

kubectl get nodes

Het commando geeft een lijst van nodes terug:

NAAM                                       STATUS   ROLLEN    LEEFTIJD    VERSIE
gke-istoready-default-pool-dbeb23dc-1vg0   Klaar       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Klaar       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Klaar       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Klaar       99s    v1.13.6-gke.13

Belangrijke concepten van Kubernetes

De afbeelding toont een applicatie op GKE:

Voordat u containers in GKE implementeert, dient u de belangrijke concepten van Kubernetes te bestuderen. Onderaan zijn links als u meer wilt leren.

Knooppunten en clusters. In GKE is een knooppunt een virtuele machine. Op andere Kubernetes-platformen kan een knooppunt een computer of virtuele machine zijn. Een cluster is een reeks knooppunten die als één geheel kunnen worden beschouwd en waarop u een containergebaseerde applicatie implementeert.
Pods. In Kubernetes worden containers uitgevoerd in pods. Een pod in Kubernetes is een ongedeelde eenheid. Een pod bevat een of meerdere containers. U implementeert de server- en loadgen in aparte pods. Wanneer er meerdere containers in een pod zijn (bijvoorbeeld een applicatieserver en proxy-server), worden de containers beheerd als één object en delen ze de bronnen van de pod.
Implementaties. In Kubernetes is een implementatie een object dat een set identieke pods vertegenwoordigt. Een implementatie start meerdere replicas van pods, verspreid over de knooppunten van het cluster. Een implementatie vervangt automatisch pods die zijn mislukt of niet reageren.
Kubernetes Service. Wanneer u de code van de applicatie in GKE uitvoert, verandert de verbinding tussen loadgen en server. Toen u services op de Cloud Shell virtuele machine of uw computer uitvoerde, verzond u verzoeken naar server op het adres localhost:8080. Na implementatie in GKE worden de pods uitgevoerd op de beschikbare knooppunten. Standaard kunt u niet beheren op welk knooppunt een pod is uitgevoerd, zodat de pods geen permanente IP-adressen hebben.
Om een IP-adres te verkrijgen voor server, moet u een netwerklagen boven de pods definiëren. Dit is de Kubernetes service. De Kubernetes service biedt een vast eindpunt voor een set pods. Er zijn verschillende soorten services. server gebruikt LoadBalancer, die een extern IP-adres bieden om contact te maken met server van buiten het cluster.
Daarnaast heeft Kubernetes een ingebouwd DNS-systeem dat DNS-namen toekent (bijvoorbeeld, helloserver.default.cluster.local) diensten. Hierdoor kunnen pods binnen het cluster met andere pods in het cluster communiceren via een vast adres. De DNS-naam kan niet buiten het cluster worden gebruikt, bijvoorbeeld in Cloud Shell of op een computer.

Kubernetes-manifesten

Wanneer je de applicatie uit de broncode startte, gebruikte je de imperatieve opdracht python3

server.py

Imperativiteit impliceert een werkwoord: "doe dit".

Kubernetes gebruikt de declaratieve model. Dit betekent dat we Kubernetes niet vertellen wat er precies gedaan moet worden, maar we beschrijven de gewenste toestand. Bijvoorbeeld, Kubernetes start en stopt pods indien nodig, zodat de werkelijke toestand van het systeem overeenkomt met de gewenste.

De gewenste toestand geef je op in manifesten of bestanden YAML. Het YAML-bestand bevat specificaties voor één of meerdere Kubernetes-objecten.

In het voorbeeld is er een YAML-bestand voor server en loadgen. Elk YAML-bestand geeft de gewenste toestand van het implementatie- en serviceobject aan.

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

soort geeft het type object aan.
metadata.name geeft de naam van de implementatie aan.
Het eerste veld spec bevat een beschrijving van de gewenste toestand.
spec.replicas geeft het gewenste aantal pods aan.
Sectie spec.template bepaalt de sjabloon van de pod. In de specificatie van pods is er een veld afbeelding, waar de naam van de afbeelding wordt opgegeven die uit de Container Registry moet worden gedownload.

De service wordt als volgt gedefinieerd:

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

LoadBalancer: cliënten sturen verzoeken naar het IP-adres van de load balancer, die een vast IP-adres heeft en vanuit buiten het cluster toegankelijk is.
targetPort: zoals je je herinnert, gaf de opdracht EXPOSE 8080 in Dockerfile geen poorten op. Je geeft poort 8080op, zodat je contact kunt maken met de container server vanuit het cluster. In ons geval hellosvc.default.cluster.local:80 (korte naam: hellosvc) komt overeen met poort 8080 het IP-adres van de pod helloserver.
port: dit is het poortnummer waar andere services in het cluster verzoeken naartoe zullen sturen.

loadgen.yaml

Het implementatieobject in loadgen.yaml lijkt op server.yaml. Het verschil is dat het implementatieobject een sectie bevat env. Het definieert de omgevingsvariabelen die nodig zijn loadgen en die je hebt ingesteld bij het starten van de applicatie uit de broncode.

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

Eén loadgen neemt geen binnenkomende verzoeken aan voor het veld type is opgegeven ClusterIP. Dit type biedt een vast IP-adres dat door services in het cluster kan worden gebruikt, maar dit IP-adres is niet beschikbaar voor externe klanten.

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

Containerimplementatie op GKE

1) Ga naar de map waar het voorbeeld zich bevindt server:

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

2) Open server.yaml in een teksteditor.
3) Vervang de naam in het veld afbeelding door de naam van uw Docker-image.

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

Vervang PROJECT_ID door uw GCP-project-ID.
4) Sla op en sluit server.yaml.
5) Implementeer het YAML-bestand in Kubernetes:

kubectl apply -f server.yaml

Na een succesvolle uitvoering geeft het commando de volgende code terug:

deployment.apps/helloserver created
service/hellosvc created

6) Ga naar de map waar loadgen:

cd ../loadgen

7) Open loadgen.yaml in een teksteditor.
8) Vervang de naam in het veld afbeelding door de naam van uw Docker-image.

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

Vervang PROJECT_ID door uw GCP-project-ID.
9) Sla op en sluit loadgen.yaml, sluit de teksteditor.
10) Implementeer het YAML-bestand in Kubernetes:

kubectl apply -f loadgen.yaml

Na een succesvolle uitvoering geeft het commando de volgende code terug:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Controleer de status van de pods:

kubectl get pods

Het commando toont de status:

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

12) Haal de applicatielogboeken op van de pod loadgen. Vervang POD_ID door de ID uit het vorige antwoord.

kubectl logs loadgenerator-POD_ID

13) Verkrijg externe IP-adressen hellosvc:

kubectl get service

Het antwoord van het commando ziet er ongeveer zo uit:

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) Stuur een verzoek naar hellosvc: vervang EXTERNAL_IP door het externe IP-adres hellosvc.

curl http://EXTERNAL_IP

We gaan aan de slag met Istio

U heeft al een applicatie die is geïmplementeerd in GKE. loadgen kan Kubernetes DNS gebruiken (hellosvc:80), om verzoeken te verzenden naar server, en u kunt verzoeken verzenden naar server via het externe IP-adres. Hoewel Kubernetes veel mogelijkheden biedt, ontbreken sommige informatie over services:

Hoe communiceren services? Wat is de relatie tussen de services? Hoe verloopt het verkeer tussen de services? Weet u dat loadgen verzoeken verzendt naar server, maar stel je voor dat je niets weet over de applicatie. Om deze vragen te beantwoorden, kijken we naar de lijst met actieve pods in GKE.
Statistieken. Hoe lang server beantwoordt een binnenkomend verzoek? Hoeveel verzoeken per seconde komen er binnen op de server? Geeft het foutmeldingen?
Veiligheidsinformatie. Verkeer tussen loadgen en server verloopt eenvoudig via HTTP of via mTLS?

Op al deze vragen geeft Istio antwoord. Hiervoor plaatst Istio een sidecar-proxy Envoy in elke pod. De Envoy-proxy onderschept al het binnenkomende en uitgaande verkeer naar de applic container. Dit betekent dat server en loadgen verzoeken ontvangen via de sidecar-proxy Envoy, en al het verkeer van loadgen aan server gaat via de Envoy-proxy.

De verbindingen tussen Envoy-proxies vormen een service mesh. De architectuur van de service mesh biedt een laag controle bovenop Kubernetes.

Aangezien de Envoy-proxies in hun eigen containers draaien, kan Istio bovenop de GKE-cluster worden geïnstalleerd met minimale wijzigingen aan de applicatiecode. Maar je moet wel wat gedaan hebben om de applicatie voor te bereiden op het beheer met Istio:

Services voor alle containers. Aan de implementaties zijn server en loadgen een Kubernetes-service gekoppeld. Zelfs loadgen, die geen binnenkomende verzoeken ontvangt, heeft een service.
De poorten in de services moeten namen hebben. Hoewel in GKE de poorten van services zonder naam kunnen blijven, vereist Istio een naam voor de poort volgens zijn protocol. In het YAML-bestand wordt de poort voor server wordt genoemd http, omdat de server het protocol gebruikt HTTP. Als voor het SystemD-initiesysteem: gebruikte gRPC, zou je de poort noemen grpc.
De implementaties zijn gemarkeerd. Daarom kunt u Istio's verkeersbeheersfuncties gebruiken, zoals het splitsen van verkeer tussen versies van dezelfde service.

Instelling Istio

Istio kan op twee manieren worden geïnstalleerd. U kunt de Istio on GKE-extensie inschakelen of de open-source versie van Istio installeren op de cluster. Met Istio on GKE kunt u eenvoudig de installatie en upgrade van Istio beheren binnen de levenscyclus van de GKE-cluster. Als u de nieuwste versie van Istio nodig heeft of meer controle over de configuratie van het Istio-dashboard wilt, installeer dan de open-source versie in plaats van de Istio on GKE-extensie. Om een keuze te maken, lees het artikel Heb ik Istio on GKE nodig?.

Kies een optie, bekijk de relevante handleiding en volg de instructies om Istio op het cluster te installeren. Als u Istio wilt gebruiken met een net geïmplementeerde applicatie, schakel dan sidecar-injectie in. voor de naamruimte default.

Opruimen

Om kosten voor de bronnen die je in deze handleiding hebt gebruikt te voorkomen vanuit je Google Cloud Platform-account, verwijder je de containercluster nadat je Istio hebt geïnstalleerd en met de voorbeeldapplicatie hebt geëxperimenteerd. Dit verwijdert alle clusterbronnen, zoals rekeninstanties, schijven en netwerkmiddelen.