ProHoster > Օրագիր > Վարչակազմը > Istio-ի համար դիմումի պատրաստում

Istio-ի համար դիմումի պատրաստում

Istio-ի համար դիմումի պատրաստում

Istio-ն հարմար գործիք է բաշխված հավելվածների միացման, ապահովման և մոնիտորինգի համար: Istio-ն օգտագործում է մի շարք տեխնոլոգիաներ՝ ծրագրային ապահովման մասշտաբով գործարկելու և կառավարելու համար, ներառյալ կոնտեյներներ՝ կիրառական ծածկագրերը փաթեթավորելու և տեղակայման համար կախվածությունները, և Kubernetes-ը՝ այդ բեռնարկղերը կառավարելու համար: Հետևաբար, Istio-ի հետ աշխատելու համար դուք պետք է իմանաք, թե ինչպես է աշխատում այս տեխնոլոգիաների վրա հիմնված բազմաթիվ ծառայություններով հավելվածը առանց Իստիո. Եթե ​​այս գործիքներն ու հասկացությունները արդեն ծանոթ են ձեզ, ազատ զգալ բաց թողեք այս ձեռնարկը և անմիջապես անցեք բաժին Istio-ի տեղադրում Google Kubernetes Engine-ում (GKE) կամ ընդլայնման տեղադրում Իստիո GKE-ի վրա.

Սա քայլ առ քայլ ուղեցույց է, որտեղ մենք կանցնենք ողջ գործընթացի միջով սկզբնական կոդից մինչև GKE կոնտեյներ՝ օրինակի միջոցով ձեզ այս տեխնոլոգիաների հիմնական ըմբռնումը տալու համար: Դուք նաև կտեսնեք, թե ինչպես է Istio-ն օգտագործում այս տեխնոլոգիաների ուժը: Սա ենթադրում է, որ դուք ոչինչ չգիտեք բեռնարկղերի, Kubernetes-ի, սպասարկման ցանցերի կամ Istio-ի մասին:

խնդիրները

Այս ձեռնարկում դուք կկատարեք հետևյալ առաջադրանքները.

  1. Սովորելով մի պարզ բարև աշխարհ հավելված՝ բազմաթիվ ծառայություններով:
  2. Գործարկեք հավելվածը սկզբնական կոդից:
  3. Հավելվածի փաթեթավորում տարաներով:
  4. Kubernetes կլաստերի ստեղծում:
  5. Կոնտեյներների տեղակայում կլաստերի մեջ:

Նախքան սկսելը

Հետևեք հրահանգներին՝ Kubernetes Engine API-ն միացնելու համար.

  1. Գնացեք Kubernetes Engine էջ Google Cloud Platform վահանակում:
  2. Ստեղծեք կամ ընտրեք նախագիծ:
  3. Սպասեք մինչև API-ն և հարակից ծառայությունները միացվեն: Սա կարող է տևել մի քանի րոպե:
  4. Համոզվեք, որ վճարումը կարգավորված է ձեր Google Cloud Platform նախագծի համար: Իմացեք, թե ինչպես միացնել վճարումները.

Այս ձեռնարկում կարող եք օգտագործել Cloud Shell-ը, որը պատրաստում է վիրտուալ մեքենան g1-small Google Compute Engine-ում Debian-ի վրա հիմնված Linux-ի կամ Linux-ի կամ macOS համակարգչի հետ:

Տարբերակ Ա. Օգտագործելով Cloud Shell-ը

Cloud Shell-ի օգտագործման առավելությունները.

  • Python 2 և Python 3 զարգացման միջավայրեր (ներառյալ վիրտուալենվ) լիովին կազմաձևված են:
  • Հրամանի տող գործիքներ gcloud, դոկտոր, գիտ и կուբեկտլ, որոնք մենք կօգտագործենք արդեն տեղադրված են։
  • Դուք ունեք մի քանի ընտրություն տեքստային խմբագիրներ:
    1. Կոդի խմբագիր, որը բացվում է Cloud Shell պատուհանի վերևում գտնվող խմբագրման պատկերակով:
    2. Emacs, Vim կամ Nano, որոնք բացվում են Cloud Shell-ի հրամանի տողից:

Օգտագործել Cloud Shell:

  1. Գնացեք GCP վահանակ:
  2. Կտտացրեք կոճակը Ակտիվացրեք Cloud Shell-ը (Ակտիվացրեք Cloud Shell-ը) GCP վահանակի պատուհանի վերևում:

Istio-ի համար դիմումի պատրաստում

Ստորին մասում GCP կոնսոլ Cloud Shell նիստը հրամանի տողով կբացվի նոր պատուհանում:

Istio-ի համար դիմումի պատրաստում

Տարբերակ B. Օգտագործելով հրամանի տող գործիքները տեղայնորեն

Եթե ​​դուք աշխատելու եք Linux կամ macOS աշխատող համակարգչի վրա, ապա ձեզ հարկավոր է կարգավորել և տեղադրել հետևյալ բաղադրիչները.

  1. Անհատականացնել Python 3 և Python 2 զարգացման միջավայր.

  2. Տեղադրեք Cloud SDK-ն հրամանի տողի գործիքով gcloud.

  3. Տեղադրեք կուբեկտլ - հրամանի տողի հետ աշխատելու գործիք Կուբերնետես.

    gcloud components install kubectl

  4. Տեղադրեք Docker Community Edition (CE). Դուք կօգտագործեք հրամանի տողի գործիքը դոկտորնմուշի հավելվածի համար կոնտեյների պատկերներ ստեղծելու համար:

  5. Տեղադրեք գործիքը Git տարբերակի վերահսկումGitHub-ից նմուշի դիմումը ստանալու համար:

Ներբեռնեք օրինակելի կոդը

  1. Ներբեռնեք աղբյուրի կոդը բարև սպասարկող:

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

  2. Գնացեք օրինակի կոդի գրացուցակ.

    cd istio-samples/sample-apps/helloserver

Բազմաթիվ ծառայություններով հավելվածի ուսումնասիրություն

Նմուշ հավելվածը գրված է Python-ով և բաղկացած է երկու բաղադրիչից, որոնք փոխազդում են՝ օգտագործելով ՀԱՆԳՍՏՅԱՆ:

  • սերվերպարզ սերվեր մեկ վերջնակետով ՁԵՌՔ, /, որը վահանակում տպում է «բարև աշխարհ»:
  • բեռնիչ: սկրիպտ, որն ուղարկում է երթևեկությունը սերվեր, վայրկյանում կարգավորվող հարցումների քանակով:

Istio-ի համար դիմումի պատրաստում

Ծրագրի գործարկում սկզբնական կոդից

Նմուշի հավելվածը ուսումնասիրելու համար գործարկեք այն Cloud Shell-ում կամ ձեր համակարգչում:
1) կատալոգում istio-samples/sample-apps/helloserver վազել սերվեր:

python3 server/server.py

Վազելիս սերվեր ցուցադրվում է հետևյալը.

INFO:root:Starting server...

2) Բացեք մեկ այլ տերմինալի պատուհան՝ հարցումներ ուղարկելու համար սերվեր. Եթե ​​դուք օգտագործում եք Cloud Shell-ը, սեղմեք ավելացնել պատկերակը ևս մեկ նիստ բացելու համար:
3) հարցում ուղարկել սերվեր:

curl http://localhost:8080

սերվերի պատասխանները.

Hello World!

4) Այն գրացուցակից, որտեղ դուք ներբեռնել եք օրինակի կոդը, գնացեք այն գրացուցակը, որը պարունակում է բեռնիչ:

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

5) Ստեղծեք հետևյալ միջավայրի փոփոխականները.

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

6) Վազիր վիրտուալենվ:

virtualenv --python python3 env

7) Ակտիվացրեք վիրտուալ միջավայրը.

source env/bin/activate

8) սահմանել պահանջներ բեռնիչ:

pip3 install -r requirements.txt

9) Վազիր բեռնիչ:

python3 loadgen.py

Վազելիս բեռնիչ ցուցադրում է հետևյալ հաղորդագրության նման մի բան.

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

Մեկ այլ տերմինալի պատուհանում սերվեր Վահանակին թողարկում է հետևյալ հաղորդագրությունները.

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

Ցանցի տեսանկյունից ամբողջ հավելվածն աշխատում է մեկ հոսթի վրա (տեղական համակարգիչ կամ Cloud Shell վիրտուալ մեքենա): Այսպիսով, դուք կարող եք օգտագործել localhostհարցումներ ուղարկելու համար սերվեր.
10) կանգ առնել բեռնիչ и սերվեր, մուտքագրեք Ctrl-c յուրաքանչյուր տերմինալի պատուհանում:
11) Տերմինալի պատուհանում բեռնիչ ապաակտիվացնել վիրտուալ միջավայրը.

