ProHoster > Blog > Pentadbiran > Menyediakan permohonan untuk Istio

Menyediakan permohonan untuk Istio

Menyediakan permohonan untuk Istio

Istio ialah alat mudah untuk menyambung, mengamankan dan memantau aplikasi yang diedarkan. Istio menggunakan pelbagai teknologi untuk menjalankan dan mengurus perisian secara berskala, termasuk bekas untuk membungkus kod aplikasi dan kebergantungan untuk penggunaan, dan Kubernetes untuk mengurus bekas tersebut. Oleh itu, untuk bekerja dengan Istio anda mesti tahu cara aplikasi dengan pelbagai perkhidmatan berdasarkan teknologi ini berfungsi tanpa Istio. Jika alatan dan konsep ini sudah biasa kepada anda, jangan ragu untuk melangkau tutorial ini dan pergi terus ke bahagian tersebut Memasang Istio pada Enjin Kubernetes Google (GKE) atau memasang sambungan Istio pada GKE.

Ini ialah panduan langkah demi langkah di mana kami akan menjalankan keseluruhan proses daripada kod sumber ke bekas GKE untuk memberi anda pemahaman asas tentang teknologi ini melalui contoh. Anda juga akan melihat cara Istio memanfaatkan kuasa teknologi ini. Ini menganggap anda tidak tahu apa-apa tentang bekas, Kubernetes, jaringan perkhidmatan atau Istio.

tugas-tugas

Dalam tutorial ini, anda akan menyelesaikan tugasan berikut:

  1. Mempelajari aplikasi hello world yang mudah dengan pelbagai perkhidmatan.
  2. Jalankan aplikasi daripada kod sumber.
  3. Membungkus aplikasi dalam bekas.
  4. Mencipta gugusan Kubernetes.
  5. Menyebarkan bekas ke dalam kelompok.

Sebelum awak mula

Ikut arahan untuk mendayakan API Enjin Kubernetes:

  1. Pergi ke Halaman Enjin Kubernetes dalam konsol Google Cloud Platform.
  2. Buat atau pilih projek.
  3. Tunggu sehingga API dan perkhidmatan berkaitan didayakan. Ini mungkin mengambil masa beberapa minit.
  4. Pastikan pengebilan disediakan untuk projek Google Cloud Platform anda. Ketahui cara mendayakan pengebilan.

Dalam tutorial ini, anda boleh menggunakan Cloud Shell, yang menyediakan mesin maya g1-kecil dalam Enjin Pengiraan Google dengan Linux berasaskan Debian, atau komputer Linux atau macOS.

Pilihan A: Menggunakan Cloud Shell

Faedah menggunakan Cloud Shell:

  • Persekitaran pembangunan Python 2 dan Python 3 (termasuk virtualenv) dikonfigurasikan sepenuhnya.
  • Alat Baris Perintah gcloud, docker, pergi ΠΈ kubectl, yang akan kami gunakan sudah dipasang.
  • Anda mempunyai beberapa untuk dipilih penyunting teks:
    1. Editor kod, yang dibuka dengan ikon edit di bahagian atas tetingkap Cloud Shell.
    2. Emacs, Vim atau Nano, yang dibuka dari baris arahan dalam Cloud Shell.

Untuk menggunakan Cengkerang Awan:

  1. Pergi ke konsol GCP.
  2. akhbar Aktifkan Cloud Shell (Aktifkan Cloud Shell) di bahagian atas tetingkap konsol GCP.

Menyediakan permohonan untuk Istio

Di bahagian bawah Konsol GCP Sesi Cloud Shell dengan baris arahan akan dibuka dalam tetingkap baharu.

Menyediakan permohonan untuk Istio

Pilihan B: Menggunakan Alat Baris Perintah Secara Setempat

