🥇Paghahanda ng aplikasyon para sa Istio

Ang Istio ay isang maginhawang tool para sa pagkonekta, pag-secure at pagsubaybay sa mga ipinamamahaging application. Gumagamit ang Istio ng iba't ibang teknolohiya para patakbuhin at pamahalaan ang software nang malawakan, kabilang ang mga container para i-package ang application code at mga dependency para sa deployment, at ang Kubernetes para pamahalaan ang mga container na iyon. Samakatuwid, upang makatrabaho ang Istio dapat mong malaman kung paano gumagana ang isang application na may maraming serbisyo batay sa mga teknolohiyang ito wala Istio. Kung pamilyar na sa iyo ang mga tool at konseptong ito, huwag mag-atubiling laktawan ang tutorial na ito at dumiretso sa seksyon Pag-install ng Istio sa Google Kubernetes Engine (GKE) o pag-install ng extension Istio sa GKE.

Isa itong step-by-step na gabay kung saan tatalakayin namin ang buong proseso mula sa source code hanggang sa container ng GKE para mabigyan ka ng pangunahing pag-unawa sa mga teknolohiyang ito sa pamamagitan ng isang halimbawa. Makikita mo rin kung paano ginagamit ng Istio ang kapangyarihan ng mga teknolohiyang ito. Ipinapalagay nito na wala kang alam tungkol sa mga container, Kubernetes, service meshes, o Istio.

gawain

Sa tutorial na ito, kukumpletuhin mo ang mga sumusunod na gawain:

Pag-aaral ng simpleng hello world application na may maraming serbisyo.
Patakbuhin ang application mula sa source code.
Pag-iimpake ng aplikasyon sa mga lalagyan.
Paggawa ng Kubernetes cluster.
Pag-deploy ng mga container sa isang cluster.

Bago ka magsimula

Sundin ang mga tagubilin upang paganahin ang Kubernetes Engine API:

Pumunta sa Pahina ng Kubernetes Engine sa Google Cloud Platform console.
Lumikha o pumili ng isang proyekto.
Maghintay hanggang ma-enable ang API at mga kaugnay na serbisyo. Maaaring tumagal ito ng ilang minuto.
Tiyaking naka-set up ang pagsingil para sa iyong proyekto sa Google Cloud Platform. Matutunan kung paano paganahin ang pagsingil.

Sa tutorial na ito, maaari mong gamitin ang Cloud Shell, na naghahanda ng virtual machine g1-maliit sa Google Compute Engine gamit ang Linux na nakabase sa Debian, o isang Linux o macOS computer.

Opsyon A: Paggamit ng Cloud Shell

Mga pakinabang ng paggamit ng Cloud Shell:

Python 2 at Python 3 development environment (kabilang ang virtualenv) ay ganap na na-configure.
Mga Tool sa Command Line gcloud, docker, pumunta и kubectl, na aming gagamitin ay naka-install na.
Marami kang mapagpipilian mga text editor:
1. Editor ng code, na bubukas gamit ang icon ng pag-edit sa itaas ng window ng Cloud Shell.
2. Emacs, Vim o Nano, na bubukas mula sa command line sa Cloud Shell.

Para magamit Cloud Shell:

Pumunta sa GCP console.
I-click ang pindutan I-activate ang Cloud Shell (I-activate ang Cloud Shell) sa itaas ng GCP console window.

Sa ibabang bahagi GCP console Magbubukas sa bagong window ang isang session sa Cloud Shell na may command line.

Opsyon B: Paggamit ng Command Line Tools Lokal

Kung nagtatrabaho ka sa isang computer na nagpapatakbo ng Linux o macOS, kakailanganin mong i-configure at i-install ang mga sumusunod na bahagi:

I-customize Python 3 at Python 2 development environment.
I-install ang Cloud SDK gamit ang command line tool gcloud.
Itakda kubectl - tool sa command line para magtrabaho kasama Kubernetes.
```
gcloud components install kubectl
```
Itakda Docker Community Edition (CE). Gagamitin mo ang command line tool dockerupang lumikha ng mga imahe ng lalagyan para sa sample na application.
I-install ang tool Kontrol ng bersyon ng Gitupang makuha ang sample na application mula sa GitHub.