deactivate

Հավելվածի փաթեթավորում տարաներով

Հավելվածը GKE-ում գործարկելու համար անհրաժեշտ է փաթեթավորել նմուշի հավելվածը − սերվեր и բեռնիչ - ին տարաներ. Կոնտեյները հավելվածը փաթեթավորելու միջոց է՝ այն իր միջավայրից մեկուսացնելու համար:

Հավելվածը տարայի մեջ փաթեթավորելու համար ձեզ հարկավոր է dockerfile. dockerfile տեքստային ֆայլ է, որը սահմանում է հրամաններ՝ հավելվածի սկզբնական կոդը և դրա կախվածությունները կառուցելու համար Դոկերի պատկեր: Կառուցվելուց հետո դուք վերբեռնում եք պատկերը կոնտեյների ռեեստրում, ինչպիսին է Docker Hub կամ Կոնտեյներների ռեեստր.

Օրինակն արդեն կա dockerfile համար սերվեր и բեռնիչ պատկերներ հավաքելու համար անհրաժեշտ բոլոր հրամաններով: Ստորև - dockerfile համար սերվեր:

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

  • Թիմ Պիթոնից:3-բարակ որպես հիմք ասում է Docker-ին օգտագործել վերջինը Python 3 պատկեր որպես հիմք:
  • Թիմ ՊԱՏՃԱՌ. . պատճենում է աղբյուրի ֆայլերը ընթացիկ աշխատանքային գրացուցակում (միայն մեր դեպքում server.py) կոնտեյների ֆայլային համակարգին:
  • ՄՈՒՏՔԻ ԿԵՏ սահմանում է հրամանը, որն օգտագործվում է բեռնարկղը գործարկելու համար: Մեր դեպքում այս հրամանը գրեթե նույնն է, ինչ դուք գործարկում էիք server.py սկզբնական կոդից։
  • Թիմ ԲԱՑԱՀԱՅՏԵԼ ցույց է տալիս, որ սերվեր սպասում է տվյալների պորտի միջոցով 8080. Այս թիմը չէ ապահովում է նավահանգիստներ. Սա ինչ-որ փաստաթուղթ է, որն անհրաժեշտ է նավահանգիստը բացելու համար 8080 կոնտեյները գործարկելիս.

Ձեր դիմումը կոնտեյներականացնելու պատրաստում

1) Սահմանեք հետևյալ միջավայրի փոփոխականները. Փոխարինել PROJECT_ID ձեր GCP նախագծի ID-ին:

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Օգտագործելով արժեքներ PROJECT_ID и GCR_REPO դուք նշում եք Docker պատկերը, երբ այն կառուցում եք և այն մղում մասնավոր կոնտեյներային ռեգիստր:

2) Սահմանեք լռելյայն GCP նախագիծը հրամանի տողի գործիքի համար gcloud.

gcloud config set project $PROJECT_ID

3) Սահմանեք հրամանի տող գործիքի լռելյայն գոտին gcloud.

gcloud config set compute/zone us-central1-b

4) Համոզվեք, որ Container Registry ծառայությունը միացված է GCP նախագծում:

gcloud services enable containerregistry.googleapis.com

Կոնտեյներացման սերվեր

  1. Գնացեք այն գրացուցակը, որտեղ գտնվում է օրինակը սերվեր:

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

  2. Հավաքեք պատկերը օգտագործելով dockerfile և շրջակա միջավայրի փոփոխականները, որոնք դուք սահմանել եք ավելի վաղ.

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

Parameter -t ներկայացնում է Docker թեգը: Սա պատկերի անունն է, որն օգտագործում եք բեռնարկղը տեղակայելիս:

  1. Վերբեռնեք պատկերը կոնտեյների ռեեստր. 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Բեռնատարի կոնտեյներացում

1) Գնացեք այն գրացուցակը, որտեղ գտնվում է օրինակը բեռնիչ:

cd ../loadgen

2) Հավաքեք պատկերը.

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

3) Վերբեռնեք պատկերը կոնտեյների ռեեստր.

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

Դիտեք պատկերների ցանկը

Վերանայեք պահեստի պատկերների ցանկը և հաստատեք, որ պատկերները վերբեռնված են.

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

Հրամանը ցուցադրում է նոր բեռնված պատկերների անունները.

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

GKE կլաստերի ստեղծում:

Այս բեռնարկղերը կարող են գործարկվել Cloud Shell վիրտուալ մեքենայի վրա կամ հրամանով համակարգչի վրա docker վազում. Բայց արտադրական միջավայրում ձեզ անհրաժեշտ է միջոց՝ կոնտեյներները կենտրոնական կերպով կազմակերպելու համար: Օրինակ, ձեզ անհրաժեշտ է համակարգ, որը երաշխավորում է, որ բեռնարկղերը միշտ աշխատում են, և ձեզ անհրաժեշտ է միջոց՝ մեծացնելու և պտտելու լրացուցիչ կոնտեյներների օրինակները, եթե երթևեկությունը մեծանա:

Կոնտեյներային հավելվածներ գործարկելու համար կարող եք օգտագործել Գ.Կ.Ե.. GKE-ը կոնտեյներային նվագախմբային հարթակ է, որը միավորում է վիրտուալ մեքենաները կլաստերի մեջ: Յուրաքանչյուր վիրտուալ մեքենա կոչվում է հանգույց: GKE կլաստերները հիմնված են բաց կոդով Kubernetes կլաստերի կառավարման համակարգի վրա: Kubernetes-ն ապահովում է կլաստերի հետ փոխազդելու մեխանիզմներ։

GKE կլաստերի ստեղծում.

1) Ստեղծեք կլաստեր.

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

Թիմ gcloud ստեղծում է Istioready կլաստեր GCP նախագծում և ձեր նշած լռելյայն գոտում: Istio-ն գործարկելու համար խորհուրդ ենք տալիս ունենալ առնվազն 4 հանգույց և վիրտուալ մեքենա n1-ստանդարտ-2.

Թիմը ստեղծում է կլաստերը մի քանի րոպեում: Երբ կլաստերը պատրաստ է, հրամանը թողարկում է նման բան сообщение.

2) Տրամադրել հավատարմագրերը հրամանի տող գործիքում կուբեկտլօգտագործել այն կլաստերը կառավարելու համար.

gcloud container clusters get-credentials istioready

3) Այժմ դուք կարող եք շփվել Kubernetes-ի հետ միջոցով կուբեկտլ. Օրինակ, հետևյալ հրամանը կարող է պարզել հանգույցների կարգավիճակը.

kubectl get nodes

Հրամանը ստեղծում է հանգույցների ցանկ.

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 հիմնական հասկացությունները

Դիագրամը ցույց է տալիս GKE հավելվածը.

Istio-ի համար դիմումի պատրաստում

Նախքան GKE-ում կոնտեյներներ տեղակայելը, սովորեք Kubernetes-ի հիմնական հասկացությունները: Ամենավերջում կան հղումներ, եթե ցանկանում եք ավելին իմանալ:

  • Հանգույցներ և կլաստերներ. GKE-ում հանգույցը վիրտուալ մեքենա է: Kubernetes-ի այլ հարթակներում հանգույցը կարող է լինել համակարգիչ կամ վիրտուալ մեքենա: Կլաստերը հանգույցների հավաքածու է, որը կարելի է համարել մեկ միավոր, որտեղ դուք տեղակայում եք կոնտեյներացված հավելված:
  • Ոտքեր. Kubernetes-ում բեռնարկղերը աշխատում են պատիճներով: Pod-ը Kubernetes-ում անբաժանելի միավոր է: Pod-ը պարունակում է մեկ կամ մի քանի տարա: Դուք տեղադրում եք սերվերի կոնտեյներներ և բեռնիչ առանձին պատյաններով: Երբ պատիճում կան մի քանի բեռնարկղեր (օրինակ՝ հավելվածի սերվեր և պրոքսի սերվեր), բեռնարկղերը կառավարվում են որպես մեկ միավոր և կիսում են pod ռեսուրսները:
  • Տեղակայումներ. Kubernetes-ում տեղակայումը օբյեկտ է, որը միանման պատիճների հավաքածու է: Deployment-ը գործարկում է բլոկների մի քանի կրկնօրինակներ, որոնք բաշխված են կլաստերային հանգույցներում: Տեղաբաշխումն ավտոմատ կերպով փոխարինում է ձախողված կամ անպատասխան թողնված բլոկները:
  • Kubernetes ծառայություն. GKE-ում հավելվածի կոդը գործարկելիս կապը միջև բեռնիչ и սերվեր. Երբ դուք ծառայություններ եք սկսել Cloud Shell վիրտուալ մեքենայի կամ աշխատասեղանի վրա, հարցումներ եք ուղարկել սերվեր ժամը տեղական ցանց ՝ 8080. GKE-ում տեղակայվելուց հետո pods-ը գործարկվում է հասանելի հանգույցների վրա: Լռելյայնորեն, դուք չեք վերահսկում, թե որ հանգույցի վրա է աշխատում պատիճը, այնպես որ դուք պատիճներ մշտական ​​IP հասցեներ չկան:
    համար IP հասցե ստանալու համար սերվեր, դուք պետք է սահմանեք ցանցի աբստրակցիա բլոկների վերևում: Ահա թե ինչ է դա Kubernetes ծառայություն. Kubernetes ծառայությունը ապահովում է կայուն վերջնակետ մի շարք pods-ի համար: Կան մի քանիսը ծառայությունների տեսակները. սերվեր օգտագործում LoadBalancer, որն ապահովում է արտաքին IP հասցե կապի համար սերվեր կլաստերի դրսից.
    Kubernetes-ն ունի նաև ներկառուցված DNS համակարգ, որը նշանակում է DNS անուններ (օրինակ. helloserver.default.cluster.local) ծառայություններ։ Դրա շնորհիվ կլաստերի ներսում գտնվող պատիճները շփվում են կլաստերի այլ պատիճների հետ մշտական ​​հասցեով: DNS անունը չի կարող օգտագործվել կլաստերից դուրս, օրինակ՝ Cloud Shell-ում կամ համակարգչում:

Կուբերնետեսը դրսևորվում է

Երբ դիմումը գործարկեցիք աղբյուրից, օգտագործեցիք հրամայական հրամանը python3

server.py

Իմպերատիվը ենթադրում է բայ՝ «արա սա»։

Kubernetes-ը օգտագործում է դեկլարատիվ մոդել. Սա նշանակում է, որ մենք Kubernetes-ին հստակ չենք ասում, թե ինչ անել, այլ ավելի շուտ նկարագրում ենք ցանկալի վիճակը: Օրինակ, Kubernetes-ը սկսում և դադարեցնում է pods, ըստ անհրաժեշտության, որպեսզի համակարգի իրական վիճակը համապատասխանի ցանկալի վիճակին:

Դուք նշում եք ցանկալի վիճակը մանիֆեստներում կամ ֆայլերում ՅԱՄԼ. YAML ֆայլը պարունակում է բնութագրեր մեկ կամ մի քանի Kubernetes օբյեկտների համար:

Օրինակը պարունակում է YAML ֆայլ սերվեր и բեռնիչ. Յուրաքանչյուր YAML ֆայլ սահմանում է տեղակայման օբյեկտի և 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

  • բարի ցույց է տալիս օբյեկտի տեսակը.
  • մետատվյալներ.անուն նշում է տեղակայման անվանումը.
  • Առաջին դաշտ մասնագիրն պարունակում է ցանկալի վիճակի նկարագրություն:
  • spec.replicas ցույց է տալիս պատիճների ցանկալի քանակը:
  • Բաժին spec.կաղապար սահմանում է պատիճ ձևանմուշ: Պատիճ ճշգրտման մեջ կա դաշտ պատկեր, որը նշում է պատկերի անունը, որը պետք է հանվի Container Registry-ից:

Ծառայությունը սահմանվում է հետևյալ կերպ.

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

  • LoadBalancerՀաճախորդները հարցումներ են ուղարկում բեռի հավասարակշռողի IP հասցեին, որն ունի մշտական ​​IP հասցե և հասանելի է կլաստերի դրսից:
  • targetPortԻնչպես հիշում եք, թիմը ԲԱՑԱՀԱՅՏՈՒՄ 8080 в dockerfile նավահանգիստներ չի տրամադրել. Դուք տրամադրում եք նավահանգիստը 8080որպեսզի կարողանաք կապ հաստատել կոնտեյների հետ սերվեր կլաստերից դուրս: Մեր դեպքում hellosvc.default.cluster.local:80 (կարճ անուն: hellosvc) համապատասխանում է նավահանգիստին 8080 Pod IP հասցեներ բարև սպասարկող.
  • նավահանգիստՍա այն նավահանգստի համարն է, որտեղ կլաստերի մյուս ծառայությունները հարցումներ կուղարկեն:

loadgen.yaml

