ProHoster > Blog > Bestjoer > It tarieden fan in applikaasje foar Istio

It tarieden fan in applikaasje foar Istio

It tarieden fan in applikaasje foar Istio

Istio is in handich ark foar it ferbinen, befeiligjen en kontrolearjen fan ferspraat applikaasjes. Istio brûkt in ferskaat oan technologyen om software op skaal út te fieren en te behearjen, ynklusyf konteners om applikaasjekoade en ôfhinklikens foar ynset te pakken, en Kubernetes om dy konteners te behearjen. Dêrom, om te wurkjen mei Istio moatte jo witte hoe't in applikaasje mei meardere tsjinsten basearre op dizze technologyen wurket sûnder Istio. As dizze ark en begripen jo al bekend binne, fiel jo frij om dizze tutorial oer te slaan en direkt nei de seksje te gean Ynstallearje Istio op Google Kubernetes Engine (GKE) of it ynstallearjen fan in útwreiding Istio op GKE.

Dit is in stap-foar-stap hantlieding wêr't wy troch it heule proses sille rinne fan boarnekoade oant GKE-kontener om jo in basisbegryp fan dizze technologyen te jaan fia in foarbyld. Jo sille ek sjen hoe't Istio de krêft fan dizze technologyen benut. Dit giet derfan út dat jo neat witte oer konteners, Kubernetes, servicemeshes of Istio.

taken

Yn dizze tutorial sille jo de folgjende taken foltôgje:

  1. Learje in ienfâldige Hello World-applikaasje mei meardere tsjinsten.
  2. Run de applikaasje út boarne koade.
  3. Ferpakking fan de applikaasje yn konteners.
  4. It meitsjen fan in Kubernetes-kluster.
  5. It ynsetten fan konteners yn in kluster.

Foardat'st begjinst

Folgje de ynstruksjes om de Kubernetes Engine API yn te skeakeljen:

  1. Gean nei Kubernetes Engine side yn 'e Google Cloud Platform-konsole.
  2. Meitsje of selektearje in projekt.
  3. Wachtsje oant de API en relatearre tsjinsten binne ynskeakele. Dit kin in pear minuten duorje.
  4. Soargje derfoar dat fakturearring is ynsteld foar jo Google Cloud Platform-projekt. Learje hoe't jo fakturearring ynskeakelje kinne.

Yn dit tutorial kinne jo Cloud Shell brûke, dy't de firtuele masine taret g1-small yn Google Compute Engine mei Debian-basearre Linux, as in Linux- of macOS-kompjûter.

Opsje A: Cloud Shell brûke

Foardielen fan it brûken fan Cloud Shell:

  • Python 2 en Python 3 ûntwikkelomjouwings (ynklusyf virtualenv) binne folslein ynsteld.
  • Kommandorigelark gcloud, docker, gean и kubectl, dy't wy sille brûke binne al ynstallearre.
  • Jo hawwe ferskate om út te kiezen tekst bewurkers:
    1. Koade bewurker, dy't iepenet mei it bewurkje ikoan oan 'e boppekant fan it Cloud Shell-finster.
    2. Emacs, Vim of Nano, dy't iepenje fanút de kommandorigel yn Cloud Shell.

Brûke Wolke Shell:

  1. Gean nei de GCP-konsole.
  2. parse Aktivearje Cloud Shell (Cloud Shell aktivearje) oan 'e boppekant fan it GCP-konsolefinster.

It tarieden fan in applikaasje foar Istio

Yn it ûnderste diel GCP konsole In Cloud Shell-sesje mei in kommandorigel sil yn in nij finster iepenje.

It tarieden fan in applikaasje foar Istio

Opsje B: Gebrûk fan kommandorigelark lokaal

