🥇 Berei 'n aansoek voor vir Istio

Istio is 'n gerieflike hulpmiddel om verspreide toepassings te koppel, te beveilig en te monitor. Istio gebruik 'n verskeidenheid tegnologieë om sagteware op skaal uit te voer en te bestuur, insluitend houers om toepassingskode en afhanklikhede vir ontplooiing te verpak, en Kubernetes om daardie houers te bestuur. Daarom, om met Istio te werk, moet jy weet hoe 'n toepassing met veelvuldige dienste wat op hierdie tegnologieë gebaseer is, werk sonder Istio. As hierdie gereedskap en konsepte reeds aan jou bekend is, slaan gerus hierdie tutoriaal oor en gaan reguit na die afdeling Installeer Istio op Google Kubernetes Engine (GKE) of die installering van 'n uitbreiding Istio op GKE.

Hierdie is 'n stap-vir-stap gids waar ons deur die hele proses van bronkode tot GKE-houer sal loop om jou 'n basiese begrip van hierdie tegnologieë deur middel van 'n voorbeeld te gee. Jy sal ook sien hoe Istio die krag van hierdie tegnologieë benut. Dit neem aan dat jy niks weet van houers, Kubernetes, diensmaskers of Istio nie.

take

In hierdie tutoriaal sal jy die volgende take voltooi:

Leer 'n eenvoudige hallo wêreld-toepassing met verskeie dienste.
Begin die toepassing vanaf die bronkode.
Verpak die toediening in houers.
Skep 'n Kubernetes-kluster.
Ontplooi houers in 'n groepering.

Voor jy begin

Volg die instruksies om die Kubernetes Engine API te aktiveer:

Gaan na Kubernetes Engine-bladsy in die Google Wolk Platform-konsole.
Skep of kies 'n projek.
Wag totdat die API en verwante dienste geaktiveer is. Dit kan 'n paar minute neem.
Maak seker dat fakturering vir jou Google Wolk-platform-projek opgestel is. Leer hoe om fakturering te aktiveer.

In hierdie tutoriaal kan jy Cloud Shell gebruik, wat die virtuele masjien voorberei g1-small in Google Compute Engine met Debian-gebaseerde Linux, of 'n Linux- of macOS-rekenaar.

Opsie A: Gebruik Cloud Shell

Voordele van die gebruik van Cloud Shell:

Python 2 en Python 3-ontwikkelingsomgewings (insluitend virtualenv) volledig gekonfigureer is.
Opdragreëlnutsgoed gwolk, Docker, git и kubectl, wat ons sal gebruik, is reeds geïnstalleer.
Jy het verskeie om van te kies teksredakteurs:
1. Kode-redakteur, wat oopmaak met die wysiging-ikoon aan die bokant van die Wolkdop-venster.
2. Emacs, Vim of Nano, wat vanaf die opdragreël in Cloud Shell oopmaak.

Om te gebruik Wolkdop:

Gaan na die GCP-konsole.
pers Aktiveer Cloud Shell (Aktiveer Cloud Shell) aan die bokant van die GCP-konsolevenster.

In die onderste deel GCP-konsole 'n Wolk Shell-sessie met 'n opdragreël sal in 'n nuwe venster oopmaak.

Opsie B: Gebruik opdragreëlnutsmiddels plaaslik

As jy op 'n rekenaar met Linux of macOS werk, sal jy die volgende komponente moet konfigureer en installeer:

Pas aan Python 3 en Python 2 ontwikkelingsomgewing.
Installeer Wolk SDK met die opdragreëlinstrument gwolk.
Installeer kubectl - opdragreëlinstrument om mee te werk Kubernetes.
```
gcloud components install kubectl
```
Installeer Docker Community Edition (CE). U sal die opdragreëlinstrument gebruik Dockerom houerbeelde vir die voorbeeldtoepassing te skep.
Installeer die instrument Git weergawe beheerom die voorbeeldtoepassing van GitHub te kry.

Laai voorbeeldkode af

Laai die bronkode af hallo bediener:

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

Gaan na die voorbeeldkodegids:

cd istio-samples/sample-apps/helloserver

Verken 'n toepassing met verskeie dienste

Die voorbeeldtoepassing is in Python geskryf en bestaan uit twee komponente wat met mekaar in wisselwerking tree REST:

bediener: eenvoudige bediener met een eindpunt KRY, /, wat "hallo wêreld" op die konsole druk.
loadgen: skrif wat verkeer na stuur bediener, met 'n konfigureerbare aantal versoeke per sekonde.

