โปรโฮสต์ > บล็อก > การบริหาร > กำลังเตรียมใบสมัครสำหรับ Istio

กำลังเตรียมใบสมัครสำหรับ Istio

กำลังเตรียมใบสมัครสำหรับ Istio

Istio เป็นเครื่องมือที่สะดวกสำหรับการเชื่อมต่อ การรักษาความปลอดภัย และตรวจสอบแอปพลิเคชันแบบกระจาย Istio ใช้เทคโนโลยีที่หลากหลายเพื่อเรียกใช้และจัดการซอฟต์แวร์ในวงกว้าง รวมถึงคอนเทนเนอร์เพื่อจัดแพ็กเกจโค้ดแอปพลิเคชันและการพึ่งพาสำหรับการปรับใช้ และ Kubernetes เพื่อจัดการคอนเทนเนอร์เหล่านั้น ดังนั้น หากต้องการทำงานร่วมกับ Istio คุณต้องรู้ว่าแอปพลิเคชันที่มีบริการหลากหลายที่ใช้เทคโนโลยีเหล่านี้ทำงานอย่างไร ไม่มี อิสติโอ. หากคุณคุ้นเคยกับเครื่องมือและแนวคิดเหล่านี้อยู่แล้ว คุณสามารถข้ามบทช่วยสอนนี้และไปที่ส่วนนี้ได้โดยตรง การติดตั้ง Istio บน Google Kubernetes Engine (GKE) หรือติดตั้งส่วนขยาย อิสติโอบน GKE.

นี่คือคำแนะนำทีละขั้นตอนที่เราจะอธิบายกระบวนการทั้งหมดตั้งแต่ซอร์สโค้ดไปจนถึงคอนเทนเนอร์ GKE เพื่อให้คุณเข้าใจพื้นฐานเกี่ยวกับเทคโนโลยีเหล่านี้ผ่านตัวอย่าง คุณยังจะได้เห็นว่า Istio ใช้ประโยชน์จากพลังของเทคโนโลยีเหล่านี้ได้อย่างไร การดำเนินการนี้จะถือว่าคุณไม่รู้อะไรเลยเกี่ยวกับคอนเทนเนอร์, Kubernetes, Service Mesh หรือ 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 ด้วย Linux ที่ใช้ Debian หรือคอมพิวเตอร์ Linux หรือ macOS

ตัวเลือก A: การใช้ Cloud Shell

ประโยชน์ของการใช้ Cloud Shell:

  • สภาพแวดล้อมการพัฒนา Python 2 และ Python 3 (รวมถึง Virtualenv) ได้รับการกำหนดค่าอย่างสมบูรณ์
  • เครื่องมือบรรทัดคำสั่ง จีคลาวด์, นักเทียบท่า, คอมไพล์ и Kubectlซึ่งเราจะใช้ติดตั้งไว้แล้ว
  • คุณมีหลายอย่างให้เลือก โปรแกรมแก้ไขข้อความ:
    1. ตัวแก้ไขโค้ดซึ่งเปิดขึ้นพร้อมกับไอคอนแก้ไขที่ด้านบนของหน้าต่าง Cloud Shell
    2. Emacs, Vim หรือ Nano ซึ่งเปิดจากบรรทัดคำสั่งใน Cloud Shell

ใช้ คลาวด์เชลล์:

  1. ไปที่คอนโซล GCP
  2. คลิกที่ปุ่ม เปิดใช้งานคลาวด์เชลล์ (เปิดใช้งาน Cloud Shell) ที่ด้านบนของหน้าต่างคอนโซล GCP

กำลังเตรียมใบสมัครสำหรับ Istio

ในส่วนล่าง คอนโซล GCP เซสชัน Cloud Shell ที่มีบรรทัดคำสั่งจะเปิดขึ้นในหน้าต่างใหม่

กำลังเตรียมใบสมัครสำหรับ Istio

ตัวเลือก B: การใช้เครื่องมือบรรทัดคำสั่งในเครื่อง

