🥇Een aanvraag voorbereiden voor Istio

Istio is een handig hulpmiddel voor het verbinden, beveiligen en monitoren van gedistribueerde applicaties. Istio gebruikt verschillende technologieën om software op schaal uit te voeren en te beheren, waaronder containers om applicatiecode en afhankelijkheden voor implementatie te verpakken, en Kubernetes om die containers te beheren. Om met Istio te kunnen werken, moet je daarom weten hoe een applicatie met meerdere diensten op basis van deze technologieën werkt без Istio. Als u deze tools en concepten al kent, kunt u deze tutorial overslaan en direct naar de sectie gaan Istio installeren op Google Kubernetes Engine (GKE) of het installeren van een extensie Istio op GKE.

Dit is een stapsgewijze handleiding waarin we het hele proces van broncode tot GKE-container doorlopen, zodat u aan de hand van een voorbeeld een basiskennis krijgt van deze technologieën. Je zult ook zien hoe Istio de kracht van deze technologieën benut. Hierbij wordt ervan uitgegaan dat u niets weet over containers, Kubernetes, service meshes of Istio.

taken

In deze zelfstudie voert u de volgende taken uit:

Een eenvoudige hello world-applicatie leren met meerdere services.
Voer de applicatie uit vanuit de broncode.
Verpakken van de applicatie in containers.
Een Kubernetes-cluster maken.
Containers in een cluster implementeren.

Voordat je start

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

uitchecken Kubernetes Engine-pagina in de Google Cloud Platform-console.
Maak of selecteer een project.
Wacht tot de API en gerelateerde services zijn ingeschakeld. Dit kan enkele minuten duren.
Zorg ervoor dat de facturering is ingesteld voor uw Google Cloud Platform-project. Ontdek hoe u facturering inschakelt.

In deze zelfstudie kunt u Cloud Shell gebruiken, waarmee de virtuele machine wordt voorbereid g1-small in Google Compute Engine met op Debian gebaseerde Linux, of een Linux- of macOS-computer.

Optie A: Cloud Shell gebruiken

Voordelen van het gebruik van Cloud Shell:

Python 2- en Python 3-ontwikkelomgevingen (inclusief virtualenv) zijn volledig geconfigureerd.
Commandoregelhulpmiddelen gwolk, havenarbeider, git и kubectl, die we zullen gebruiken, zijn al geïnstalleerd.
Je hebt er verschillende om uit te kiezen teksteditors:
1. Code-editor, dat wordt geopend met het bewerkingspictogram bovenaan het Cloud Shell-venster.
2. Emacs, Vim of Nano, die worden geopend vanaf de opdrachtregel in Cloud Shell.

Gebruiken Cloud Shell:

Ga naar de GCP-console.
Klik op de knop Activeer Cloudshell (Activeer Cloud Shell) bovenaan het GCP-consolevenster.

In het onderste deel GCP-console Een Cloud Shell-sessie met een opdrachtregel wordt in een nieuw venster geopend.

Optie B: Commandoregelhulpmiddelen lokaal gebruiken

Als u op een computer met Linux of macOS gaat werken, moet u de volgende componenten configureren en installeren:

Aanpassen Python 3- en Python 2-ontwikkelomgeving.
Installeer Cloud-SDK met opdrachtregelprogramma gwolk.
Ingesteld kubectl - opdrachtregelprogramma om mee te werken Kubernetes.
```
gcloud components install kubectl
```
Ingesteld Docker Community-editie (CE). U gebruikt het opdrachtregelprogramma havenarbeiderom containerimages te maken voor de voorbeeldtoepassing.
Installeer het gereedschap Git-versiebeheerom de voorbeeldtoepassing van GitHub op te halen.

Voorbeeldcode downloaden

Download de broncode Halloserver:

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

Ga naar de voorbeeldcodemap:

cd istio-samples/sample-apps/helloserver

Een applicatie verkennen met meerdere services

De voorbeeldtoepassing is geschreven in Python en bestaat uit twee componenten die met elkaar communiceren via REST:

server: eenvoudige server met één eindpunt KRIJGEN, /, dat "Hallo wereld" naar de console afdrukt.
laden: script dat verkeer naar stuurt server, met een configureerbaar aantal verzoeken per seconde.

