განაცხადის მომზადება ისტიოსთვის

Istio არის მოსახერხებელი ინსტრუმენტი განაწილებული აპლიკაციების დასაკავშირებლად, დასაცავად და მონიტორინგისთვის. Istio იყენებს მრავალფეროვან ტექნოლოგიას პროგრამული უზრუნველყოფის მასშტაბური გასაშვებად და სამართავად, მათ შორის კონტეინერებს აპლიკაციის კოდის შესაფუთად და დამოკიდებულებების დასაყენებლად, ხოლო Kubernetes ამ კონტეინერების მართვისთვის. ამიტომ, Istio-სთან მუშაობისთვის თქვენ უნდა იცოდეთ როგორ მუშაობს ამ ტექნოლოგიებზე დაფუძნებული მრავალი სერვისის მქონე აპლიკაცია გარეშე ისტიო. თუ ეს ხელსაწყოები და ცნებები უკვე ნაცნობია თქვენთვის, მოგერიდებათ გამოტოვოთ ეს სახელმძღვანელო და გადადით პირდაპირ განყოფილებაში Istio-ს ინსტალაცია Google Kubernetes Engine-ზე (GKE) ან გაფართოების დაყენება ისტიო GKE-ზე.

ეს არის ნაბიჯ-ნაბიჯ სახელმძღვანელო, სადაც ჩვენ განვიხილავთ მთელ პროცესს წყაროს კოდიდან GKE კონტეინერამდე, რათა მოგცეთ ამ ტექნოლოგიების ძირითადი გაგება მაგალითის საშუალებით. თქვენ ასევე ნახავთ, თუ როგორ იყენებს Istio ამ ტექნოლოგიების ძალას. ეს ვარაუდობს, რომ თქვენ არაფერი იცით კონტეინერების, კუბერნეტების, სერვისის ბადეების ან ისტიოს შესახებ.

ამოცანები

ამ გაკვეთილზე თქვენ შეასრულებთ შემდეგ დავალებებს:

1. მარტივი hello world აპლიკაციის სწავლა მრავალი სერვისით.
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 კომპიუტერით.

ვარიანტი A: Cloud Shell-ის გამოყენება

Cloud Shell-ის გამოყენების უპირატესობები:

• Python 2 და Python 3 განვითარების გარემო (მათ შორის ვირტუალური) სრულად არის კონფიგურირებული.
• ბრძანების ხაზის ინსტრუმენტები gcloud, docker, ტურიზმი и კუბექტლი, რომელსაც ჩვენ გამოვიყენებთ, უკვე დაინსტალირებულია.
• თქვენ გაქვთ რამდენიმე არჩევანი ტექსტის რედაქტორები:
  1. კოდის რედაქტორი, რომელიც იხსნება Cloud Shell-ის ფანჯრის ზედა რედაქტირების ხატულაზე.
  2. Emacs, Vim ან Nano, რომლებიც იხსნება Cloud Shell-ის ბრძანების ხაზიდან.

Გამოყენება ღრუბელი ჭურვი:

1. გადადით GCP კონსოლზე.
2. დააჭირეთ ღილაკს Cloud Shell-ის გააქტიურება (გააქტიურეთ Cloud Shell) GCP კონსოლის ფანჯრის ზედა ნაწილში.

ქვედა ნაწილში GCP კონსოლი Cloud Shell-ის სესია ბრძანების ხაზით გაიხსნება ახალ ფანჯარაში.

ვარიანტი B: ბრძანების ხაზის ინსტრუმენტების ადგილობრივად გამოყენება

თუ იმუშავებთ კომპიუტერზე, რომელიც მუშაობს Linux ან macOS-ზე, მოგიწევთ შემდეგი კომპონენტების კონფიგურაცია და ინსტალაცია:

1. მორგება Python 3 და Python 2 განვითარების გარემო.

2. დააინსტალირეთ Cloud SDK ბრძანების ხაზის ხელსაწყოთი gcloud.

3. უცნობია კუბექტლი - ბრძანების ხაზის ინსტრუმენტი მუშაობისთვის კუბერნეტები.

   gcloud components install kubectl

4. უცნობია Docker Community Edition (CE). თქვენ გამოიყენებთ ბრძანების ხაზის ხელსაწყოს dockerნიმუშის განაცხადისთვის კონტეინერის სურათების შესაქმნელად.

5. დააინსტალირეთ ინსტრუმენტი Git ვერსიის კონტროლიGitHub-დან აპლიკაციის ნიმუშის მისაღებად.

ჩამოტვირთეთ კოდის ნიმუში