หากคุณจะทำงานบนคอมพิวเตอร์ที่ใช้ Linux หรือ macOS คุณจะต้องกำหนดค่าและติดตั้งส่วนประกอบต่อไปนี้:

  1. ปรับแต่ง สภาพแวดล้อมการพัฒนา Python 3 และ Python 2.

  2. ติดตั้งคลาวด์ SDK ด้วยเครื่องมือบรรทัดคำสั่ง จีคลาวด์.

  3. ติดตั้ง Kubectl - เครื่องมือบรรทัดคำสั่งสำหรับการทำงานกับ Kubernetes.

    gcloud components install kubectl

  4. ติดตั้ง นักเทียบท่าชุมชนฉบับ (CE). คุณจะใช้เครื่องมือบรรทัดคำสั่ง นักเทียบท่าเพื่อสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชันตัวอย่าง

  5. ติดตั้งเครื่องมือ การควบคุมเวอร์ชัน Gitเพื่อรับแอปพลิเคชันตัวอย่างจาก GitHub

ดาวน์โหลดโค้ดตัวอย่าง

  1. ดาวน์โหลดซอร์สโค้ด สวัสดีเซิร์ฟเวอร์:

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

  2. ไปที่ไดเร็กทอรีโค้ดตัวอย่าง:

    cd istio-samples/sample-apps/helloserver

สำรวจแอปพลิเคชันด้วยบริการที่หลากหลาย

แอปพลิเคชันตัวอย่างเขียนด้วยภาษา Python และประกอบด้วยสององค์ประกอบที่ใช้งานร่วมกัน REST:

  • เซิร์ฟเวอร์: เซิร์ฟเวอร์ธรรมดาที่มีจุดสิ้นสุดเดียว รับ, /ซึ่งพิมพ์ "hello world" ไปที่คอนโซล
  • โหลด: สคริปต์ที่ส่งการรับส่งข้อมูลไปที่ เซิร์ฟเวอร์ด้วยจำนวนคำขอที่กำหนดได้ต่อวินาที

กำลังเตรียมใบสมัครสำหรับ 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:

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 คุณจะต้องจัดทำแพ็กเกจแอปพลิเคชันตัวอย่าง - เซิร์ฟเวอร์ и โหลด - ใน ภาชนะบรรจุ. คอนเทนเนอร์เป็นวิธีหนึ่งในการจัดแพ็กเกจแอปพลิเคชันเพื่อแยกแอปพลิเคชันออกจากสภาพแวดล้อม

หากต้องการบรรจุแอปพลิเคชันลงในคอนเทนเนอร์ คุณต้องมี ไฟล์นักเทียบท่า. ไฟล์นักเทียบท่า เป็นไฟล์ข้อความที่กำหนดคำสั่งสำหรับการสร้างซอร์สโค้ดของแอปพลิเคชันและการขึ้นต่อกันของแอปพลิเคชัน ภาพนักเทียบท่า เมื่อสร้างเสร็จแล้ว คุณจะอัปโหลดอิมเมจไปยังคอนเทนเนอร์รีจีสทรี เช่น Docker Hub หรือ การลงทะเบียนคอนเทนเนอร์.

ตัวอย่างก็มีแล้ว ไฟล์นักเทียบท่า สำหรับ เซิร์ฟเวอร์ и โหลด พร้อมคำสั่งที่จำเป็นทั้งหมดเพื่อรวบรวมภาพ ด้านล่าง - ไฟล์นักเทียบท่า สำหรับ เซิร์ฟเวอร์:

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

  • ทีม จาก python:3-slim เป็นฐาน บอกให้ Docker ใช้อันล่าสุด รูปภาพหลาม 3 เป็นฐาน
  • ทีม สำเนา. . คัดลอกไฟล์ต้นฉบับไปยังไดเร็กทอรีการทำงานปัจจุบัน (ในกรณีของเราเท่านั้น เซิร์ฟเวอร์.py) ไปยังระบบไฟล์ของคอนเทนเนอร์
  • จุดเริ่มต้น กำหนดคำสั่งที่ใช้ในการเริ่มคอนเทนเนอร์ ในกรณีของเรา คำสั่งนี้เกือบจะเหมือนกับคำสั่งที่คุณใช้เรียกใช้ เซิร์ฟเวอร์.py จากซอร์สโค้ด
  • ทีม เปิดเผย แสดงว่า เซิร์ฟเวอร์ รอข้อมูลผ่านพอร์ต 8080. ทีมนี้ไม่ใช่. ให้พอร์ต. นี่คือเอกสารบางประเภทที่จำเป็นในการเปิดพอร์ต 8080 เมื่อเริ่มคอนเทนเนอร์