As jo ​​​​wurkje op in kompjûter mei Linux of macOS, moatte jo de folgjende komponinten konfigurearje en ynstallearje:

  1. Oanpasse Python 3 en Python 2 ûntwikkeling omjouwing.

  2. Ynstallearje Cloud SDK mei kommandorigelark gcloud.

  3. Ynstallearje kubectl - kommandorigelark om mei te wurkjen Kubernetes.

    gcloud components install kubectl

  4. Ynstallearje Docker Community Edition (CE). Jo sille it kommandorigelark brûke dockerom kontenerôfbyldings te meitsjen foar de foarbyldapplikaasje.

  5. Ynstallearje it ark Git ferzje kontrôleom de foarbyldapplikaasje fan GitHub te krijen.

Download foarbyldkoade

  1. Download de boarnekoade helloserver:

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

  2. Gean nei it foarbyldkoademap:

    cd istio-samples/sample-apps/helloserver

Ferkenne in applikaasje mei meardere tsjinsten

De foarbyldapplikaasje is skreaun yn Python en bestiet út twa komponinten dy't ynteraksje mei RÊST:

  • tsjinner: ienfâldige tsjinner mei ien einpunt GET, /, dy't "hallo wrâld" op 'e konsole printsje.
  • loadgen: skript dat stjoert ferkear nei tsjinner, mei in ynstelbere oantal oanfragen per sekonde.

It tarieden fan in applikaasje foar Istio

In applikaasje útfiere fanút boarnekoade

Om de foarbyldapplikaasje te ferkennen, útfiere it yn Cloud Shell of op jo kompjûter.
1) Yn 'e katalogus istio-samples/sample-apps/helloserver rinne tsjinner:

python3 server/server.py

By it opstarten tsjinner it folgjende wurdt werjûn:

INFO:root:Starting server...

2) Iepenje in oar terminalfinster om fersiken nei te stjoeren tsjinner. As jo ​​​​Cloud Shell brûke, klikje dan op it ikoan tafoegje om in oare sesje te iepenjen.
3) Stjoer in fersyk nei tsjinner:

curl http://localhost:8080

tsjinner antwurden:

Hello World!

4) Gean út 'e map wêr't jo de foarbyldkoade ynladen hawwe, nei de map dy't befettet loadgen:

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

5) Meitsje de folgjende omjouwingsfariabelen:

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

6) Start virtualenv:

virtualenv --python python3 env

7) Aktivearje de firtuele omjouwing:

source env/bin/activate

8) Stel easken foar loadgen:

pip3 install -r requirements.txt

9) Start loadgen:

python3 loadgen.py

By it opstarten loadgen toant wat as it folgjende berjocht:

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