Mag-download ng sample code

I-download ang source code helloserver:

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

Pumunta sa direktoryo ng halimbawang code:
```
cd istio-samples/sample-apps/helloserver
```

Paggalugad ng isang application na may maraming serbisyo

Ang sample na application ay nakasulat sa Python at binubuo ng dalawang bahagi na nakikipag-ugnayan gamit REST:

server: simpleng server na may isang endpoint GET, /, na nagpi-print ng "hello world" sa console.
loadgen: script na nagpapadala ng trapiko sa server, na may na-configure na bilang ng mga kahilingan sa bawat segundo.

Pagpapatakbo ng isang application mula sa source code

Upang i-explore ang sample na application, patakbuhin ito sa Cloud Shell o sa iyong computer.
1) Sa catalog istio-samples/sample-apps/helloserver tumakbo server:

python3 server/server.py

Sa pagsisimula server ang sumusunod ay ipinapakita:

INFO:root:Starting server...

2) Magbukas ng isa pang terminal window para magpadala ng mga kahilingan server. Kung gumagamit ka ng Cloud Shell, i-click ang icon na magdagdag upang magbukas ng isa pang session.
3) Magpadala ng kahilingan sa server:

curl http://localhost:8080

sagot ng server:

Hello World!

4) Mula sa direktoryo kung saan mo na-download ang sample code, pumunta sa direktoryo na naglalaman loadgen:

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

5) Lumikha ng mga sumusunod na variable ng kapaligiran:

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

6) Tumakbo virtualenv:

virtualenv --python python3 env

7) I-activate ang virtual na kapaligiran:

source env/bin/activate

8) Magtakda ng mga kinakailangan para sa loadgen:

pip3 install -r requirements.txt

9) Tumakbo loadgen:

python3 loadgen.py

Sa pagsisimula loadgen nagpapakita ng isang bagay tulad ng sumusunod na mensahe:

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