กำลังเตรียมบรรจุแอปพลิเคชันของคุณ

1) ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ แทนที่ โครงการ_ID ไปยังรหัสโปรเจ็กต์ GCP ของคุณ

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

การใช้ค่า โครงการ_ID и GCR_REPO คุณแท็กอิมเมจ Docker เมื่อคุณสร้างและพุชไปที่ Container Registry ส่วนตัว

2) ตั้งค่าโปรเจ็กต์ GCP เริ่มต้นสำหรับเครื่องมือบรรทัดคำสั่ง จีคลาวด์.

gcloud config set project $PROJECT_ID

3) ตั้งค่าโซนเริ่มต้นสำหรับเครื่องมือบรรทัดคำสั่ง จีคลาวด์.

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. ประกอบภาพโดยใช้ ไฟล์นักเทียบท่า และตัวแปรสภาพแวดล้อมที่คุณกำหนดไว้ก่อนหน้านี้:

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

พารามิเตอร์ -t แสดงถึงแท็กนักเทียบท่า นี่คือชื่อของอิมเมจที่คุณใช้เมื่อปรับใช้คอนเทนเนอร์

  1. อัปโหลดรูปภาพไปยัง Container Registry: 
    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) อัปโหลดภาพไปยัง Container Registry:

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

ทีม จีคลาวด์ สร้างคลัสเตอร์ istioready ในโปรเจ็กต์ GCP และโซนเริ่มต้นที่คุณระบุ หากต้องการเรียกใช้ Istio เราขอแนะนำให้มีอย่างน้อย 4 โหนดและเครื่องเสมือน n1-มาตรฐาน-2.

ทีมงานสร้างคลัสเตอร์ภายในไม่กี่นาที เมื่อคลัสเตอร์พร้อม คำสั่งจะแสดงผลดังนี้ ข่าวสาร.

2) ระบุข้อมูลรับรองในเครื่องมือบรรทัดคำสั่ง Kubectlเพื่อใช้เพื่อจัดการคลัสเตอร์:

gcloud container clusters get-credentials istioready

3) ตอนนี้คุณสามารถสื่อสารกับ Kubernetes ผ่านทาง Kubectl. ตัวอย่างเช่น คำสั่งต่อไปนี้สามารถค้นหาสถานะของโหนด:

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 คอนเทนเนอร์ทำงานในพ็อด พ็อดใน Kubernetes เป็นหน่วยที่แบ่งแยกไม่ได้ พ็อดบรรจุหนึ่งหรือหลายภาชนะ คุณปรับใช้คอนเทนเนอร์เซิร์ฟเวอร์และ โหลด ในฝักที่แยกจากกัน เมื่อมีหลายคอนเทนเนอร์ในพ็อด (เช่น แอปพลิเคชันเซิร์ฟเวอร์และ พร็อกซีเซิร์ฟเวอร์) คอนเทนเนอร์ได้รับการจัดการเป็นเอนทิตีเดียวและแบ่งปันทรัพยากรพ็อด
  • การปรับใช้. ใน Kubernetes การปรับใช้คือออบเจ็กต์ที่เป็นกลุ่มของพ็อดที่เหมือนกัน การปรับใช้จะเปิดตัวพ็อดจำลองหลายตัวที่กระจายไปตามโหนดคลัสเตอร์ การปรับใช้จะแทนที่พ็อดที่ล้มเหลวหรือไม่ตอบสนองโดยอัตโนมัติ
  • บริการคูเบอร์เนเทส. เมื่อรันโค้ดแอปพลิเคชันใน GKE การเชื่อมต่อระหว่าง โหลด и เซิร์ฟเวอร์. เมื่อคุณเริ่มบริการบนเครื่องเสมือนหรือเดสก์ท็อป Cloud Shell คุณได้ส่งคำขอไปที่ เซิร์ฟเวอร์ ที่ localhost: 8080. เมื่อปรับใช้กับ GKE แล้ว พ็อดจะถูกดำเนินการบนโหนดที่มีอยู่ ตามค่าเริ่มต้น คุณไม่สามารถควบคุมได้ว่าโหนดใดที่พ็อดกำลังทำงานอยู่ ดังนั้นคุณก็เช่นกัน ฝัก ไม่มีที่อยู่ IP ถาวร
    เพื่อรับที่อยู่ IP สำหรับ เซิร์ฟเวอร์คุณต้องกำหนดสิ่งที่เป็นนามธรรมของเครือข่ายที่ด้านบนของพ็อด นั่นคือสิ่งที่มันเป็น บริการคูเบอร์เนเทส. บริการ Kubernetes มอบปลายทางแบบถาวรสำหรับชุดพ็อด มีไม่กี่อย่าง ประเภทของบริการ. เซิร์ฟเวอร์ ใช้ โหลดบาลานเซอร์ซึ่งให้ที่อยู่ IP ภายนอกเพื่อติดต่อ เซิร์ฟเวอร์ จากภายนอกคลัสเตอร์
    Kubernetes ยังมีระบบ DNS ในตัวซึ่งกำหนดชื่อ DNS (เช่น helloserver.default.cluster.local) บริการ ด้วยเหตุนี้ พ็อดภายในคลัสเตอร์จึงสื่อสารกับพ็อดอื่นๆ ในคลัสเตอร์ตามที่อยู่ถาวร ชื่อ DNS ไม่สามารถใช้ภายนอกคลัสเตอร์ เช่น ใน Cloud Shell หรือบนคอมพิวเตอร์