Een applicatie uitvoeren vanuit de broncode

Als u de voorbeeldtoepassing wilt verkennen, voert u deze uit in Cloud Shell of op uw computer.
1) In de catalogus istio-samples/sample-apps/helloserver loop server:

python3 server/server.py

Bij het uitvoeren van server het volgende wordt weergegeven:

INFO:root:Starting server...

2) Open een ander terminalvenster waar u verzoeken naartoe kunt sturen server. Als u Cloud Shell gebruikt, klikt u op het pictogram Toevoegen om een nieuwe sessie te openen.
3) Stuur een verzoek naar server:

curl http://localhost:8080

serverantwoorden:

Hello World!

4) Ga vanuit de map waar u de voorbeeldcode hebt gedownload naar de map die deze bevat laden:

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

5) Maak de volgende omgevingsvariabelen:

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

6) Rennen virtualenv:

virtualenv --python python3 env

7) Activeer de virtuele omgeving:

source env/bin/activate

8) Stel eisen aan laden:

pip3 install -r requirements.txt

9) Rennen laden:

python3 loadgen.py

Bij het uitvoeren van laden geeft zoiets als het volgende bericht weer:

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

In een ander terminalvenster server stuurt de volgende berichten naar de 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: */*

Vanuit netwerkperspectief draait de gehele applicatie op één enkele host (lokale computer of virtuele Cloud Shell-machine). Daarom kunt u gebruiken localhostverzoeken naar te sturen server.
10) Om te stoppen laden и server, binnenkomen Ctrl-c in elk terminalvenster.
11) In het terminalvenster laden de virtuele omgeving deactiveren:

deactivate

Een applicatie verpakken in containers

Om de applicatie op GKE uit te voeren, moet u de voorbeeldapplicatie inpakken − server и laden - in Containers. Een container is een manier om een applicatie te verpakken om deze te isoleren van zijn omgeving.

Om een applicatie in een container te verpakken, hebt u nodig Dockerfile. Dockerfile is een tekstbestand dat opdrachten definieert voor het inbouwen van de broncode van de applicatie en de afhankelijkheden ervan Docker-afbeelding. Eenmaal gebouwd, uploadt u de image naar een containerregister zoals Docker Hub of Containerregister.

Het voorbeeld heeft dat al gedaan Dockerfile voor server и laden met alle benodigde opdrachten om afbeeldingen te verzamelen. Onderstaand - 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/*

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

Team VAN python:3-slank als basis vertelt Docker om de nieuwste te gebruiken Python 3-afbeelding als basis.
Team KOPIËREN. . kopieert de bronbestanden naar de huidige werkmap (alleen in ons geval server.py) naar het bestandssysteem van de container.
INGANGSPUNT definieert de opdracht die wordt gebruikt om de container te starten. In ons geval is dit commando bijna hetzelfde als het commando dat u gebruikte server.py uit de broncode.
Team BLOOT geeft aan dat server wacht op gegevens via de poort 8080. Dit team niet biedt havens. Dit is een soort documentatie die nodig is om de poort te openen 8080 bij het starten van de container.

Voorbereiden op het containeriseren van uw applicatie

1) Stel de volgende omgevingsvariabelen in. Vervangen PROJECT_ID naar uw GCP-project-ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Waarden gebruiken PROJECT_ID и GCR_REPO u tagt de Docker-image wanneer u deze bouwt en pusht deze naar een privécontainerregister.

2) Stel het standaard GCP-project in voor het opdrachtregelprogramma gwolk.

gcloud config set project $PROJECT_ID

3) Stel de standaardzone voor het opdrachtregelprogramma in gwolk.

gcloud config set compute/zone us-central1-b

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

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/

Stel de afbeelding samen met behulp van Dockerfile en de omgevingsvariabelen die u 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 u gebruikt bij het implementeren van de container.

Upload de afbeelding naar het containerregister:

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

Containerisatie van loadgen

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

cd ../loadgen

2) Verzamel de afbeelding:

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

3) Upload de afbeelding naar het containerregister:

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

Bekijk een lijst met afbeeldingen

Bekijk de lijst met afbeeldingen in de repository en controleer of de afbeeldingen zijn geüpload:

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

Met de opdracht worden de namen van de nieuw geüploade afbeeldingen weergegeven:

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

Een GKE-cluster maken.

Deze containers kunnen worden uitgevoerd op een virtuele Cloud Shell-machine of op een computer met de opdracht koppelingsrun. Maar in een productieomgeving heb je een manier nodig om containers centraal te orkestreren. U hebt bijvoorbeeld een systeem nodig dat ervoor zorgt dat containers altijd actief zijn, en u hebt een manier nodig om op te schalen en extra containerinstanties op te zetten als het verkeer toeneemt.

Om container-applicaties uit te voeren die u kunt gebruiken G.K.E.. GKE is een containerorkestratieplatform dat virtuele machines samenvoegt in een cluster. Elke virtuele machine wordt een knooppunt genoemd. GKE-clusters zijn gebaseerd op het open source Kubernetes-clusterbeheersysteem. Kubernetes biedt mechanismen voor interactie met het cluster.

Een GKE-cluster maken:

1) Maak een cluster:

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

Team gwolk maakt een istioready-cluster in het GCP-project en de standaardzone die u heeft opgegeven. Om Istio uit te voeren, raden we aan minimaal 4 knooppunten en een virtuele machine te hebben n1-standaard-2.

Het team creëert het cluster in een paar minuten. Wanneer het cluster gereed is, geeft de opdracht zoiets als dit uit bericht.

2) Geef inloggegevens op in het opdrachtregelprogramma kubectlom het te gebruiken om het cluster te beheren:

gcloud container clusters get-credentials istioready

3) Nu kunt u communiceren met Kubernetes via kubectl. Met de volgende opdracht kunt u bijvoorbeeld de status van knooppunten achterhalen:

kubectl get nodes

De opdracht produceert een lijst met knooppunten:

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

Kubernetes-sleutelconcepten

Het diagram toont een applicatie op GKE:

Voordat u containers in GKE implementeert, moet u de belangrijkste concepten van Kubernetes leren kennen. Helemaal aan het einde vindt u links als u meer wilt weten.

Knooppunten en clusters. In GKE is een knooppunt een virtuele machine. Op andere Kubernetes-platforms kan een knooppunt een computer of een virtuele machine zijn. Een cluster is een verzameling knooppunten die kunnen worden beschouwd als één eenheid waarin u een containertoepassing implementeert.
Peulen. In Kubernetes draaien containers in pods. Een Pod in Kubernetes is een ondeelbare eenheid. Een Pod bevat een of meer containers. Je implementeert servercontainers en laden in aparte peulen. Wanneer er meerdere containers in een pod zitten (bijvoorbeeld een applicatieserver en proxy server), worden containers beheerd als één entiteit en delen ze pod-bronnen.
Implementaties. In Kubernetes is een implementatie een object dat een verzameling identieke pods is. Door de implementatie worden meerdere replica's van peulen gestart, verdeeld over clusterknooppunten. Bij de implementatie worden automatisch pods vervangen die zijn mislukt of niet meer reageren.
Kubernetes-service. Bij het uitvoeren van applicatiecode in GKE wordt de verbinding tussen laden и server. Toen u services startte op een virtuele machine of desktop van Cloud Shell, stuurde u verzoeken naar server bij localhost: 8080. Eenmaal geïmplementeerd in GKE, worden pods uitgevoerd op beschikbare knooppunten. Standaard heeft u geen controle over op welk knooppunt de pod draait peulen geen permanente IP-adressen.
Om een IP-adres te verkrijgen voor server, moet u een netwerkabstractie bovenop de peulen definiëren. Dat is wat het is Kubernetes-service. De Kubernetes-service biedt een permanent eindpunt voor een set peulen. Er zijn een paar soorten diensten. server toepassingen Load Balancer, dat een extern IP-adres biedt waarmee contact kan worden opgenomen server van buiten het cluster.
Kubernetes heeft ook een ingebouwd DNS-systeem dat DNS-namen toewijst (bijvoorbeeld halloserver.default.cluster.local) Diensten. Hierdoor communiceren pods binnen het cluster op een permanent adres met andere pods in het cluster. De DNS-naam kan niet buiten het cluster worden gebruikt, zoals in Cloud Shell of op een computer.

Kubernetes manifesteert zich

Toen u de toepassing vanuit de broncode uitvoerde, gebruikte u de imperatieve opdracht python3

server.py

Imperatief impliceert een werkwoord: "doe dit."

Kubernetes gebruikt declaratief model. Dit betekent dat we Kubernetes niet precies vertellen wat het moet doen, maar eerder de gewenste toestand beschrijven. Kubernetes start en stopt bijvoorbeeld pods als dat nodig is om de werkelijke status van het systeem consistent te houden met de gewenste status.

Je geeft de gewenste staat aan in manifesten of bestanden Yamla. Een YAML-bestand bevat specificaties voor een of meer Kubernetes-objecten.

Het voorbeeld bevat een YAML-bestand voor server и laden. Elk YAML-bestand specificeert de gewenste status van het implementatieobject en de Kubernetes-service.

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.naam specificeert de implementatienaam.
Eerste veld spec bevat een beschrijving van de gewenste staat.
spec.replica's geeft het gewenste aantal pods aan.
Sectie spec.sjabloon definieert een pod-sjabloon. Er is een veld in de podspecificatie beeld, waarmee de naam wordt opgegeven van de afbeelding die uit het containerregister moet worden geëxtraheerd.

De dienst is als volgt gedefinieerd:

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

Load Balancer: Clients sturen verzoeken naar het IP-adres van de load balancer, die een persistent IP-adres heeft en toegankelijk is van buiten het cluster.
doelpoort: zoals je je herinnert, het team BELICHT 8080 в Dockerfile leverde geen poorten. Jij zorgt voor de haven 8080zodat u contact kunt opnemen met de container server buiten het cluster. In ons geval hallosvc.default.cluster.local:80 (korte naam: hallovc) komt overeen met de poort 8080 Pod-IP-adressen Halloserver.
port: dit is het poortnummer waarnaar andere services in het cluster aanvragen verzenden.

loadgen.yaml

Implementatieobject voor loadgen.yaml ziet eruit als server.yaml. Het verschil is dat het implementatieobject een sectie bevat env. Het definieert de omgevingsvariabelen die nodig zijn laden en die u hebt geïnstalleerd toen u de applicatie vanuit de broncode uitvoerde.

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

tijd laden accepteert geen inkomende verzoeken voor het veld type dan: onbekend ClusterIP. Dit type biedt een persistent IP-adres dat services in het cluster kunnen gebruiken, maar dit IP-adres is niet zichtbaar voor externe clients.

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

Containers implementeren in GKE

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

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

2) Vraag server.yaml in een teksteditor.
3) Vervang de naam in het veld beeld naar de naam van uw Docker-installatiekopie.

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

Vervangen PROJECT_ID naar uw GCP-project-ID.
4) Opslaan en sluiten server.yaml.
5) Implementeer het YAML-bestand naar Kubernetes:

kubectl apply -f server.yaml

Na succesvolle voltooiing produceert de opdracht de volgende code:

deployment.apps/helloserver created
service/hellosvc created

6) Ga naar de map waar laden:

cd ../loadgen

7) Vraag loadgen.yaml in een teksteditor.
8) Vervang de naam in het veld beeld naar de naam van uw Docker-installatiekopie.

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

Vervangen PROJECT_ID naar uw GCP-project-ID.
9) Opslaan en sluiten loadgen.yaml, sluit de teksteditor.
10) Implementeer het YAML-bestand naar Kubernetes:

kubectl apply -f loadgen.yaml

Na succesvolle voltooiing produceert de opdracht de volgende code:

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) Extraheer applicatielogboeken uit de pod laden. Vervangen POD_ID naar de identificatie uit het vorige antwoord.

kubectl logs loadgenerator-POD_ID

13) Verkrijg externe IP-adressen hallovc:

kubectl get service

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

14) Stuur een verzoek naar hallovc: vervangen EXTERN_IP naar een extern IP-adres hallovc.

curl http://EXTERNAL_IP

Laten we het opnemen tegen Istio

U heeft al een applicatie geïmplementeerd in GKE. laden kan Kubernetes DNS gebruiken (hallovc:80) om verzoeken naar te sturen serveren u kunt verzoeken sturen naar server via extern IP-adres. Hoewel Kubernetes veel functionaliteiten heeft, ontbreekt er wat informatie over de diensten:

Hoe interacteren diensten? Wat zijn de relaties tussen diensten? Hoe verloopt het verkeer tussen diensten? Bent u zich daarvan bewust laden stuurt verzoeken naar server, maar stel je voor dat je niets weet over de applicatie. Laten we, om deze vragen te beantwoorden, eens kijken naar de lijst met actieve pods in GKE.
statistieken. Hoe lang server reageert op een binnenkomend verzoek? Hoeveel verzoeken ontvangt de server per seconde? Geeft hij foutmeldingen?
veiligheidsinformatie. Verkeer tussen laden и server gaat gewoon door HTTP of door mTLS?

Istio beantwoordt al deze vragen. Om dit te doen plaatst Istio een zijspanproxy Gezant in elke peul. De Envoy-proxy onderschept al het inkomende en uitgaande verkeer naar applicatiecontainers. Het betekent dat server и laden ontvangen via zijspanproxy Envoy en al het verkeer van laden к server gaat via de Envoy-proxy.

Verbindingen tussen Envoy-proxy's vormen een servicegaas. De service mesh-architectuur biedt een controlelaag bovenop Kubernetes.

Omdat Envoy-proxy's in hun eigen containers draaien, kan Istio bovenop een GKE-cluster worden geïnstalleerd met vrijwel geen wijzigingen in de applicatiecode. Maar u heeft wat werk verricht om uw applicatie klaar te maken voor beheer door Istio:

Diensten voor alle containers. Naar implementaties server и laden gekoppeld aan de Kubernetes-service. Zelfs laden, die geen inkomende verzoeken ontvangt, is er een service.
Poorten in services moeten namen hebben. Hoewel servicepoorten in GKE naamloos kunnen blijven, vereist Istio dat u dit opgeeft poort naam in overeenstemming met zijn protocol. In het YAML-bestand de poort voor server genoemd httpomdat de server het protocol gebruikt HTTP. Als service gebruikt gRPC, je zou de poort een naam geven grpc.
Implementaties zijn gemarkeerd. Daarom kunt u de verkeersbeheerfuncties van Istio gebruiken, zoals het splitsen van verkeer tussen versies van dezelfde service.

Istio installeren

Er zijn twee manieren om Istio te installeren. Kan schakel Istio in op de GKE-extensie of installeer de open source-versie van Istio op het cluster. Met Istio op GKE kunt u eenvoudig Istio-installaties en -upgrades beheren gedurende de gehele levenscyclus van het GKE-cluster. Als u de nieuwste versie van Istio of meer controle wilt over de configuratie van uw Istio-configuratiescherm, installeer dan de open source-versie in plaats van de Istio op GKE-extensie. Lees het artikel om te beslissen over de aanpak Heb ik Istio nodig op GKE?.

Selecteer een optie, bekijk de betreffende handleiding en volg de instructies om Istio op uw cluster te installeren. Als u Istio wilt gebruiken met uw nieuw geïmplementeerde applicatie, zijspanimplementatie mogelijk maken voor naamruimte verzuim.

Очистка

Om te voorkomen dat de bronnen die u in deze zelfstudie heeft gebruikt, in rekening worden gebracht op uw Google Cloud Platform-account, verwijdert u het containercluster nadat u Istio heeft geïnstalleerd en met de voorbeeldapplicatie heeft gespeeld. Hiermee worden alle clusterbronnen verwijderd, zoals rekeninstanties, schijven en netwerkbronnen.

Wat is het volgende?

Ontdek de volgende technologieën:
Ontdek de volgende hulpmiddelen:
Leer Kubernetes-concepten:
1. Clusters
2. Knooppunten
3. Peulen
4. Services
5. Inzet

Bron: www.habr.com

Een aanvraag voorbereiden voor Istio