Sa isa pang terminal window server output ang mga sumusunod na mensahe sa 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: */*

Mula sa pananaw sa networking, ang buong application ay tumatakbo sa isang host (lokal na computer o Cloud Shell virtual machine). Samakatuwid maaari mong gamitin localhostupang magpadala ng mga kahilingan sa server.
10) Para huminto loadgen и server, pumasok Ctrl-c sa bawat terminal window.
11) Sa terminal window loadgen i-deactivate ang virtual na kapaligiran:

deactivate

Pag-iimpake ng isang application sa mga lalagyan

Upang patakbuhin ang application sa GKE, kailangan mong i-package ang sample na application − server и loadgen - sa Lalagyan. Ang isang lalagyan ay isang paraan upang i-package ang isang application upang ihiwalay ito sa kapaligiran nito.

Upang i-package ang isang application sa isang lalagyan, kailangan mo dockerfile. dockerfile ay isang text file na tumutukoy sa mga command para sa pagbuo ng source code ng application at sa mga dependency nito Larawan ng docker. Kapag nabuo na, ia-upload mo ang larawan sa isang container registry gaya ng Docker Hub o Registry ng Container.

Ang halimbawa ay mayroon na dockerfile para sa server и loadgen kasama ang lahat ng kinakailangang mga utos upang mangolekta ng mga imahe. sa ibaba - dockerfile para sa 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" ]

Koponan MULA sa python:3-slim bilang base nagsasabi sa Docker na gamitin ang pinakabago Larawan ng Python 3 bilang batayan.
Koponan KOPYA. . kinokopya ang mga source file sa kasalukuyang gumaganang direktoryo (sa aming kaso lamang server.py) sa file system ng container.
PASUKAN tumutukoy sa utos na ginagamit upang simulan ang lalagyan. Sa aming kaso, ang utos na ito ay halos kapareho ng dati mong pinapatakbo server.py mula sa source code.
Koponan I-expose nagpapahiwatig na server naghihintay para sa data sa pamamagitan ng port 8080. Ang pangkat na ito ay hindi nagbibigay ng mga port. Ito ay ilang uri ng dokumentasyon na kailangan para buksan ang port 8080 kapag sinimulan ang lalagyan.

Naghahanda na ilagay sa container ang iyong aplikasyon

1) Itakda ang mga sumusunod na variable ng kapaligiran. Palitan PROJECT_ID sa iyong GCP project ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Paggamit ng mga halaga PROJECT_ID и GCR_REPO ita-tag mo ang imahe ng Docker kapag binuo mo ito at itulak ito sa isang pribadong Container Registry.

2) Itakda ang default na proyekto ng GCP para sa command line tool gcloud.

gcloud config set project $PROJECT_ID

3) Itakda ang default na zone para sa command line tool gcloud.

gcloud config set compute/zone us-central1-b

4) Tiyaking naka-enable ang serbisyo ng Container Registry sa proyekto ng GCP.

gcloud services enable containerregistry.googleapis.com

Server ng containerization

Pumunta sa direktoryo kung saan matatagpuan ang halimbawa server:

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

Ipunin ang larawan gamit ang dockerfile at ang mga variable ng kapaligiran na tinukoy mo kanina:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parametro -t kumakatawan sa tag ng Docker. Ito ang pangalan ng larawang ginagamit mo kapag nagde-deploy ng container.

I-upload ang larawan sa Container Registry:

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

Containerization ng loadgen

1) Pumunta sa direktoryo kung saan matatagpuan ang halimbawa loadgen:

cd ../loadgen

2) Kolektahin ang larawan:

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

3) I-upload ang larawan sa Container Registry:

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

Tingnan ang isang listahan ng mga larawan

Suriin ang listahan ng mga larawan sa repositoryo at i-verify na ang mga larawan ay na-upload na:

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

Ipinapakita ng utos ang mga pangalan ng mga bagong na-upload na larawan:

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

Gumagawa ng cluster ng GKE.

Ang mga container na ito ay maaaring patakbuhin sa isang Cloud Shell virtual machine o sa isang computer na may command docker run. Ngunit sa isang kapaligiran ng produksyon, kailangan mo ng isang paraan para sa sentral na pagsasaayos ng mga lalagyan. Halimbawa, kailangan mo ng system na tinitiyak na palaging tumatakbo ang mga container, at kailangan mo ng paraan upang palakihin at palakihin ang mga karagdagang instance ng container kung tataas ang trapiko.

Upang magpatakbo ng mga containerized na application na maaari mong gamitin G.K.E.. Ang GKE ay isang container orchestration platform na pinagsasama-sama ang mga virtual machine sa isang cluster. Ang bawat virtual machine ay tinatawag na node. Ang mga cluster ng GKE ay batay sa open source na Kubernetes cluster management system. Nagbibigay ang Kubernetes ng mga mekanismo para sa pakikipag-ugnayan sa cluster.

Paglikha ng isang cluster ng GKE:

1) Lumikha ng isang kumpol:

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

Koponan gcloud lumilikha ng istioready na cluster sa proyekto ng GCP at default na zone na iyong tinukoy. Upang patakbuhin ang Istio, inirerekomenda namin ang pagkakaroon ng hindi bababa sa 4 na node at isang virtual machine n1-pamantayan-2.

Lumilikha ang koponan ng kumpol sa loob ng ilang minuto. Kapag handa na ang kumpol, ang utos ay naglalabas ng ganito mensahe.

2) Magbigay ng mga kredensyal sa command line tool kubectlpara gamitin ito para pamahalaan ang cluster:

gcloud container clusters get-credentials istioready

3) Ngayon ay maaari kang makipag-ugnayan sa Kubernetes sa pamamagitan ng kubectl. Halimbawa, maaaring malaman ng sumusunod na command ang katayuan ng mga node:

kubectl get nodes

Ang utos ay gumagawa ng isang listahan ng mga node:

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

Mga Pangunahing Konsepto ng Kubernetes

Ang diagram ay nagpapakita ng isang application sa GKE:

Bago ka mag-deploy ng mga container sa GKE, alamin ang mga pangunahing konsepto ng Kubernetes. May mga link sa pinakadulo kung gusto mong matuto pa.

Mga node at kumpol. Sa GKE, ang isang node ay isang virtual machine. Sa iba pang mga platform ng Kubernetes, ang isang node ay maaaring isang computer o isang virtual machine. Ang cluster ay isang koleksyon ng mga node na maaaring ituring na isang unit kung saan ka nag-deploy ng containerized na application.
Mga pod. Sa Kubernetes, ang mga container ay tumatakbo sa mga pod. Ang Pod sa Kubernetes ay isang hindi mahahati na unit. Ang isang Pod ay naglalaman ng isa o higit pang mga lalagyan. Nag-deploy ka ng mga lalagyan ng server at loadgen sa magkahiwalay na mga pod. Kapag may ilang container sa isang pod (halimbawa, isang application server at proxy server), ang mga container ay pinamamahalaan bilang isang entity at nagbabahagi ng mga mapagkukunan ng pod.
Mga deployment. Sa Kubernetes, ang deployment ay isang object na isang koleksyon ng mga magkatulad na pod. Ang deployment ay naglulunsad ng maraming replika ng mga pod na ipinamahagi sa mga cluster node. Awtomatikong pinapalitan ng deployment ang mga pod na nabigo o hindi tumutugon.
Serbisyo ng Kubernetes. Kapag nagpapatakbo ng application code sa GKE, ang koneksyon sa pagitan loadgen и server. Noong nagsimula ka ng mga serbisyo sa isang Cloud Shell virtual machine o desktop, nagpadala ka ng mga kahilingan sa server по адресу localhost: 8080. Kapag na-deploy na sa GKE, ipapatupad ang mga pod sa mga available na node. Bilang default, wala kang kontrol sa kung saang node tumatakbo ang pod, kaya ikaw mga pod walang permanenteng IP address.
Upang makakuha ng IP address para sa server, kailangan mong tukuyin ang abstraction ng network sa ibabaw ng mga pod. Iyon na iyon Serbisyo ng Kubernetes. Ang serbisyo ng Kubernetes ay nagbibigay ng patuloy na endpoint para sa isang hanay ng mga pod. Mayroong kaunti mga uri ng serbisyo. server gumagamit LoadBalancer, na nagbibigay ng panlabas na IP address para makipag-ugnayan server mula sa labas ng kumpol.
Ang Kubernetes ay mayroon ding built-in na DNS system na nagtatalaga ng mga pangalan ng DNS (halimbawa, helloserver.default.cluster.local) mga serbisyo. Dahil dito, ang mga pod sa loob ng cluster ay nakikipag-ugnayan sa iba pang mga pod sa cluster sa isang permanenteng address. Hindi magagamit ang pangalan ng DNS sa labas ng cluster, gaya ng sa Cloud Shell o sa isang computer.

Nagpapakita ang mga Kubernetes

Kapag pinatakbo mo ang application mula sa pinagmulan, ginamit mo ang imperative command python3

server.py

Ang imperative ay nagpapahiwatig ng isang pandiwa: "gawin mo ito."

Ginagamit ng Kubernetes deklaratibong modelo. Nangangahulugan ito na hindi namin sinasabi sa Kubernetes nang eksakto kung ano ang gagawin, ngunit sa halip ay naglalarawan sa nais na estado. Halimbawa, sinisimulan at ihihinto ng Kubernetes ang mga pod kung kinakailangan upang matiyak na ang aktwal na estado ng system ay tumutugma sa gustong estado.

Isinasaad mo ang gustong estado sa mga manifest o file Yaml. Ang isang YAML file ay naglalaman ng mga detalye para sa isa o higit pang mga bagay sa Kubernetes.

Ang halimbawa ay naglalaman ng isang YAML file para sa server и loadgen. Tinutukoy ng bawat YAML file ang gustong estado ng deployment object at serbisyo ng Kubernetes.

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

uri nagsasaad ng uri ng bagay.
metadata.name tumutukoy sa pangalan ng deployment.
Unang field pagsasapalaran naglalaman ng isang paglalarawan ng nais na estado.
spec.replicas ay nagpapahiwatig ng nais na bilang ng mga pod.
Seksyon spec.template tumutukoy sa isang pod template. Mayroong isang patlang sa detalye ng pod larawan, na tumutukoy sa pangalan ng larawan na kailangang kunin mula sa Container Registry.

Ang serbisyo ay tinukoy bilang mga sumusunod:

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

LoadBalancer: Ang mga kliyente ay nagpapadala ng mga kahilingan sa IP address ng load balancer, na may patuloy na IP address at naa-access mula sa labas ng cluster.
targetPort: tulad ng naaalala mo, ang koponan EXPOSE 8080 в dockerfile hindi nagbigay ng mga port. Ibigay mo ang port 8080para makontak mo ang lalagyan server sa labas ng kumpol. Sa kaso natin hellosvc.default.cluster.local:80 (maikling pangalan: hellosvc) ay tumutugma sa port 8080 Mga IP address ng pod helloserver.
port: Ito ang port number kung saan magpapadala ng mga kahilingan ang ibang mga serbisyo sa cluster.

loadgen.yaml

Deployment object sa loadgen.yaml kamukha server.yaml. Ang pagkakaiba ay ang deployment object ay naglalaman ng isang seksyon env. Tinutukoy nito ang mga variable ng kapaligiran na kinakailangan loadgen at na iyong na-install kapag pinapatakbo ang application mula sa pinagmulan.

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

oras loadgen ay hindi tumatanggap ng mga papasok na kahilingan, para sa field uri ipinahiwatig ClusterIP. Ang uri na ito ay nagbibigay ng patuloy na IP address na maaaring gamitin ng mga serbisyo sa cluster, ngunit ang IP address na ito ay hindi nakalantad sa mga panlabas na kliyente.

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

Pag-deploy ng Mga Container sa GKE

1) Pumunta sa direktoryo kung saan matatagpuan ang halimbawa server:

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

2) Buksan server.yaml sa isang text editor.
3) Palitan ang pangalan sa field larawan sa pangalan ng iyong larawan ng Docker.

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

Palitan PROJECT_ID sa iyong GCP project ID.
4) I-save at isara server.yaml.
5) I-deploy ang YAML file sa Kubernetes:

kubectl apply -f server.yaml

Sa matagumpay na pagkumpleto, ang utos ay gumagawa ng sumusunod na code:

deployment.apps/helloserver created
service/hellosvc created

6) Pumunta sa direktoryo kung saan loadgen:

cd ../loadgen

7) Buksan loadgen.yaml sa isang text editor.
8) Palitan ang pangalan sa field larawan sa pangalan ng iyong larawan ng Docker.

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

Palitan PROJECT_ID sa iyong GCP project ID.
9) I-save at isara loadgen.yaml, isara ang text editor.
10) I-deploy ang YAML file sa Kubernetes:

kubectl apply -f loadgen.yaml

Sa matagumpay na pagkumpleto, ang utos ay gumagawa ng sumusunod na code:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Suriin ang katayuan ng mga pod:

kubectl get pods

Ipinapakita ng utos ang katayuan:

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

12) I-extract ang mga log ng application mula sa pod loadgen. Palitan POD_ID sa identifier mula sa nakaraang sagot.

kubectl logs loadgenerator-POD_ID

13) Kumuha ng mga panlabas na IP address hellosvc:

kubectl get service

Ang tugon ng command ay ganito ang hitsura:

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) Magpadala ng kahilingan sa hellosvc: palitan EXTERNAL_IP sa panlabas na IP address hellosvc.

curl http://EXTERNAL_IP

Sagutin natin si Istio

Mayroon ka nang application na naka-deploy sa GKE. loadgen maaaring gumamit ng Kubernetes DNS (hellosvc:80) upang magpadala ng mga kahilingan sa serverat maaari kang magpadala ng mga kahilingan sa server sa pamamagitan ng panlabas na IP address. Bagama't maraming feature ang Kubernetes, may nawawalang impormasyon tungkol sa mga serbisyo:

Paano nakikipag-ugnayan ang mga serbisyo? Ano ang mga ugnayan sa pagitan ng mga serbisyo? Paano dumadaloy ang trapiko sa pagitan ng mga serbisyo? Aware ka ba dun loadgen nagpapadala ng mga kahilingan sa server, ngunit isipin na wala kang alam tungkol sa application. Para masagot ang mga tanong na ito, tingnan natin ang listahan ng mga tumatakbong pod sa GKE.
Mga sukatan. Gaano katagal server tumutugon sa isang papasok na kahilingan? Ilang kahilingan kada segundo ang natatanggap ng server? Nagbibigay ba ito ng mga mensahe ng error?
Impormasyon sa Seguridad. Trapiko sa pagitan loadgen и server dumadaan lang HTTP o ni mTLS?

Sinasagot ni Istio ang lahat ng tanong na ito. Para magawa ito, naglalagay si Istio ng sidecar proxy Sugo sa bawat pod. Hinaharang ng Envoy proxy ang lahat ng papasok at papalabas na trapiko sa mga container ng application. Ibig sabihin nito ay server и loadgen makatanggap sa pamamagitan ng sidecar proxy Envoy, at lahat ng trapiko mula sa loadgen к server dumadaan sa Envoy proxy.

Ang mga koneksyon sa pagitan ng mga proxy ng Envoy ay bumubuo ng isang service mesh. Ang arkitektura ng mesh ng serbisyo ay nagbibigay ng isang layer ng kontrol sa ibabaw ng Kubernetes.

Dahil tumatakbo ang mga proxy ng Envoy sa sarili nilang mga container, maaaring i-install ang Istio sa ibabaw ng isang cluster ng GKE na halos walang pagbabago sa application code. Ngunit gumawa ka ng ilang trabaho upang maihanda ang iyong aplikasyon na pangasiwaan ng Istio:

Mga serbisyo para sa lahat ng lalagyan. Sa mga deployment server и loadgen nakatali sa serbisyo ng Kubernetes. Kahit na loadgen, na hindi tumatanggap ng mga papasok na kahilingan, mayroong serbisyo.
Ang mga port sa mga serbisyo ay dapat may mga pangalan. Bagama't maaaring iwanang walang pangalan ang mga port ng serbisyo sa GKE, hinihiling sa iyo ng Istio na tukuyin pangalan ng port alinsunod sa kanyang protocol. Sa YAML file ang port para sa server tinawagan httpdahil ginagamit ng server ang protocol HTTP... Kung serbisyo ginamit gRPC, pangalanan mo ang port grpc.
Na-flag ang mga deployment. Samakatuwid, maaari mong gamitin ang mga feature ng pamamahala ng trapiko ng Istio, gaya ng paghahati ng trapiko sa pagitan ng mga bersyon ng parehong serbisyo.

Pag-install ng Istio

Mayroong dalawang paraan upang i-install ang Istio. Pwede paganahin ang Istio sa extension ng GKE o i-install ang open source na bersyon ng Istio sa kumpol. Sa Istio sa GKE, madali mong mapapamahalaan ang mga pag-install at pag-upgrade ng Istio sa buong GKE cluster lifecycle. Kung gusto mo ang pinakabagong bersyon ng Istio o higit pang kontrol sa iyong configuration ng Istio control panel, i-install ang open source na bersyon sa halip na ang Istio on GKE extension. Upang magpasya sa diskarte, basahin ang artikulo Kailangan ko ba ng Istio sa GKE?.

Pumili ng opsyon, suriin ang naaangkop na gabay, at sundin ang mga tagubilin para i-install ang Istio sa iyong cluster. Kung gusto mong gamitin ang Istio sa iyong bagong deployed na application, paganahin ang pagpapatupad ng sidecar para sa namespace default.

Очистка

Upang maiwasang masingil sa iyong Google Cloud Platform account para sa mga mapagkukunang ginamit mo sa tutorial na ito, tanggalin ang container cluster kapag na-install mo na ang Istio at naglaro sa sample na application. Aalisin nito ang lahat ng mapagkukunan ng kumpol, tulad ng mga instance ng pagkalkula, mga disk, at mga mapagkukunan ng network.

Ano ang susunod?

Galugarin ang mga sumusunod na teknolohiya:
Galugarin ang mga sumusunod na tool:
Alamin ang mga konsepto ng Kubernetes:

Pinagmulan: www.habr.com

Paghahanda ng aplikasyon para sa Istio