Begin 'n toepassing vanaf bronkode

Om die voorbeeldtoepassing te verken, voer dit in Cloud Shell of op jou rekenaar uit.
1) In die katalogus istio-monsters/sample-apps/helloserver hardloop bediener:

python3 server/server.py

Met die aanvang bediener die volgende word vertoon:

INFO:root:Starting server...

2) Maak nog 'n terminale venster oop om versoeke na te stuur bediener. As jy Cloud Shell gebruik, klik die byvoeg-ikoon om nog 'n sessie oop te maak.
3) Stuur 'n versoek aan bediener:

curl http://localhost:8080

bediener antwoord:

Hello World!

4) Van die gids waar jy die voorbeeldkode afgelaai het, gaan na die gids wat bevat loadgen:

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

5) Skep die volgende omgewingsveranderlikes:

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

6) Hardloop virtualenv:

virtualenv --python python3 env

7) Aktiveer die virtuele omgewing:

source env/bin/activate

8) Stel vereistes vir loadgen:

pip3 install -r requirements.txt

9) Hardloop loadgen:

python3 loadgen.py

Met die aanvang loadgen vertoon iets soos die volgende boodskap:

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

In 'n ander terminale venster bediener voer die volgende boodskappe uit na die konsole:

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 'n netwerkperspektief loop die hele toepassing op 'n enkele gasheer (plaaslike rekenaar of Cloud Shell virtuele masjien). Daarom kan jy gebruik localhostversoeke aan te stuur bediener.
10) Om te stop loadgen и bediener, gaan in Ctrl-c in elke terminale venster.
11) In die terminale venster loadgen deaktiveer die virtuele omgewing:

deactivate

Verpak 'n toepassing in houers

Om die toepassing op GKE te laat loop, moet u die voorbeeldtoepassing verpak − bediener и loadgen - in Houers. 'n Houer is 'n manier om 'n toepassing te verpak om dit van sy omgewing te isoleer.

Om 'n toepassing in 'n houer te verpak, benodig jy dockerfile. dockerfile is 'n tekslêer wat opdragte definieer om die toepassing se bronkode en sy afhanklikhede in te bou Docker-beeld. Sodra dit gebou is, laai u die prent op na 'n houerregister soos Docker Hub of Houerregister.

Die voorbeeld het reeds dockerfile vir bediener и loadgen met al die nodige opdragte om beelde te versamel. Onder - dockerfile vir bediener:

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

Span VAN luislang: 3-slank as basis vertel Docker om die nuutste te gebruik Python 3 beeld as basis.
Span KOPIE. . kopieer die bronlêers na die huidige werkgids (slegs in ons geval bediener.py) na die houer se lêerstelsel.
INGANGSPUNT definieer die opdrag wat gebruik word om die houer te begin. In ons geval is hierdie opdrag amper dieselfde as die een wat jy gebruik het bediener.py vanaf bronkode.
Span BLOOT TE STEL dui daarop aan bediener wag vir data deur die poort 8080. Hierdie span is nie verskaf hawens. Dit is 'n soort dokumentasie wat nodig is om die poort oop te maak 8080 wanneer die houer begin word.

Berei voor om jou aansoek te hou

1) Stel die volgende omgewingsveranderlikes. Vervang PROJECT_ID na jou GCP-projek-ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Gebruik waardes PROJECT_ID и GCR_REPO jy merk die Docker-beeld wanneer jy dit bou en stoot dit na 'n private houerregister.

2) Stel die verstek GCP-projek vir die opdragreëlnutsding gwolk.

gcloud config set project $PROJECT_ID

3) Stel die versteksone vir die opdragreëlnutsding gwolk.

gcloud config set compute/zone us-central1-b

4) Maak seker dat die Container Registry-diens in die GCP-projek geaktiveer is.

gcloud services enable containerregistry.googleapis.com

Containerisering bediener

Gaan na die gids waar die voorbeeld geleë is bediener:

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

Stel die beeld saam met behulp van dockerfile en die omgewingsveranderlikes wat jy vroeër gedefinieer het:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameter -t verteenwoordig die Docker-merker. Dit is die naam van die prent wat jy gebruik wanneer jy die houer ontplooi.

Laai die prent op na die houerregister:

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

Houerisering van loadgen

1) Gaan na die gids waar die voorbeeld geleë is loadgen:

cd ../loadgen

2) Versamel die beeld:

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