Yn in oar terminalfinster tsjinner útfiert de folgjende berjochten nei de 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: */*

Fanút in netwurkperspektyf rint de heule applikaasje op ien host (lokale kompjûter of Cloud Shell firtuele masine). Dêrom kinne jo gebrûk meitsje localhostom fersiken te stjoeren tsjinner.
10) Stopje loadgen и tsjinner, ynfier Ctrl-c yn elk terminalfinster.
11) Yn it terminalfinster loadgen de firtuele omjouwing deaktivearje:

deactivate

Ferpakking fan in applikaasje yn konteners

Om de applikaasje op GKE út te fieren, moatte jo de foarbyldapplikaasje ynpakke - tsjinner и loadgen - yn konteners. In kontener is in manier om in applikaasje te ferpakken om it te isolearjen fan har omjouwing.

Om in applikaasje yn in kontener te ferpakken, moatte jo dockerfile. dockerfile is in teksttriem dat kommando's definiearret foar it bouwen fan 'e boarnekoade fan' e applikaasje en syn ôfhinklikens Docker ôfbylding. Ienris boud, uploade jo de ôfbylding nei in kontenerregister lykas Docker Hub of Container Registry.

It foarbyld hat al dockerfile foar tsjinner и loadgen mei alle nedige kommando's om ôfbyldings te sammeljen. Ûnder - dockerfile foar tsjinner:

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 FROM python: 3-slim as basis fertelt Docker de lêste te brûken Python 3 ôfbylding as basis.
  • team KOPY. . kopiearret de boarnebestannen nei de aktive wurkmap (allinich yn ús gefal server.py) nei it bestânsysteem fan 'e kontener.
  • YNGONGSPUNT definiearret it kommando dat wurdt brûkt om de kontener te starten. Yn ús gefal is dit kommando hast itselde as dejinge dy't jo dien hawwe server.py út boarne koade.
  • team BLOOTSTELLING jout dat oan tsjinner wachtet op gegevens troch de haven 8080. Dit team is net jout havens. Dit is in soarte fan dokumintaasje dy't nedich is om de haven te iepenjen 8080 by it starten fan de kontener.

Tariede op containerize jo applikaasje

1) Stel de folgjende omjouwingsfariabelen yn. Ferfange PROJECT_ID nei jo GCP-projekt-ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Mei help fan wearden PROJECT_ID и GCR_REPO jo tagje de Docker-ôfbylding as jo it bouwe en triuwe it nei in privee kontenerregister.

2) Stel it standert GCP-projekt yn foar it kommandorigelark gcloud.

gcloud config set project $PROJECT_ID

3) Stel de standertsône yn foar it kommandorigelark gcloud.

gcloud config set compute/zone us-central1-b

4) Soargje derfoar dat de tsjinst Container Registry is ynskeakele yn it GCP-projekt.

gcloud services enable containerregistry.googleapis.com

Containerization tsjinner

  1. Gean nei de map wêr't it foarbyld leit tsjinner:

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

  2. Meitsje de ôfbylding mei help fan dockerfile en de omjouwingsfariabelen dy't jo earder definieare:

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

Parameter -t stiet foar de Docker-tag. Dit is de namme fan de ôfbylding dy't jo brûke by it ynsetten fan de kontener.

  1. Upload de ôfbylding nei it Container Registry: 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerization fan loadgen

1) Gean nei de map wêr't it foarbyld leit loadgen:

cd ../loadgen

2) Sammelje de ôfbylding:

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

3) Upload de ôfbylding nei it kontenerregister:

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

Besjoch in list mei ôfbyldings

Kontrolearje de list mei ôfbyldings yn 'e repository en ferifiearje dat de ôfbyldings binne opladen:

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

It kommando toant de nammen fan de nij opladen ôfbyldings:

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

It meitsjen fan in GKE-kluster.

Dizze konteners kinne wurde útfierd op in Cloud Shell firtuele masine of op in kompjûter mei it kommando docker run. Mar yn in produksjeomjouwing hawwe jo in manier nedich om konteners sintraal te orkestrearjen. Jo hawwe bygelyks in systeem nedich dat derfoar soarget dat konteners altyd rinne, en jo hawwe in manier nedich om ekstra kontenereksimplaren op te skaaljen en op te spinnen as ferkear ferheget.

Om containerized applikaasjes út te fieren kinne jo brûke G.K.E.. GKE is in kontenerorkestraasjeplatfoarm dat firtuele masines aggregearret yn in kluster. Elke firtuele masine wurdt in knooppunt neamd. GKE-klusters binne basearre op it iepen boarne Kubernetes-klusterbehearsysteem. Kubernetes leveret meganismen foar ynteraksje mei it kluster.

In GKE-kluster oanmeitsje:

1) Meitsje in kluster:

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

team gcloud makket in istioready-kluster yn it GCP-projekt en standertsône dy't jo opjûn hawwe. Om Istio út te fieren, riede wy oan om op syn minst 4 knopen en in firtuele masine te hawwen n1-standert-2.

It team makket it kluster yn in pear minuten. As it kluster klear is, jout it kommando soksawat út berjocht.

2) Jou bewiisbrieven yn it kommandorigelark kubectlom it te brûken om it kluster te behearjen:

gcloud container clusters get-credentials istioready

3) No kinne jo kommunisearje mei Kubernetes fia kubectl. Bygelyks kin it folgjende kommando de status fan knopen fine:

kubectl get nodes

It kommando produsearret in list mei knopen:

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 Key Concepts

It diagram lit in applikaasje op GKE sjen:

It tarieden fan in applikaasje foar Istio

Foardat jo konteners yn GKE ynsette, learje de kaaibegripen fan Kubernetes. D'r binne links oan 'e ein as jo mear wolle leare.

  • Knooppunten en klusters. Yn GKE is in knooppunt in firtuele masine. Op oare Kubernetes-platfoarms kin in knooppunt in kompjûter of in firtuele masine wêze. In kluster is in samling knopen dy't kin wurde beskôge as ien ienheid wêr't jo in kontenerisearre applikaasje ynsette.
  • Pods. Yn Kubernetes rinne konteners yn pods. In Pod yn Kubernetes is in ûndielbere ienheid. In Pod hâldt ien of mear konteners. Jo ynsette tsjinner containers en loadgen yn aparte pods. As d'r ferskate konteners yn in pod binne (bygelyks in applikaasjetsjinner en proxy tsjinner), konteners wurde beheard as ien entiteit en dielen pod-boarnen.
  • Deployments. Yn Kubernetes is in ynset in objekt dat in samling identike pods is. Ynset lanseart meardere replika's fan pods ferdield oer klusterknooppunten. Ynset ferfangt automatysk pods dy't mislearre binne of net reagearje.
  • Kubernetes tsjinst. By it útfieren fan applikaasjekoade yn GKE, de ferbining tusken loadgen и tsjinner. As jo ​​begûn tsjinsten op in Cloud Shell firtuele masine of buroblêd, Jo stjoerde fersiken nei tsjinner at localhost: 8080. Ienris ynset nei GKE, wurde pods útfierd op beskikbere knopen. Standert hawwe jo gjin kontrôle oer hokker knooppunt de pod rint, dus jo poddestuollen gjin permaninte IP-adressen.
    Om in IP-adres te krijen foar tsjinner, Jo moatte in netwurkabstraksje definiearje boppe op 'e pods. Dat is wat it is Kubernetes tsjinst. De Kubernetes-tsjinst biedt in persistint einpunt foar in set pods. Der binne in pear soarten tsjinsten. tsjinner brûkt LoadBalancer, dy't in ekstern IP-adres leveret om kontakt te meitsjen tsjinner fan bûten it kluster.
    Kubernetes hat ek in ynboude DNS-systeem dat DNS-nammen tawize (bygelyks, helloserver.default.cluster.local) tsjinsten. Hjirtroch kommunisearje pods binnen it kluster mei oare podden yn it kluster op in fêst adres. De DNS-namme kin net bûten it kluster brûkt wurde, lykas yn Cloud Shell of op in kompjûter.

Kubernetes manifestearret

As jo ​​​​de applikaasje fan 'e boarne rûnen, hawwe jo it ymperatyf kommando brûkt python3

server.py

Imperatyf betsjut in tiidwurd: "dit dwaan."

Kubernetes brûkt declarative model. Dit betsjut dat wy Kubernetes net krekt fertelle wat te dwaan, mar leaver de winske steat beskriuwe. Bygelyks, Kubernetes begjint en stopet pods as nedich om te soargjen dat de eigentlike steat fan it systeem oerienkomt mei de winske steat.

Jo jouwe de winske steat oan yn manifesten of triemmen YAML. In YAML-bestân befettet spesifikaasjes foar ien of mear Kubernetes-objekten.

It foarbyld befettet in YAML triem foar tsjinner и loadgen. Elk YAML-bestân spesifisearret de winske steat fan it ynsetobjekt en Kubernetes-tsjinst.

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

  • soart jout it type fan it objekt oan.
  • metadata.name spesifisearret de ynset namme.
  • Earste fjild Spec befettet in beskriuwing fan de winske steat.
  • spec.replicas jout it winske oantal pods oan.
  • Seksje spec.template definiearret in pod sjabloan. D'r is in fjild yn 'e podspesifikaasje byld, dy't de namme spesifisearret fan 'e ôfbylding dy't ekstrahearre wurde moat út it Container Registry.

De tsjinst wurdt definiearre as folget:

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

  • LoadBalancer: Klanten stjoere fersiken nei it IP-adres fan 'e loadbalancer, dy't in oanhâldend IP-adres hat en tagonklik is fan bûten it kluster.
  • targetPort: as jo ûnthâlde, it team EXPOSE 8080 в dockerfile joech gjin havens. Jo jouwe de haven 8080sadat jo kontakt opnimme kinne mei de kontener tsjinner bûten it kluster. Yn ús gefal hellosvc.default.cluster.local:80 (koarte Namme: hellosvc) komt oerien mei de haven 8080 Pod IP-adressen helloserver.
  • haven: Dit is it poartenûmer dêr't oare tsjinsten yn it kluster fersiken stjoere.

loadgen.yaml

Ynset foarwerp oan loadgen.yaml Liket op server.yaml. It ferskil is dat it ynsetobjekt in seksje befettet sawat. It definiearret de omjouwingsfariabelen dy't nedich binne loadgen en dy't jo ynstalleare by it útfieren fan de applikaasje fan 'e boarne.

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

Tiid loadgen akseptearret gjin ynkommende oanfragen, foar it fjild type oanjûn ClusterIP. Dit type jout in oanhâldend IP-adres dat tsjinsten yn it kluster brûke kinne, mar dit IP-adres wurdt net bleatsteld oan eksterne kliïnten.

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

Containers ynsette yn GKE

1) Gean nei de map wêr't it foarbyld leit tsjinner:

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

2) Iepenje server.yaml yn in tekstbewurker.
3) Ferfang de namme yn it fjild byld nei de namme fan jo Docker-ôfbylding.

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

Ferfange PROJECT_ID nei jo GCP-projekt-ID.
4) Bewarje en slute server.yaml.
5) Implementearje it YAML-bestân nei Kubernetes:

kubectl apply -f server.yaml

Nei suksesfolle foltôging produseart it kommando de folgjende koade:

deployment.apps/helloserver created
service/hellosvc created

6) Gean nei de map wêr loadgen:

cd ../loadgen

7) Iepenje loadgen.yaml yn in tekstbewurker.
8) Ferfang de namme yn it fjild byld nei de namme fan jo Docker-ôfbylding.

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

Ferfange PROJECT_ID nei jo GCP-projekt-ID.
9) Bewarje en slute loadgen.yaml, slute de tekstbewurker.
10) Implementearje it YAML-bestân nei Kubernetes:

kubectl apply -f loadgen.yaml

Nei suksesfolle foltôging produseart it kommando de folgjende koade:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Kontrolearje de status fan 'e pods:

kubectl get pods

It kommando toant de status:

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

12) Extract applikaasje logs út 'e pod loadgen. Ferfange POD_ID nei de ID fan it foarige antwurd.

kubectl logs loadgenerator-POD_ID

13) Krij eksterne IP-adressen hellosvc:

kubectl get service

It kommando-antwurd sjocht der sa út:

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) Stjoer in fersyk nei hellosvc: ferfange EXTERNAL_IP nei eksterne IP-adres hellosvc.

curl http://EXTERNAL_IP

Lit ús nimme op Istio

Jo hawwe al in applikaasje ynset op GKE. loadgen kin Kubernetes DNS (hello:80) om fersiken nei te stjoeren tsjinneren jo kinne fersiken stjoere nei tsjinner troch eksterne IP-adres. Hoewol Kubernetes in protte funksjes hat, ûntbrekt d'r wat ynformaasje oer de tsjinsten:

  • Hoe ynteraksje tsjinsten? Wat binne de relaasjes tusken tsjinsten? Hoe streamt ferkear tusken tsjinsten? Binne jo dat bewust loadgen stjoert fersiken nei tsjinner, mar stel jo foar dat jo neat witte oer de applikaasje. Om dizze fragen te beantwurdzjen, litte wy sjen nei de list mei rinnende pods yn GKE.
  • Metrics. Hoe lang tsjinner reagearret op in ynkommend fersyk? Hoefolle oanfragen per sekonde wurde ûntfongen troch de tsjinner? Jout it flaterberjochten?
  • Feiligens ynformaasje. Ferkear tusken loadgen и tsjinner giet gewoan troch HTTP of troch mTLS?

Istio beantwurdet al dizze fragen. Om dit te dwaan pleatst Istio in sidecar-proxy envoy yn elke pod. De Envoy-proxy ûnderskept alle ynkommende en útgeande ferkear nei applikaasjekonteners. It betsjut dat tsjinner и loadgen ûntfange fia sidecar proxy Envoy, en alle ferkear fan loadgen к tsjinner giet troch de Envoy proxy.

Ferbinings tusken Envoy-proxies foarmje in tsjinstmesh. De tsjinstmesh-arsjitektuer leveret in laach fan kontrôle boppe op Kubernetes.

It tarieden fan in applikaasje foar Istio

Sûnt Envoy-proxy's rinne yn har eigen konteners, kin Istio ynstalleare wurde boppe op in GKE-kluster mei hast gjin feroarings oan 'e applikaasjekoade. Mar jo hawwe wat wurk dien om jo applikaasje klear te meitsjen om te wurde beheard troch Istio:

  • Tsjinsten foar alle konteners. Oan ynset tsjinner и loadgen ferbûn oan de Kubernetes-tsjinst. Sels loadgen, dy't net ûntfange ynkommende oanfragen, der is in tsjinst.
  • Havens yn tsjinsten moatte nammen hawwe. Hoewol't tsjinst havens kinne ferlitten sûnder namme yn GKE, Istio fereasket dat jo oantsjutte haven namme yn oerienstimming mei syn protokol. Yn it YAML-bestân de poarte foar tsjinner wurdt neamd httpom't de tsjinner it protokol brûkt HTTP... As betsjinning brûkt gRPC, jo soene de poarte neame grpc.
  • Ynset wurde markearre. Dêrom kinne jo Istio's ferkearsbehearfunksjes brûke, lykas ferkear splitsen tusken ferzjes fan deselde tsjinst.

Ynstallaasje

D'r binne twa manieren om Istio te ynstallearjen. Kinne ynskeakelje Istio op GKE útwreiding of ynstallearje de iepen boarne ferzje fan Istio op it kluster. Mei Istio op GKE kinne jo maklik Istio-ynstallaasjes en upgrades beheare yn 'e heule GKE-klusterlibbenssyklus. As jo ​​​​de lêste ferzje fan Istio wolle of mear kontrôle oer jo konfiguraasje fan jo Istio-kontrôlepaniel, ynstallearje dan de iepen boarne ferzje ynstee fan de Istio op GKE-útwreiding. Om te besluten oer de oanpak, lês it artikel Haw ik nedich Istio op GKE?.

Selektearje in opsje, besjoch de passende hantlieding, en folgje de ynstruksjes om Istio op jo kluster te ynstallearjen. As jo ​​​​Istio wolle brûke mei jo nij ynset applikaasje, ynskeakelje sidecar ymplemintaasje foar nammeromte standert.

Reiniging

Om foar te kommen dat jo op jo Google Cloud Platform-akkount yn rekken brocht wurde foar de boarnen dy't jo yn dizze tutorial hawwe brûkt, wiskje it kontenerkluster as jo Istio hawwe ynstalleare en spielje mei de foarbyldapplikaasje. Dit sil alle klusterboarnen fuortsmite, lykas komputerynstânsjes, skiven en netwurkboarnen.

Wat is folgjende?

Boarne: www.habr.com

Add a comment