Տեղակայման օբյեկտ դեպի loadgen.yaml նման լինել server.yaml. Տարբերությունն այն է, որ տեղակայման օբյեկտը պարունակում է բաժին նախանձ. Այն սահմանում է շրջակա միջավայրի փոփոխականները, որոնք անհրաժեշտ են բեռնիչ և որը դուք տեղադրել եք հավելվածը աղբյուրից գործարկելիս:

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

Ժամանակը բեռնիչ չի ընդունում մուտքային հարցումները, ոլորտի համար տիպ նշվեց ClusterIP. Այս տեսակը ապահովում է մշտական ​​IP հասցե, որը կարող են օգտագործել կլաստերի ծառայությունները, սակայն այս IP հասցեն չի ենթարկվում արտաքին հաճախորդներին:

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

Կոնտեյներների տեղակայում GKE-ում

1) Գնացեք այն գրացուցակը, որտեղ գտնվում է օրինակը սերվեր:

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

2) բացել server.yaml տեքստային խմբագրիչում:
3) փոխարինել անունը դաշտում պատկեր ձեր Docker պատկերի անվանմանը:

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

Փոխարինել PROJECT_ID ձեր GCP նախագծի ID-ին:
4) Պահպանել և փակել server.yaml.
5) Տեղադրեք YAML ֆայլը Kubernetes-ում.

kubectl apply -f server.yaml

Հաջողությամբ ավարտից հետո հրամանը արտադրում է հետևյալ կոդը.

deployment.apps/helloserver created
service/hellosvc created

6) Գնացեք այն գրացուցակը, որտեղ բեռնիչ:

cd ../loadgen

7) բացել loadgen.yaml տեքստային խմբագրիչում:
8) փոխարինել անունը դաշտում պատկեր ձեր Docker պատկերի անվանմանը:

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

Փոխարինել PROJECT_ID ձեր GCP նախագծի ID-ին:
9) Պահպանել և փակել loadgen.yaml, փակիր տեքստային խմբագրիչը։
10) Տեղադրեք YAML ֆայլը Kubernetes-ում.

kubectl apply -f loadgen.yaml

Հաջողությամբ ավարտից հետո հրամանը արտադրում է հետևյալ կոդը.

deployment.apps/loadgenerator created
service/loadgensvc created

11) Ստուգեք պատյանների կարգավիճակը.

kubectl get pods

Հրամանը ցույց է տալիս կարգավիճակը.

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

12) Քաղեք հավելվածի տեղեկամատյանները պատիճից բեռնիչ. Փոխարինել POD_ID նախորդ պատասխանից նույնացուցիչին:

kubectl logs loadgenerator-POD_ID

13) Ստացեք արտաքին IP հասցեներ hellosvc:

kubectl get service

Հրամանի պատասխանը նման է հետևյալին.

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) հարցում ուղարկել hellosvc: փոխարինել EXTERNAL_IP դեպի արտաքին IP հասցե hellosvc.

curl http://EXTERNAL_IP

Վերցնենք Իստիոն

Դուք արդեն ունեք հավելված, որը տեղադրված է GKE-ում: բեռնիչ կարող է օգտագործել Kubernetes DNS (hellosvc:80) հարցումներ ուղարկելու համար սերվերև դուք կարող եք հարցումներ ուղարկել սերվեր արտաքին IP հասցեով: Չնայած Kubernetes-ն ունի բազմաթիվ առանձնահատկություններ, ծառայությունների մասին որոշ տեղեկություններ բացակայում են.

  • Ինչպե՞ս են փոխազդում ծառայությունները: Ի՞նչ հարաբերություններ կան ծառայությունների միջև: Ինչպե՞ս է երթևեկությունը հոսում ծառայությունների միջև: Դուք տեղյա՞կ եք դա բեռնիչ հարցումներ է ուղարկում սերվեր, բայց պատկերացրեք, որ դուք ոչինչ չգիտեք հավելվածի մասին։ Այս հարցերին պատասխանելու համար եկեք նայենք GKE-ում գործարկվող պատյանների ցանկին:
  • Չափումներ. Ինչքան երկար սերվեր արձագանքում է մուտքային հարցմանը. Քանի՞ հարցում է ստացվում վայրկյանում սերվերի կողմից: Արդյո՞ք այն սխալի հաղորդագրություններ է տալիս:
  • Անվտանգության տեղեկատվություն. Երթևեկությունը միջև բեռնիչ и սերվեր պարզապես անցնում է HTTP կամ կողմից mTLS?