3) Laai die prent op na die houerregister:

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

Bekyk 'n lys prente

Hersien die lys prente in die bewaarplek en verifieer dat die prente opgelaai is:

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

Die opdrag vertoon die name van die nuut opgelaaide beelde:

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

Skep 'n GKE-kluster.

Hierdie houers kan op 'n Cloud Shell virtuele masjien of op 'n rekenaar met die opdrag uitgevoer word docker run. Maar in 'n produksie-omgewing het jy 'n manier nodig om houers sentraal te orkestreer. Byvoorbeeld, jy het 'n stelsel nodig wat seker maak dat houers altyd aan die gang is, en jy het 'n manier nodig om bykomende houergevalle op te skaal en op te tel as die verkeer toeneem.

Om houertoepassings te laat loop wat jy kan gebruik G.K.E.. GKE is 'n houerorkestrasieplatform wat virtuele masjiene in 'n groep saamvoeg. Elke virtuele masjien word 'n nodus genoem. GKE-klusters is gebaseer op die oopbron Kubernetes-klusterbestuurstelsel. Kubernetes verskaf meganismes vir interaksie met die groep.

Skep 'n GKE-kluster:

1) Skep 'n groep:

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

Span gwolk skep 'n reeds-groepering in die GCP-projek en versteksone wat jy gespesifiseer het. Om Istio te laat loop, beveel ons aan om ten minste 4 nodusse en 'n virtuele masjien te hê n1-standaard-2.

Die span skep die groep binne 'n paar minute. Wanneer die groep gereed is, voer die opdrag iets soos hierdie uit die boodskap.

2) Verskaf geloofsbriewe in die opdragreëlnutsding kubectlom dit te gebruik om die groepie te bestuur:

gcloud container clusters get-credentials istioready

3) Nou kan jy met Kubernetes kommunikeer via kubectl. Byvoorbeeld, die volgende opdrag kan die status van nodusse uitvind:

kubectl get nodes

Die opdrag produseer 'n lys nodusse:

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 Sleutelkonsepte

Die diagram toon 'n toepassing op GKE:

Voordat jy houers in GKE ontplooi, leer die sleutelkonsepte van Kubernetes. Daar is skakels heel aan die einde as jy meer wil leer.