Jika anda akan bekerja pada komputer yang menjalankan Linux atau macOS, anda perlu mengkonfigurasi dan memasang komponen berikut:

  1. Sesuaikan Persekitaran pembangunan Python 3 dan Python 2.

  2. Pasang Cloud SDK dengan alat baris arahan gcloud.

  3. Tetapkan kubectl - alat baris arahan untuk bekerja dengan Kubernetes.

    gcloud components install kubectl

  4. Tetapkan Edisi Komuniti Docker (CE). Anda akan menggunakan alat baris arahan dockeruntuk mencipta imej bekas untuk aplikasi sampel.

  5. Pasang alat Kawalan versi Gituntuk mendapatkan contoh aplikasi daripada GitHub.

Muat turun kod sampel

  1. Muat turun kod sumber helloserver:

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

  2. Pergi ke direktori kod contoh:

    cd istio-samples/sample-apps/helloserver

Meneroka aplikasi dengan pelbagai perkhidmatan

Aplikasi sampel ditulis dalam Python dan terdiri daripada dua komponen yang berinteraksi menggunakan REST:

  • server: pelayan mudah dengan satu titik akhir DAPATKAN, /, yang mencetak "hello world" ke konsol.
  • loadgen: skrip yang menghantar trafik ke server, dengan bilangan permintaan yang boleh dikonfigurasikan sesaat.

Menyediakan permohonan untuk Istio

Menjalankan aplikasi daripada kod sumber

Untuk meneroka aplikasi sampel, jalankan ia dalam Cloud Shell atau pada komputer anda.
1) Dalam katalog istio-samples/sample-apps/helloserver lari server:

python3 server/server.py

Pada permulaan server berikut dipaparkan:

INFO:root:Starting server...

2) Buka tetingkap terminal lain untuk menghantar permintaan server. Jika anda menggunakan Cloud Shell, klik ikon tambah untuk membuka sesi lain.
3) Hantar permintaan kepada server:

curl http://localhost:8080

balasan pelayan:

Hello World!

4) Dari direktori tempat anda memuat turun kod sampel, pergi ke direktori yang mengandungi loadgen:

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

5) Cipta pembolehubah persekitaran berikut:

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

6) Pelancaran virtualenv:

virtualenv --python python3 env

7) Aktifkan persekitaran maya:

source env/bin/activate

8) Tetapkan keperluan untuk loadgen:

pip3 install -r requirements.txt

9) Pelancaran loadgen:

python3 loadgen.py

Pada permulaan loadgen memaparkan sesuatu seperti mesej berikut:

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

Dalam tetingkap terminal lain server mengeluarkan mesej berikut kepada konsol:

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

Dari perspektif rangkaian, keseluruhan aplikasi berjalan pada satu hos (komputer tempatan atau mesin maya Cloud Shell). Oleh itu anda boleh menggunakan localhostuntuk menghantar permintaan kepada server.
10) Untuk berhenti loadgen ΠΈ server, masuk Ctrl-c dalam setiap tetingkap terminal.
11) Dalam tetingkap terminal loadgen nyahaktifkan persekitaran maya:

deactivate

Membungkus aplikasi dalam bekas

Untuk menjalankan aplikasi pada GKE, anda perlu membungkus aplikasi contoh βˆ’ server ΠΈ loadgen - pada bekas. Bekas ialah cara untuk membungkus aplikasi untuk mengasingkannya daripada persekitarannya.

Untuk membungkus aplikasi ke dalam bekas, anda perlukan Dockerfile. Dockerfile ialah fail teks yang mentakrifkan arahan untuk membina kod sumber aplikasi dan kebergantungannya ke dalam Imej Docker. Setelah dibina, anda memuat naik imej ke pendaftaran kontena seperti Docker Hub atau Pendaftaran Kontena.