Kubernetes ปรากฏขึ้น

เมื่อคุณรันแอปพลิเคชันจากแหล่งที่มา แสดงว่าคุณใช้คำสั่งที่จำเป็น python3

เซิร์ฟเวอร์.py

ความจำเป็นหมายถึงคำกริยา: “ทำสิ่งนี้”

การใช้งาน Kubernetes แบบจำลองที่ประกาศ. ซึ่งหมายความว่าเราไม่ได้บอก Kubernetes อย่างชัดเจนว่าต้องทำอะไร แต่เป็นการอธิบายสถานะที่ต้องการ ตัวอย่างเช่น Kubernetes เริ่มต้นและหยุดพ็อดตามความจำเป็นเพื่อให้แน่ใจว่าสถานะที่แท้จริงของระบบตรงกับสถานะที่ต้องการ

คุณระบุสถานะที่ต้องการในรายการหรือไฟล์ ย.ม. ไฟล์ YAML มีข้อกำหนดสำหรับออบเจ็กต์ Kubernetes อย่างน้อย 1 รายการ

ตัวอย่างนี้มีไฟล์ YAML สำหรับ เซิร์ฟเวอร์ и โหลด. ไฟล์ YAML แต่ละไฟล์จะระบุสถานะที่ต้องการของออบเจ็กต์การทำให้ใช้งานได้และบริการ Kubernetes

เซิร์ฟเวอร์.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

  • ชนิด ระบุประเภทของวัตถุ
  • ข้อมูลเมตา.ชื่อ ระบุชื่อการปรับใช้
  • สนามแรก ข้อมูลจำเพาะ มีคำอธิบายสถานะที่ต้องการ
  • ข้อมูลจำเพาะ แบบจำลอง ระบุจำนวนพ็อดที่ต้องการ
  • ส่วน ข้อมูลจำเพาะเทมเพลต กำหนดเทมเพลตพ็อด มีช่องในข้อกำหนดพ็อด ภาพซึ่งระบุชื่อของอิมเมจที่ต้องแตกออกจาก Container Registry

บริการถูกกำหนดดังนี้:

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

  • โหลดบาลานเซอร์: ไคลเอนต์ส่งคำขอไปยังที่อยู่ IP ของโหลดบาลานเซอร์ซึ่งมีที่อยู่ IP ถาวรและสามารถเข้าถึงได้จากภายนอกคลัสเตอร์
  • เป้าหมายพอร์ต: เท่าที่จำได้นะทีมงาน เปิดเผย 8080 в ไฟล์นักเทียบท่า ไม่ได้จัดให้มีพอร์ต คุณให้พอร์ต 8080เพื่อให้คุณสามารถติดต่อคอนเทนเนอร์ได้ เซิร์ฟเวอร์ นอกคลัสเตอร์ ในกรณีของเรา hellosvc.default.cluster.local:80 (ชื่อสั้น: สวัสดี สวีซี) สอดคล้องกับพอร์ต 8080 ที่อยู่ IP ของพ็อด สวัสดีเซิร์ฟเวอร์.
  • พอร์ต: นี่คือหมายเลขพอร์ตที่บริการอื่นในคลัสเตอร์จะส่งคำขอ