Nodusse en trosse. In GKE is 'n nodus 'n virtuele masjien. Op ander Kubernetes-platforms kan 'n nodus 'n rekenaar of 'n virtuele masjien wees. 'n Groepering is 'n versameling nodusse wat as 'n enkele eenheid beskou kan word waar u 'n houertoepassing ontplooi.
Peule. In Kubernetes loop houers in peule. 'n Peul in Kubernetes is 'n ondeelbare eenheid. 'n Peul bevat een of meer houers. Jy ontplooi bedienerhouers en loadgen in aparte peule. Wanneer daar verskeie houers in 'n peul is (byvoorbeeld 'n toepassingsbediener en instaanbediener), word houers as 'n enkele entiteit bestuur en deel peulhulpbronne.
Ontplooiings. In Kubernetes is 'n ontplooiing 'n voorwerp wat 'n versameling identiese peule is. Ontplooiing loods veelvuldige replikas van peule wat oor groepnodusse versprei is. Ontplooiing vervang outomaties peule wat misluk het of nie reageer nie.
Kubernetes diens. Wanneer toepassingskode in GKE uitgevoer word, is die verbinding tussen loadgen и bediener. Toe jy dienste op 'n Cloud Shell virtuele masjien of rekenaar begin het, het jy versoeke gestuur na bediener by localhost: 8080. Sodra dit na GKE ontplooi is, word peule op beskikbare nodusse uitgevoer. By verstek het jy geen beheer oor watter nodus die peul loop nie, so jy peule geen permanente IP-adresse nie.
Om 'n IP-adres vir bediener, moet jy 'n netwerkabstraksie bo-op die peule definieer. Dit is wat dit is Kubernetes diens. Die Kubernetes-diens bied 'n aanhoudende eindpunt vir 'n stel peule. Daar is 'n paar tipes dienste. bediener gebruike LoadBalancer, wat 'n eksterne IP-adres verskaf om te kontak bediener van buite die groep.
Kubernetes het ook 'n ingeboude DNS-stelsel wat DNS-name toeken (byvoorbeeld, helloserver.default.cluster.local) dienste. Danksy dit kommunikeer peule binne die cluster met ander peule in die cluster by 'n permanente adres. Die DNS-naam kan nie buite die groepering gebruik word nie, soos in Cloud Shell of op 'n rekenaar.

Kubernetes manifesteer

Wanneer jy die toepassing vanaf die bron laat loop het, het jy die noodsaaklike opdrag gebruik python3

bediener.py

Imperatief impliseer 'n werkwoord: "doen dit."

Kubernetes gebruik verklarende model. Dit beteken dat ons nie vir Kubernetes presies vertel wat om te doen nie, maar eerder die gewenste toestand beskryf. Byvoorbeeld, Kubernetes begin en stop peule soos nodig om te verseker dat die werklike toestand van die stelsel ooreenstem met die verlangde toestand.

Jy dui die verlangde toestand in manifeste of lêers aan YAML. 'n YAML-lêer bevat spesifikasies vir een of meer Kubernetes-voorwerpe.

Die voorbeeld bevat 'n YAML-lêer vir bediener и loadgen. Elke YAML-lêer spesifiseer die verlangde toestand van die ontplooiingsvoorwerp en Kubernetes-diens.

bediener.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 dui die tipe voorwerp aan.
metadata.naam spesifiseer die ontplooiingsnaam.
Eerste veld spec bevat 'n beskrywing van die verlangde toestand.
spes.replikas dui die verlangde aantal peule aan.
artikel spes.sjabloon definieer 'n peul-sjabloon. Daar is 'n veld in die peulspesifikasie beeld, wat die naam spesifiseer van die prent wat uit die houerregister onttrek moet word.

Die diens word soos volg gedefinieer:

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

LoadBalancer: Kliënte stuur versoeke na die IP-adres van die lasbalanseerder, wat 'n volgehoue IP-adres het en toeganklik is van buite die groepering.
doelpoort: soos jy onthou, die span BLOOTSTELLING 8080 в dockerfile het nie hawens verskaf nie. Jy verskaf die hawe 8080sodat jy die houer kan kontak bediener buite die cluster. In ons geval hellosvc.default.cluster.local:80 (kort naam: hellosvc) stem ooreen met die poort 8080 Pod IP-adresse hallo bediener.
hawe: Dit is die poortnommer waarheen ander dienste in die groep versoeke sal stuur.

loadgen.yaml

Ontplooiing beswaar teen loadgen.yaml lyk soos bediener.yaml. Die verskil is dat die ontplooiingsvoorwerp 'n afdeling bevat env. Dit definieer die omgewingsveranderlikes wat benodig word loadgen en wat u geïnstalleer het toe u die toepassing vanaf die bron bestuur het.

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

tyd loadgen aanvaar nie inkomende versoeke vir die veld nie tipe onbekend ClusterIP. Hierdie tipe verskaf 'n aanhoudende IP-adres wat dienste in die groepering kan gebruik, maar hierdie IP-adres word nie aan eksterne kliënte blootgestel nie.

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

Ontplooi houers in GKE

1) Gaan na die gids waar die voorbeeld geleë is bediener:

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

2) Maak oop bediener.yaml in 'n teksredigeerder.
3) Vervang die naam in die veld beeld na die naam van jou Docker-beeld.

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

Vervang PROJECT_ID na jou GCP-projek-ID.
4) Stoor en maak toe bediener.yaml.
5) Ontplooi die YAML-lêer na Kubernetes:

kubectl apply -f server.yaml

Na suksesvolle voltooiing produseer die opdrag die volgende kode:

deployment.apps/helloserver created
service/hellosvc created

6) Gaan na die gids waar loadgen:

cd ../loadgen

7) Maak oop loadgen.yaml in 'n teksredigeerder.
8) Vervang die naam in die veld beeld na die naam van jou Docker-beeld.

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

Vervang PROJECT_ID na jou GCP-projek-ID.
9) Stoor en maak toe loadgen.yaml, maak die teksredigeerder toe.
10) Ontplooi die YAML-lêer na Kubernetes:

kubectl apply -f loadgen.yaml

Na suksesvolle voltooiing produseer die opdrag die volgende kode:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Gaan die status van die peule na:

kubectl get pods

Die opdrag wys die status:

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

12) Onttrek toepassingslogboeke uit die peul loadgen. Vervang POD_ID na die identifiseerder van die vorige antwoord.

kubectl logs loadgenerator-POD_ID

13) Verkry eksterne IP-adresse hellosvc:

kubectl get service

Die opdragreaksie lyk iets soos volg:

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 'n versoek aan hellosvc: vervang EXTERNAL_IP na eksterne IP-adres hellosvc.