1. ჩამოტვირთეთ საწყისი კოდი helloserver:

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

2. გადადით კოდის მაგალითის დირექტორიაში:

   cd istio-samples/sample-apps/helloserver

აპლიკაციის შესწავლა მრავალი სერვისით

განაცხადის ნიმუში დაწერილია პითონში და შედგება ორი კომპონენტისგან, რომლებიც ურთიერთქმედებენ გამოყენებით დასვენება:

• სერვერზე: მარტივი სერვერი ერთი ბოლო წერტილით მიიღეთ, /, რომელიც კონსოლზე იბეჭდება "hello world".
• ჩამტვირთავი: სკრიპტი, რომელიც აგზავნის ტრაფიკს სერვერზე, მოთხოვნის კონფიგურირებადი რაოდენობით წამში.

აპლიკაციის გაშვება საწყისი კოდიდან

ნიმუშის აპლიკაციის შესასწავლად, გაუშვით ის 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-სლიმი, როგორც ბაზა ეუბნება დოკერს გამოიყენოს უახლესი პითონის 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) დარწმუნდით, რომ კონტეინერის რეესტრის სერვისი ჩართულია 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 .

პარამეტრის -t წარმოადგენს Docker ტეგს. ეს არის სურათის სახელი, რომელსაც იყენებთ კონტეინერის განლაგებისას.

1. ატვირთეთ სურათი კონტეინერის რეესტრში:

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

loadgen-ის კონტეინერიზაცია

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-ის ვირტუალურ მანქანაზე ან კომპიუტერზე ბრძანებით დოკერის გაშვება. მაგრამ საწარმოო გარემოში, თქვენ გჭირდებათ კონტეინერების ცენტრალიზებული ორკესტრირების საშუალება. მაგალითად, გჭირდებათ სისტემა, რომელიც დარწმუნდება, რომ კონტეინერები ყოველთვის მუშაობენ, და თქვენ გჭირდებათ გზა, რომ გააფართოვოთ და გაზარდოთ კონტეინერის დამატებითი შემთხვევები, თუ ტრაფიკი გაიზრდება.

კონტეინერირებული აპლიკაციების გასაშვებად შეგიძლიათ გამოიყენოთ გ.კ.ე.. 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

კუბერნეტის ძირითადი ცნებები

დიაგრამა აჩვენებს აპლიკაციას GKE-ზე:

სანამ კონტეინერებს GKE-ში განათავსებთ, გაეცანით Kubernetes-ის ძირითად ცნებებს. დასასრულს არის ბმულები, თუ გსურთ გაიგოთ მეტი.

• კვანძები და კლასტერები. GKE-ში კვანძი არის ვირტუალური მანქანა. Kubernetes-ის სხვა პლატფორმებზე კვანძი შეიძლება იყოს კომპიუტერი ან ვირტუალური მანქანა. კლასტერი არის კვანძების კოლექცია, რომელიც შეიძლება ჩაითვალოს ერთ ერთეულად, სადაც განათავსებთ კონტეინერიზებულ აპლიკაციას.
• წიპწები. Kubernetes-ში კონტეინერები ხვრელების სახით მუშაობს. Pod კუბერნეტში არის განუყოფელი ერთეული. Pod იტევს ერთ ან მეტ კონტეინერს. თქვენ განათავსებთ სერვერის კონტეინერებს და ჩამტვირთავი ცალკეულ ბუდეებში. როდესაც პოდში რამდენიმე კონტეინერია (მაგალითად, აპლიკაციის სერვერი და პროქსი სერვერი), კონტეინერები იმართება როგორც ერთიანი და იზიარებენ პოდ რესურსებს.
• განლაგება. Kubernetes-ში, განლაგება არის ობიექტი, რომელიც წარმოადგენს იდენტური ჯირკვლების კრებულს. Deployment აწარმოებს კვანძების მრავალ ასლს, რომლებიც ნაწილდება კლასტერულ კვანძებში. განლაგება ავტომატურად ცვლის პოდებს, რომლებიც ვერ მოხერხდა ან არ რეაგირებს.
• Kubernetes სერვისი. GKE-ში აპლიკაციის კოდის გაშვებისას, კავშირი ჩამტვირთავი и სერვერზე. როდესაც დაიწყეთ სერვისები Cloud Shell-ის ვირტუალურ მანქანაზე ან დესკტოპზე, თქვენ გაგზავნეთ მოთხოვნები სერვერზე ზე ლოგოჰოსტი: 8080. GKE-ზე განლაგების შემდეგ, პოდები შესრულებულია ხელმისაწვდომ კვანძებზე. ნაგულისხმევად, თქვენ არ გაქვთ კონტროლი იმაზე, თუ რომელ კვანძზე მუშაობს pod, ასე რომ თქვენ ლობიოები არ არის მუდმივი IP მისამართები.
  IP მისამართის მისაღებად სერვერზე, თქვენ უნდა განსაზღვროთ ქსელის აბსტრაქცია პოდების თავზე. სწორედ ეს არის Kubernetes სერვისი. Kubernetes სერვისი უზრუნველყოფს მუდმივ საბოლოო წერტილს პოდების ნაკრებისთვის. Არის ცოტაოდენი მომსახურების სახეები. სერვერზე იყენებს LoadBalancer, რომელიც უზრუნველყოფს გარე IP მისამართს დასაკავშირებლად სერვერზე კლასტერის გარედან.
  Kubernetes-ს ასევე აქვს ჩაშენებული DNS სისტემა, რომელიც ანიჭებს DNS სახელებს (მაგალითად, helloserver.default.cluster.local) მომსახურება. ამის წყალობით, კლასტერში შემავალი პოდიები მუდმივ მისამართზე კომუნიკაციას უწევენ კლასტერში არსებულ სხვა პოდებს. DNS სახელის გამოყენება შეუძლებელია კლასტერის გარეთ, მაგალითად, Cloud Shell-ში ან კომპიუტერში.