โหลดเกน.yaml

วัตถุการปรับใช้ไปที่ โหลดเกน.yaml ดูเหมือน เซิร์ฟเวอร์.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

เวลา โหลด ไม่ยอมรับคำขอที่เข้ามาสำหรับสนาม ชนิด ระบุ คลัสเตอร์ไอพี. ประเภทนี้ให้ที่อยู่ 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) เปิด เซิร์ฟเวอร์.yaml ในโปรแกรมแก้ไขข้อความ
3) เปลี่ยนชื่อในช่อง ภาพ เป็นชื่อของอิมเมจ Docker ของคุณ

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

แทนที่ โครงการ_ID ไปยังรหัสโปรเจ็กต์ GCP ของคุณ
4) บันทึกและปิด เซิร์ฟเวอร์.yaml.
5) ปรับใช้ไฟล์ YAML กับ Kubernetes:

kubectl apply -f server.yaml

เมื่อดำเนินการเสร็จสิ้น คำสั่งจะสร้างโค้ดต่อไปนี้:

deployment.apps/helloserver created
service/hellosvc created

6) ไปที่ไดเร็กทอรีที่ โหลด:

cd ../loadgen

7) เปิด โหลดเกน.yaml ในโปรแกรมแก้ไขข้อความ
8) เปลี่ยนชื่อในช่อง ภาพ เป็นชื่อของอิมเมจ Docker ของคุณ

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

แทนที่ โครงการ_ID ไปยังรหัสโปรเจ็กต์ GCP ของคุณ
9) บันทึกและปิด โหลดเกน.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 ภายนอก สวัสดี สวีซี:

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) ส่งคำขอไปที่ สวัสดี สวีซี: แทนที่ ภายนอก_IP ไปยังที่อยู่ IP ภายนอก สวัสดี สวีซี.

curl http://EXTERNAL_IP

มาดูอิสติโอกันดีกว่า

คุณมีแอปพลิเคชันที่ใช้งานกับ GKE แล้ว โหลด สามารถใช้ Kubernetes DNS ได้ (สวัสดีsvc:80) เพื่อส่งคำขอไปที่ เซิร์ฟเวอร์และคุณสามารถส่งคำขอไปที่ เซิร์ฟเวอร์ โดยที่อยู่ IP ภายนอก แม้ว่า Kubernetes จะมีฟีเจอร์มากมาย แต่มีข้อมูลบางอย่างที่ขาดหายไปเกี่ยวกับบริการ:

  • บริการโต้ตอบกันอย่างไร? ความสัมพันธ์ระหว่างบริการคืออะไร? การรับส่งข้อมูลระหว่างบริการต่างๆ เป็นอย่างไร? คุณรู้ไหมว่า โหลด ส่งคำขอไปที่ เซิร์ฟเวอร์แต่ลองจินตนาการว่าคุณไม่รู้อะไรเกี่ยวกับแอปพลิเคชันนี้เลย เพื่อตอบคำถามเหล่านี้ มาดูรายการพ็อดที่ทำงานอยู่ใน GKE กัน
  • เมตริก. นานแค่ไหน เซิร์ฟเวอร์ ตอบสนองต่อคำขอที่เข้ามา? เซิร์ฟเวอร์รับคำขอกี่ครั้งต่อวินาที มันให้ข้อความแสดงข้อผิดพลาดหรือไม่?
  • ข้อมูลด้านความปลอดภัย. การจราจรระหว่าง โหลด и เซิร์ฟเวอร์ แค่ผ่านไป HTTP หรือโดย มทส?

Istio ตอบคำถามเหล่านี้ทั้งหมด เมื่อต้องการทำเช่นนี้ Istio จะวางพร็อกซีรถเทียมข้างรถจักรยานยนต์ ราชทูต ในแต่ละฝัก พร็อกซี Envoy สกัดกั้นการรับส่งข้อมูลขาเข้าและขาออกทั้งหมดไปยังคอนเทนเนอร์แอปพลิเคชัน มันหมายความว่าอย่างนั้น เซิร์ฟเวอร์ и โหลด รับผ่านทางทูตตัวแทนรถเทียมข้างรถจักรยานยนต์และการรับส่งข้อมูลทั้งหมดจาก โหลด к เซิร์ฟเวอร์ ผ่านพร็อกซีทูต