curl http://EXTERNAL_IP

Kom ons vat Istio aan

Jy het reeds 'n toepassing wat na GKE ontplooi is. loadgen kan Kubernetes DNS (hallo:80) om versoeke aan te stuur bedieneren jy kan versoeke stuur na bediener deur eksterne IP-adres. Alhoewel Kubernetes baie kenmerke het, ontbreek daar inligting oor die dienste:

Hoe werk dienste in wisselwerking? Wat is die verhoudings tussen dienste? Hoe vloei verkeer tussen dienste? Is jy bewus daarvan loadgen versoeke stuur aan bediener, maar stel jou voor dat jy niks van die toepassing weet nie. Om hierdie vrae te beantwoord, kom ons kyk na die lys van lopende peule in GKE.
Metrieke. Hoe lank bediener reageer op 'n inkomende versoek? Hoeveel versoeke per sekonde word deur die bediener ontvang? Gee dit foutboodskappe?
Sekuriteitsinligting. Verkeer tussen loadgen и bediener gaan net deur HTTP of deur mTLS?

Istio beantwoord al hierdie vrae. Om dit te doen, plaas Istio 'n sidecar-instaanbediener gesant in elke peul. Die Gesant-instaanbediener onderskep alle inkomende en uitgaande verkeer na toepassinghouers. Dit beteken dat bediener и loadgen ontvang via sidecar proxy gesant, en alle verkeer van loadgen к bediener gaan deur die Gesant-instaanbediener.

Verbindings tussen Gesant-gevolmagtigdes vorm 'n diensnetwerk. Die diensnetwerk-argitektuur bied 'n laag beheer bo-op Kubernetes.

Aangesien Envoy-gevolmagtigdes in hul eie houers loop, kan Istio bo-op 'n GKE-kluster geïnstalleer word met byna geen veranderinge aan die toepassingskode nie. Maar jy het 'n bietjie werk gedoen om jou aansoek gereed te kry om deur Istio bestuur te word:

Dienste vir alle houers. Aan ontplooiings bediener и loadgen gekoppel aan die Kubernetes-diens. Selfs loadgen, wat nie inkomende versoeke ontvang nie, is daar 'n diens.
Hawens in dienste moet name hê. Alhoewel dienspoorte onbenoem gelaat kan word in GKE, vereis Istio dat jy spesifiseer poort naam in ooreenstemming met sy protokol. In die YAML lêer die poort vir bediener genoem httpomdat bediener die protokol gebruik HTTP... As diens gebruik word gRPC, sou jy die poort noem grpc.
Ontplooiings is gemerk. Daarom kan jy Istio se verkeersbestuurkenmerke gebruik, soos om verkeer tussen weergawes van dieselfde diens te verdeel.

Installasie

Daar is twee maniere om Istio te installeer. Kan aktiveer Istio op GKE-uitbreiding of installeer die oopbronweergawe van Istio op die cluster. Met Istio op GKE kan jy maklik Istio-installasies en -opgraderings regdeur die GKE-kluster-lewensiklus bestuur. As jy die nuutste weergawe van Istio of meer beheer oor jou Istio-kontrolepaneel-konfigurasie wil hê, installeer die oopbronweergawe in plaas van die Istio op GKE-uitbreiding. Om oor die benadering te besluit, lees die artikel Het ek Istio op GKE nodig?.

Kies 'n opsie, hersien die toepaslike gids en volg die instruksies om Istio op jou cluster te installeer. As jy Istio wil gebruik met jou nuut-ontplooide toepassing, aktiveer syspan-implementering vir naamruimte verstek.

skoonmaak

Om te verhoed dat jy van jou Google Wolk-platform-rekening gehef word vir die hulpbronne wat jy in hierdie tutoriaal gebruik het, vee die houergroep uit sodra jy Istio geïnstalleer en met die voorbeeldtoepassing gespeel het. Dit sal alle groeperingshulpbronne, soos rekenaargevalle, skywe en netwerkhulpbronne, verwyder.

Wat is volgende?

Verken die volgende tegnologieë:
1. Docker
2. Houers
3. Houerregister
4. Kubernetes
5. G.K.E.
6. diensnetwerk
7. Istio
Verken die volgende gereedskap:
Leer Kubernetes-konsepte:
1. Trosse
2. Knope
3. Peule
4. Dienste
5. Ontplooiing

Bron: will.com

Berei 'n aansoek vir Istio voor