Kubernetes ვლინდება

როდესაც აპლიკაციას წყაროდან გაუშვით, იყენებდით იმპერატიულ ბრძანებას python3

server.py

იმპერატივი გულისხმობს ზმნას: "გააკეთე ეს".

Kubernetes იყენებს დეკლარაციული მოდელი. ეს ნიშნავს, რომ ჩვენ არ ვეუბნებით კუბერნეტებს ზუსტად რა უნდა გააკეთოს, არამედ აღვწერთ სასურველ მდგომარეობას. მაგალითად, Kubernetes იწყებს და აჩერებს პოდებს საჭიროებისამებრ, რათა უზრუნველყოს, რომ სისტემის რეალური მდგომარეობა ემთხვევა სასურველ მდგომარეობას.

თქვენ მიუთითებთ სასურველ მდგომარეობას მანიფესტებში ან ფაილებში იამლი. 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

• სახის მიუთითებს ობიექტის ტიპზე.
• მეტამონაცემები.სახელი განსაზღვრავს განლაგების სახელს.
• პირველი ველი სპეც შეიცავს სასურველი მდგომარეობის აღწერას.
• სპეც.რეპლიკა მიუთითებს წიპწების სასურველ რაოდენობაზე.
• სექცია სპეც.თარგი განსაზღვრავს pod შაბლონს. პოდის სპეციფიკაციაში არის ველი სურათი, რომელიც განსაზღვრავს იმ სურათის სახელს, რომელიც უნდა იყოს ამოღებული კონტეინერის რეესტრიდან.

სერვისი განისაზღვრება შემდეგნაირად:

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

• LoadBalancer: კლიენტები აგზავნიან მოთხოვნებს დატვირთვის ბალანსერის IP მისამართზე, რომელსაც აქვს მუდმივი IP მისამართი და ხელმისაწვდომია კლასტერის გარედან.
• targetPort: როგორც გახსოვთ, გუნდი EXPOSE 8080 в dockerfile არ უზრუნველყო პორტები. თქვენ აწვდით პორტს 8080ასე რომ თქვენ შეგიძლიათ დაუკავშირდეთ კონტეინერს სერვერზე კლასტერის გარეთ. ჩვენს შემთხვევაში hellosvc.default.cluster.local:80 (მოკლე სახელი: hellosvc) შეესაბამება პორტს 8080 პოდ IP მისამართები helloserver.
• პორტი: ეს არის პორტის ნომერი, სადაც კლასტერში სხვა სერვისები გაგზავნიან მოთხოვნებს.

loadgen.yaml

განლაგების ობიექტი loadgen.yaml გამოიყურება როგორც server.yaml. განსხვავება ისაა, რომ განლაგების ობიექტი შეიცავს განყოფილებას env. ის განსაზღვრავს გარემოს ცვლადებს, რომლებიც საჭიროა ჩამტვირთავი და რომელიც დააინსტალირეთ აპლიკაციის წყაროდან გაშვებისას.

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 ათავსებს sidecar proxy-ს დესპანი თითოეულ პოდში. Envoy proxy წყვეტს ყველა შემომავალ და გამავალ ტრაფიკს განაცხადის კონტეინერებში. Ეს ნიშნავს, რომ სერვერზე и ჩამტვირთავი მიიღოს მეშვეობით sidecar proxy Envoy, და ყველა ტრაფიკი ჩამტვირთავი к სერვერზე გადის ელჩის მარიონეტული პირის მეშვეობით.