การเชื่อมต่อระหว่างพร็อกซีทูตในรูปแบบบริการ สถาปัตยกรรมตาข่ายบริการมอบการควบคุมอีกชั้นหนึ่งบน Kubernetes

กำลังเตรียมใบสมัครสำหรับ Istio

เนื่องจากพร็อกซี Envoy ทำงานในคอนเทนเนอร์ของตัวเอง คุณจึงติดตั้ง Istio ที่ด้านบนของคลัสเตอร์ GKE ได้โดยแทบไม่มีการเปลี่ยนแปลงใดๆ ในโค้ดแอปพลิเคชัน แต่คุณได้ทำงานบางอย่างเพื่อให้แอปพลิเคชันของคุณพร้อมที่จะจัดการโดย Istio:

  • บริการทุกตู้คอนเทนเนอร์ เพื่อการปรับใช้ เซิร์ฟเวอร์ и โหลด เชื่อมโยงกับบริการ Kubernetes สม่ำเสมอ โหลดที่ไม่รับคำขอเข้ามาก็มีบริการ
  • พอร์ตในบริการจะต้องมีชื่อ แม้ว่าพอร์ตบริการจะไม่มีการตั้งชื่อใน GKE ได้ แต่ Istio กำหนดให้คุณต้องระบุ ชื่อพอร์ต ตามระเบียบการของเขา ในไฟล์ YAML พอร์ตสำหรับ เซิร์ฟเวอร์ ที่เรียกว่า ที่ httpเนื่องจากเซิร์ฟเวอร์ใช้โปรโตคอล HTTP. ถ้า บริการ ใช้แล้ว ก.ร.ปคุณจะตั้งชื่อพอร์ต ก.พ.
  • การปรับใช้จะถูกตั้งค่าสถานะ ดังนั้น คุณจึงใช้ฟีเจอร์การจัดการการรับส่งข้อมูลของ Istio ได้ เช่น การแยกการรับส่งข้อมูลระหว่างเวอร์ชันของบริการเดียวกัน

กำลังติดตั้ง Istio

มีสองวิธีในการติดตั้ง Istio สามารถ เปิดใช้ Istio บนส่วนขยาย GKE หรือ ติดตั้ง Istio เวอร์ชันโอเพ่นซอร์ส บนคลัสเตอร์ เมื่อใช้ Istio บน GKE คุณจะจัดการการติดตั้งและการอัปเกรด Istio ได้อย่างง่ายดายตลอดวงจรการใช้งานคลัสเตอร์ GKE หากคุณต้องการ Istio เวอร์ชันล่าสุดหรือควบคุมการกำหนดค่าแผงควบคุม Istio ได้มากขึ้น ให้ติดตั้งเวอร์ชันโอเพนซอร์สแทนส่วนขยาย Istio บน GKE หากต้องการตัดสินใจเกี่ยวกับแนวทาง โปรดอ่านบทความ ฉันจำเป็นต้องมี Istio บน GKE หรือไม่.

เลือกตัวเลือก อ่านคำแนะนำที่เหมาะสม และทำตามคำแนะนำเพื่อติดตั้ง Istio บนคลัสเตอร์ หากคุณต้องการใช้ Istio กับแอปพลิเคชันที่เพิ่งปรับใช้ เปิดใช้งานการนำรถเทียมข้างรถจักรยานยนต์ไปใช้ สำหรับเนมสเปซ ผิดนัด.

Очистка

เพื่อหลีกเลี่ยงการถูกเรียกเก็บเงินจากบัญชี Google Cloud Platform สำหรับทรัพยากรที่คุณใช้ในบทแนะนำนี้ ให้ลบคลัสเตอร์คอนเทนเนอร์เมื่อคุณติดตั้ง Istio และเล่นกับแอปพลิเคชันตัวอย่างแล้ว การดำเนินการนี้จะลบทรัพยากรคลัสเตอร์ทั้งหมด เช่น อินสแตนซ์การประมวลผล ดิสก์ และทรัพยากรเครือข่าย

ทำอะไรต่อไป

ที่มา: will.com

เพิ่มความคิดเห็น