Contoh sudah ada Dockerfile untuk server ΠΈ loadgen dengan semua arahan yang diperlukan untuk mengumpul imej. Di bawah - Dockerfile untuk 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" ]

  • Pasukan DARI python:3-slim sebagai asas memberitahu Docker untuk menggunakan yang terkini Imej Python 3 sebagai asas.
  • Pasukan SALINAN. . menyalin fail sumber ke direktori kerja semasa (dalam kes kami sahaja pelayan.py) ke sistem fail bekas.
  • ENTRYPOINT mentakrifkan arahan yang digunakan untuk memulakan bekas. Dalam kes kami, arahan ini hampir sama seperti yang anda gunakan untuk menjalankan pelayan.py daripada kod sumber.
  • Pasukan DEDAHKAN menunjukkan bahawa server menunggu data melalui port 8080. Pasukan ini tidak menyediakan pelabuhan. Ini adalah sejenis dokumentasi yang diperlukan untuk membuka port 8080 semasa memulakan bekas.

Bersedia untuk menyimpan permohonan anda

1) Tetapkan pembolehubah persekitaran berikut. Gantikan PROJECT_ID ke ID projek GCP anda.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Menggunakan nilai PROJECT_ID ΠΈ GCR_REPO anda menandakan imej Docker apabila anda membinanya dan menolaknya ke Pendaftaran Kontena peribadi.

2) Tetapkan projek GCP lalai untuk alat baris arahan gcloud.

gcloud config set project $PROJECT_ID

3) Tetapkan zon lalai untuk alat baris arahan gcloud.

gcloud config set compute/zone us-central1-b

4) Pastikan perkhidmatan Pendaftaran Kontena didayakan dalam projek GCP.

gcloud services enable containerregistry.googleapis.com

Pelayan kontena

  1. Pergi ke direktori tempat contoh berada server:

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

  2. Pasang imej menggunakan Dockerfile dan pembolehubah persekitaran yang anda tentukan sebelum ini:

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

Parameter -t mewakili tag Docker. Ini ialah nama imej yang anda gunakan semasa menggunakan bekas.

  1. Muat naik imej ke Pendaftaran Kontena: 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Pengkontenaan loadgen

1) Pergi ke direktori tempat contoh berada loadgen:

cd ../loadgen

2) Kumpulkan imej:

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

3) Muat naik imej ke Pendaftaran Kontena:

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

Lihat senarai imej

Semak senarai imej dalam repositori dan sahkan bahawa imej telah dimuat naik:

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

Perintah memaparkan nama imej yang baru dimuat naik:

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

Mencipta gugusan GKE.

Bekas ini boleh dijalankan pada mesin maya Cloud Shell atau pada komputer dengan arahan berlari docker. Tetapi dalam persekitaran pengeluaran, anda memerlukan cara untuk mengatur kontena secara berpusat. Sebagai contoh, anda memerlukan sistem yang memastikan bekas sentiasa berjalan dan anda memerlukan cara untuk meningkatkan dan menaikkan contoh kontena tambahan jika trafik meningkat.

Untuk menjalankan aplikasi kontena yang boleh anda gunakan GKE. GKE ialah platform orkestrasi kontena yang mengagregatkan mesin maya ke dalam kelompok. Setiap mesin maya dipanggil nod. Kluster GKE adalah berdasarkan sistem pengurusan kluster Kubernetes sumber terbuka. Kubernetes menyediakan mekanisme untuk berinteraksi dengan kluster.

Mencipta gugusan GKE:

1) Buat kluster:

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

Pasukan gcloud mencipta gugusan istioready dalam projek GCP dan zon lalai yang anda tentukan. Untuk menjalankan Istio, kami mengesyorkan anda mempunyai sekurang-kurangnya 4 nod dan mesin maya n1-standard-2.

Pasukan mencipta kluster dalam beberapa minit. Apabila kluster sudah sedia, arahan akan mengeluarkan sesuatu seperti ini mesej itu.

2) Sediakan kelayakan dalam alat baris arahan kubectluntuk menggunakannya untuk mengurus kluster:

gcloud container clusters get-credentials istioready

3) Kini anda boleh berkomunikasi dengan Kubernetes melalui kubectl. Sebagai contoh, arahan berikut boleh mengetahui status nod:

kubectl get nodes

Perintah menghasilkan senarai nod:

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

Konsep Utama Kubernetes

Rajah menunjukkan aplikasi pada GKE:

Menyediakan permohonan untuk Istio

Sebelum anda menggunakan bekas dalam GKE, pelajari konsep utama Kubernetes. Terdapat pautan di hujung sekali jika anda ingin mengetahui lebih lanjut.

  • Nod dan kelompok. Dalam GKE, nod ialah mesin maya. Pada platform Kubernetes lain, nod boleh menjadi komputer atau mesin maya. Kluster ialah koleksi nod yang boleh dianggap sebagai satu unit tempat anda menggunakan aplikasi kontena.
  • Polong. Dalam Kubernetes, bekas dijalankan dalam pod. Pod dalam Kubernetes ialah unit yang tidak boleh dibahagikan. Pod memuatkan satu atau lebih bekas. Anda menggunakan bekas pelayan dan loadgen dalam pod berasingan. Apabila terdapat beberapa bekas dalam pod (contohnya, pelayan aplikasi dan pelayan proksi), bekas diuruskan sebagai satu entiti dan berkongsi sumber pod.
  • Kerahan. Dalam Kubernetes, penempatan ialah objek yang merupakan koleksi pod yang sama. Alokasi melancarkan berbilang replika pod yang diedarkan merentasi nod kelompok. Alokasi secara automatik menggantikan pod yang gagal atau tidak bertindak balas.
  • perkhidmatan Kubernetes. Apabila menjalankan kod aplikasi dalam GKE, sambungan antara loadgen ΠΈ server. Apabila anda memulakan perkhidmatan pada mesin maya atau desktop Cloud Shell, anda menghantar permintaan kepada server ΠΏΠΎ адрСсу localhost: 8080. Setelah digunakan ke GKE, pod dilaksanakan pada nod yang tersedia. Secara lalai, anda tidak mempunyai kawalan ke atas nod yang pod sedang dijalankan, jadi anda buah polong tiada alamat IP kekal.
    Untuk mendapatkan alamat IP untuk server, anda perlu menentukan abstraksi rangkaian di atas pod. Itulah yang berlaku perkhidmatan Kubernetes. Perkhidmatan Kubernetes menyediakan titik akhir yang berterusan untuk satu set pod. Terdapat beberapa jenis perkhidmatan. server kegunaan LoadBalancer, yang menyediakan alamat IP luaran untuk dihubungi server dari luar kluster.
    Kubernetes juga mempunyai sistem DNS terbina dalam yang memberikan nama DNS (contohnya, helloserver.default.cluster.local) perkhidmatan. Terima kasih kepada ini, pod dalam kluster berkomunikasi dengan pod lain dalam kluster pada alamat tetap. Nama DNS tidak boleh digunakan di luar kluster, seperti dalam Cloud Shell atau pada komputer.

Kubernetes menjelma

Apabila anda menjalankan aplikasi dari sumber, anda menggunakan perintah penting python3

pelayan.py

Imperatif membayangkan kata kerja: "buat ini."

Kubernetes menggunakan model deklaratif. Ini bermakna kami tidak memberitahu Kubernetes dengan tepat apa yang perlu dilakukan, sebaliknya menerangkan keadaan yang diingini. Contohnya, Kubernetes memulakan dan menghentikan pod seperti yang diperlukan untuk memastikan keadaan sebenar sistem konsisten dengan keadaan yang dikehendaki.

Anda menunjukkan keadaan yang dikehendaki dalam manifes atau fail YAML. Fail YAML mengandungi spesifikasi untuk satu atau lebih objek Kubernetes.

Contoh mengandungi fail YAML untuk server ΠΈ loadgen. Setiap fail YAML menentukan keadaan yang dikehendaki bagi objek penempatan dan perkhidmatan Kubernetes.