კავშირები Envoy მარიონეტებს შორის ქმნიან სერვისის ქსელს. სერვისის ქსელის არქიტექტურა უზრუნველყოფს კონტროლის ფენას Kubernetes-ის თავზე.

ვინაიდან Envoy proxies მუშაობს საკუთარ კონტეინერებში, Istio შეიძლება დაინსტალირდეს GKE კლასტერის თავზე, აპლიკაციის კოდში თითქმის ცვლილებების გარეშე. მაგრამ თქვენ გააკეთეთ გარკვეული სამუშაო იმისათვის, რომ თქვენი აპლიკაცია მომზადდეს Istio-ს მიერ სამართავად:

• მომსახურება ყველა კონტეინერისთვის. განლაგებისკენ სერვერზე и ჩამტვირთავი მიბმული კუბერნეტის სამსახურთან. თუნდაც ჩამტვირთავი, რომელიც არ იღებს შემოსულ მოთხოვნებს, არის სერვისი.
• სერვისებში პორტებს უნდა ჰქონდეთ სახელები. მიუხედავად იმისა, რომ სერვისის პორტები შეიძლება დარჩეს უსახელო GKE-ში, Istio მოითხოვს, რომ მიუთითოთ პორტის სახელი მისი პროტოკოლის შესაბამისად. YAML ფაილში პორტი for სერვერზე მოუწოდა httpრადგან სერვერი იყენებს პროტოკოლს HTTP. თუ მომსახურება გამოიყენება gRPCპორტს დაარქმევდით grpc.
• განლაგება მონიშნულია. ამიტომ, შეგიძლიათ გამოიყენოთ Istio-ს ტრაფიკის მართვის ფუნქციები, როგორიცაა ტრაფიკის გაყოფა იმავე სერვისის ვერსიებს შორის.

ინსტალაცია

Istio-ს დაყენების ორი გზა არსებობს. შეუძლია ჩართეთ Istio GKE გაფართოებაზე ან დააინსტალირეთ Istio-ს ღია კოდის ვერსია მტევანზე. Istio-ზე GKE-ზე შეგიძლიათ მარტივად მართოთ Istio-ს ინსტალაციები და განახლებები GKE კლასტერის სასიცოცხლო ციკლის განმავლობაში. თუ გსურთ Istio-ს უახლესი ვერსია ან მეტი კონტროლი თქვენს Istio მართვის პანელის კონფიგურაციაზე, დააინსტალირეთ ღია კოდის ვერსია Istio-ს GKE გაფართოების ნაცვლად. მიდგომის გადასაწყვეტად, წაიკითხეთ სტატია მჭირდება ისტიო GKE-ზე?.

აირჩიეთ ვარიანტი, გადახედეთ შესაბამის სახელმძღვანელოს და მიჰყევით ინსტრუქციებს, რომ დააინსტალიროთ Istio თქვენს კლასტერზე. თუ გსურთ გამოიყენოთ Istio თქვენს ახლად განლაგებულ აპლიკაციაში, გვერდითი კარის განხორციელების ჩართვა სახელთა სივრცისთვის პოსტი.

დასუფთავების

იმისათვის, რომ თავიდან აიცილოთ თანხა თქვენს Google Cloud Platform-ის ანგარიშზე ამ სახელმძღვანელოში გამოყენებული რესურსებისთვის, წაშალეთ კონტეინერების კლასტერი, როგორც კი დააინსტალირებთ Istio-ს და ითამაშებთ ნიმუშის აპლიკაციასთან. ეს წაშლის ყველა კასეტურ რესურსს, როგორიცაა გამოთვლითი შემთხვევები, დისკები და ქსელის რესურსები.

რა არის შემდეგი?

• შეისწავლეთ შემდეგი ტექნოლოგიები:

  1. docker
  2. კონტეინერები
  3. კონტეინერის რეესტრი
  4. კუბერნეტები
  5. გ.კ.ე.
  6. სერვისის ბადე
  7. ისტიო

• შეისწავლეთ შემდეგი ინსტრუმენტები:

  1. Cloud SDK
  2. გზამკვლევი gcloud
  3. კუბექტლი
  4. docker

• ისწავლეთ Kubernetes ცნებები:

  1. კლასტერები
  2. კვანძები
  3. წიპწები
  4. მომსახურება
  5. განლაგება

წყარო: www.habr.com