Իստիոն պատասխանում է այս բոլոր հարցերին։ Դա անելու համար Istio-ն տեղադրում է կողային մեքենայի վստահված անձ պատվիրակ յուրաքանչյուր պատիճում: Envoy վստահված անձը գաղտնալսում է բոլոր մուտքային և ելքային տրաֆիկը դեպի հավելվածների կոնտեյներներ: Դա նշանակում է որ սերվեր и բեռնիչ ստանալ միջոցով sidecar վստահված անձի Envoy, եւ ամբողջ երթեւեկությունը բեռնիչ к սերվեր անցնում է Envoy վստահված անձի միջոցով:

Envoy վստահված անձանց միջև կապերը կազմում են ծառայության ցանց: Ծառայության ցանցի ճարտարապետությունը ապահովում է վերահսկողության շերտ Kubernetes-ի վերևում:

Istio-ի համար դիմումի պատրաստում

Քանի որ Envoy վստահված անձինք աշխատում են իրենց բեռնարկղերում, Istio-ն կարող է տեղադրվել GKE կլաստերի վերևում՝ գրեթե առանց հավելվածի կոդի փոփոխության: Բայց դուք որոշակի աշխատանք եք կատարել, որպեսզի ձեր դիմումը պատրաստ լինի կառավարվելու Istio-ի կողմից.

  • Ծառայություններ բոլոր բեռնարկղերի համար: Դեպի տեղակայումներ սերվեր и բեռնիչ կապված Kubernetes ծառայության հետ։ Նույնիսկ բեռնիչ, որը մուտքային հարցումներ չի ստանում, կա ծառայություն։
  • Ծառայությունների նավահանգիստները պետք է ունենան անուններ: Չնայած սպասարկման նավահանգիստները կարող են անանուն մնալ GKE-ում, Istio-ն պահանջում է, որ դուք նշեք նավահանգստի անվանումը իր արձանագրության համաձայն։ YAML ֆայլում պորտը համար սերվեր անվանել HTTPքանի որ սերվերն օգտագործում է արձանագրությունը HTTP. Եթե ծառայություն օգտագործված gRPC, դու անուն կտաս նավահանգիստը grpc.
  • Տեղակայումները դրոշակավորված են: Հետևաբար, դուք կարող եք օգտագործել Istio-ի երթևեկության կառավարման գործառույթները, օրինակ՝ տրաֆիկի բաժանումը նույն ծառայության տարբերակների միջև:

Տեղադրում

Istio-ն տեղադրելու երկու եղանակ կա. Կարող է միացնել Istio-ն GKE ընդլայնման վրա կամ տեղադրել Istio-ի բաց կոդով տարբերակը կլաստերի վրա։ Istio-ի միջոցով GKE-ում դուք կարող եք հեշտությամբ կառավարել Istio-ի տեղադրումները և թարմացումները GKE կլաստերի կյանքի ցիկլի ընթացքում: Եթե ​​ցանկանում եք ունենալ Istio-ի վերջին տարբերակը կամ ավելի շատ վերահսկել ձեր Istio կառավարման վահանակի կազմաձևումը, տեղադրեք բաց կոդով տարբերակը՝ Istio-ի GKE ընդլայնման փոխարեն: Մոտեցման մասին որոշելու համար կարդացեք հոդվածը Ինձ պետք է Istio-ն GKE-ում:.

Ընտրեք տարբերակ, վերանայեք համապատասխան ուղեցույցը և հետևեք Istio-ն ձեր կլաստերի վրա տեղադրելու հրահանգներին: Եթե ​​ցանկանում եք օգտագործել Istio-ն ձեր նոր տեղակայված հավելվածի հետ, միացնել sidecar-ի իրականացումը անվանատարածքի համար անհոգություն.

Մաքրում

Որպեսզի այս ձեռնարկում օգտագործած ռեսուրսների համար ձեր Google Cloud Platform հաշվից գումար չգանձվի, Istio-ն տեղադրելուց և նմուշ հավելվածի հետ խաղալուց հետո ջնջեք բեռնարկղերի կլաստերը: Սա կհեռացնի բոլոր կլաստերի ռեսուրսները, ինչպիսիք են հաշվողական օրինակները, սկավառակները և ցանցային ռեսուրսները:

Ինչ հաջորդ?

Source: www.habr.com

Добавить комментарий