pelayan.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

  • jenis menunjukkan jenis objek.
  • metadata.nama menentukan nama penempatan.
  • Medan pertama spec mengandungi perihalan keadaan yang dikehendaki.
  • spec.replika menunjukkan bilangan pod yang dikehendaki.
  • Seksyen spec.template mentakrifkan templat pod. Terdapat medan dalam spesifikasi pod gambar, yang menentukan nama imej yang perlu diekstrak daripada Pendaftaran Kontena.

Perkhidmatan ditakrifkan seperti berikut:

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

  • LoadBalancer: Pelanggan menghantar permintaan ke alamat IP pengimbang beban, yang mempunyai alamat IP berterusan dan boleh diakses dari luar kluster.
  • targetPort: seperti yang anda ingat, pasukan DEDAH 8080 Π² Dockerfile tidak menyediakan pelabuhan. Anda menyediakan pelabuhan 8080supaya anda boleh menghubungi bekas server di luar kluster. Dalam kes kita hellosvc.default.cluster.local:80 (nama pendek: hellosvc) sepadan dengan pelabuhan 8080 Alamat IP pod helloserver.
  • pelabuhan: Ini ialah nombor port di mana perkhidmatan lain dalam kluster akan menghantar permintaan.

loadgen.yaml

Kerahan objek kepada loadgen.yaml seperti pelayan.yaml. Perbezaannya ialah objek penempatan mengandungi bahagian env. Ia mentakrifkan pembolehubah persekitaran yang diperlukan loadgen dan yang anda pasang semasa menjalankan aplikasi daripada sumber.

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

masa loadgen tidak menerima permintaan masuk, untuk medan jenis ditunjukkan KlusterIP. Jenis ini menyediakan alamat IP berterusan yang boleh digunakan oleh perkhidmatan dalam kluster, tetapi alamat IP ini tidak terdedah kepada pelanggan luaran.

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

Meletakkan Bekas dalam GKE

1) Pergi ke direktori tempat contoh berada server:

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

2) Terbuka pelayan.yaml dalam penyunting teks.
3) Gantikan nama dalam medan gambar kepada nama imej Docker anda.

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

Gantikan PROJECT_ID ke ID projek GCP anda.
4) Simpan dan tutup pelayan.yaml.
5) Sebarkan fail YAML ke Kubernetes:

kubectl apply -f server.yaml

Setelah berjaya diselesaikan, arahan menghasilkan kod berikut:

deployment.apps/helloserver created
service/hellosvc created

6) Pergi ke direktori di mana loadgen:

cd ../loadgen

7) Terbuka loadgen.yaml dalam penyunting teks.
8) Gantikan nama dalam medan gambar kepada nama imej Docker anda.

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

Gantikan PROJECT_ID ke ID projek GCP anda.
9) Simpan dan tutup loadgen.yaml, tutup penyunting teks.
10) Sebarkan fail YAML ke Kubernetes:

kubectl apply -f loadgen.yaml

Setelah berjaya diselesaikan, arahan menghasilkan kod berikut:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Semak status pod:

kubectl get pods

Perintah menunjukkan status:

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

12) Ekstrak log aplikasi daripada pod loadgen. Gantikan POD_ID kepada pengecam daripada jawapan sebelumnya.

kubectl logs loadgenerator-POD_ID

13) Dapatkan alamat IP luaran hellosvc:

kubectl get service

Respons arahan kelihatan seperti ini:

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) Hantar permintaan kepada hellosvc: ganti EXTERNAL_IP kepada alamat IP luaran hellosvc.

curl http://EXTERNAL_IP

Mari kita lawan Istio

Anda sudah mempunyai aplikasi yang digunakan untuk GKE. loadgen boleh menggunakan DNS Kubernetes (hellosvc:80) untuk menghantar permintaan kepada serverdan anda boleh menghantar permintaan ke server dengan alamat IP luaran. Walaupun Kubernetes mempunyai banyak ciri, terdapat beberapa maklumat yang hilang tentang perkhidmatan:

  • Bagaimanakah perkhidmatan berinteraksi? Apakah hubungan antara perkhidmatan? Bagaimanakah aliran trafik antara perkhidmatan? Adakah anda sedar bahawa loadgen menghantar permintaan kepada server, tetapi bayangkan anda tidak tahu apa-apa tentang aplikasi itu. Untuk menjawab soalan ini, mari lihat senarai pod yang sedang berjalan dalam GKE.
  • Metrik. Berapa lama server membalas permintaan masuk? Berapa banyak permintaan sesaat yang diterima oleh pelayan? Adakah ia memberikan mesej ralat?
  • Maklumat Keselamatan. Trafik antara loadgen ΠΈ server hanya melalui HTTP atau oleh mTLS?

Istio menjawab semua soalan ini. Untuk melakukan ini, Istio meletakkan proksi kereta sampingan duta dalam setiap pod. Proksi Utusan memintas semua trafik masuk dan keluar ke bekas aplikasi. Maksudnya begitu server ΠΈ loadgen terima melalui Duta proksi sidecar, dan semua trafik dari loadgen ΠΊ server melalui proksi Utusan.

Sambungan antara proksi Utusan membentuk jaringan perkhidmatan. Seni bina mesh perkhidmatan menyediakan lapisan kawalan di atas Kubernetes.

Menyediakan permohonan untuk Istio

Memandangkan proksi Envoy dijalankan dalam bekas mereka sendiri, Istio boleh dipasang di atas gugusan GKE tanpa perubahan pada kod aplikasi. Tetapi anda telah melakukan beberapa kerja untuk menyediakan permohonan anda untuk diuruskan oleh Istio:

  • Perkhidmatan untuk semua kontena. Kepada penempatan server ΠΈ loadgen terikat dengan perkhidmatan Kubernetes. Malah loadgen, yang tidak menerima permintaan masuk, terdapat perkhidmatan.
  • Pelabuhan dalam perkhidmatan mesti mempunyai nama. Walaupun port perkhidmatan boleh dibiarkan tanpa nama dalam GKE, Istio memerlukan anda untuk menentukan nama pelabuhan sesuai dengan protokolnya. Dalam fail YAML port untuk server dipanggil httpkerana pelayan menggunakan protokol HTTP. Jika perkhidmatan digunakan gRPC, anda akan menamakan pelabuhan itu grpc.
  • Kerahan dibenderakan. Oleh itu, anda boleh menggunakan ciri pengurusan trafik Istio, seperti membahagikan trafik antara versi perkhidmatan yang sama.

Memasang Istio

Terdapat dua cara untuk memasang Istio. boleh dayakan Istio pada sambungan GKE atau pasang versi sumber terbuka Istio pada kluster. Dengan Istio pada GKE, anda boleh mengurus pemasangan dan peningkatan Istio dengan mudah sepanjang kitaran hayat kelompok GKE. Jika anda mahukan versi terkini Istio atau lebih kawalan ke atas konfigurasi panel kawalan Istio anda, pasang versi sumber terbuka dan bukannya sambungan Istio pada GKE. Untuk memutuskan pendekatan, baca artikel Adakah saya memerlukan Istio pada GKE?.

Pilih pilihan, semak panduan yang sesuai dan ikut arahan untuk memasang Istio pada kluster anda. Jika anda ingin menggunakan Istio dengan aplikasi anda yang baru digunakan, membolehkan pelaksanaan sidecar untuk ruang nama lalai.

Pembersihan

Untuk mengelak daripada dicaj ke akaun Google Cloud Platform anda untuk sumber yang anda gunakan dalam tutorial ini, padamkan gugusan kontena setelah anda memasang Istio dan bermain dengan aplikasi sampel. Ini akan mengalih keluar semua sumber kluster, seperti contoh pengiraan, cakera dan sumber rangkaian.

Apa seterusnya?

Sumber: www.habr.com

Tambah komen