הכנת אפליקציה לאיסטיו

Istio הוא כלי נוח לחיבור, אבטחה וניטור אפליקציות מבוזרות. Istio משתמשת במגוון טכנולוגיות כדי להפעיל ולנהל תוכנות בקנה מידה, כולל קונטיינרים לאריזת קוד יישומים ותלות לפריסה, ו-Kubernetes לניהול קונטיינרים אלה. לכן, כדי לעבוד עם Istio עליך לדעת כיצד פועלת אפליקציה עם מספר שירותים המבוססים על טכנולוגיות אלו без איסטיו. אם הכלים והמושגים האלה כבר מוכרים לך, אתה מוזמן לדלג על הדרכה זו ולעבור ישר לסעיף התקנת Istio ב-Google Kubernetes Engine (GKE) או התקנת הרחבה Istio על 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 עם לינוקס מבוססת דביאן, או מחשב לינוקס או macOS.

אפשרות א': שימוש ב-Cloud Shell

יתרונות השימוש ב-Cloud Shell:

• סביבות פיתוח Python 2 ו- Python 3 (כולל וירטואלי) מוגדרים במלואם.
• כלים של שורת הפקודה gcloud, סַוָר, סילון и קובקטל, שבהם נשתמש כבר מותקנים.
• יש לך כמה לבחירה עורכי טקסט:
  1. עורך קוד, שנפתח עם סמל העריכה בחלק העליון של חלון ה-Cloud Shell.
  2. Emacs, Vim או Nano, הנפתחים משורת הפקודה ב-Cloud Shell.

להשתמש מעטפת ענן:

1. עבור אל מסוף GCP.
2. לחץ על הכפתור הפעל את ה-Cloud Shell (הפעל Cloud Shell) בחלק העליון של חלון מסוף GCP.

בחלק התחתון קונסולת GCP הפעלת Cloud Shell עם שורת פקודה תיפתח בחלון חדש.

אפשרות ב': שימוש בכלי שורת הפקודה באופן מקומי

אם אתה תעבוד על מחשב עם לינוקס או 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 ומורכב משני רכיבים המקיימים אינטראקציה באמצעות REST:

• שרת: שרת פשוט עם נקודת קצה אחת לקבל, /, שמדפיס "שלום עולם" לקונסולה.
• loadgen: סקריפט ששולח תנועה אל שרת, עם מספר ניתן להגדרה של בקשות בשנייה.

הפעלת אפליקציה מקוד המקור

כדי לחקור את היישום לדוגמה, הפעל אותו ב-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) מהספרייה שבה הורדת את הקוד לדוגמה, עבור לספרייה שמכילה loadgen:

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) הגדר דרישות עבור loadgen:

pip3 install -r requirements.txt

9) השקה loadgen:

python3 loadgen.py

כשאתה רץ loadgen מציג משהו כמו ההודעה הבאה:

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) לעצור loadgen и שרת, להיכנס Ctrl-c בכל חלון מסוף.
11) בחלון הטרמינל loadgen השבת את הסביבה הוירטואלית:

deactivate

אריזת אפליקציה במיכלים

כדי להפעיל את היישום ב-GKE, עליך לארוז את היישום לדוגמה - שרת и loadgen - פנימה מכולות. מיכל הוא דרך לארוז יישום כדי לבודד אותו מהסביבה שלו.

כדי לארוז יישום לתוך מיכל, אתה צריך דוקרפיל. דוקרפיל הוא קובץ טקסט המגדיר פקודות לבניית קוד המקור של היישום והתלות שלו תמונת דוקר. לאחר הבנייה, אתה מעלה את התמונה לרישום מיכל כגון Docker Hub או רישום מיכלים.

הדוגמה כבר קיימת דוקרפיל עבור שרת и loadgen עם כל הפקודות הדרושות לאיסוף תמונות. למטה - דוקרפיל עבור שרת:

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 שלך.

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. הרכיבו את התמונה באמצעות דוקרפיל ומשתני הסביבה שהגדרת קודם לכן:

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

פרמטר -t מייצג את תג Docker. זהו השם של התמונה שבה אתה משתמש בעת פריסת המיכל.

1. העלה את התמונה ל-Container Registry:

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

מיכליות של loadgen

1) עבור לספרייה שבה נמצאת הדוגמה loadgen:

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 או על מחשב עם הפקודה מעגן לרוץ. אבל בסביבת הפקה, אתה צריך דרך לתזמר מרכזי מכולות. לדוגמה, אתה זקוק למערכת שתוודא שמכולות פועלות תמיד, ואתה צריך דרך להגדיל ולהפוך מופעי קונטיינר נוספים אם התעבורה גדלה.

כדי להפעיל יישומים עם מיכל אתה יכול להשתמש G.K.E.. GKE היא פלטפורמת תזמור קונטיינרים המאגדת מכונות וירטואליות לאשכול. כל מכונה וירטואלית נקראת צומת. אשכולות GKE מבוססים על מערכת ניהול האשכולות Kubernetes בקוד פתוח. Kubernetes מספקת מנגנונים לאינטראקציה עם האשכול.

יצירת אשכול GKE:

1) צור אשכול:

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

קבוצה gcloud יוצר אשכול מוכן בפרויקט GCP ובאזור ברירת המחדל שציינת. כדי להפעיל את Istio, אנו ממליצים להחזיק לפחות 4 צמתים ומכונה וירטואלית n1-standard-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:

לפני שאתה פורס קונטיינרים ב-GKE, למד את מושגי המפתח של Kubernetes. יש קישורים ממש בסוף אם אתה רוצה ללמוד עוד.

• צמתים ואשכולות. ב-GKE, צומת הוא מכונה וירטואלית. בפלטפורמות אחרות של Kubernetes, צומת יכול להיות מחשב או מכונה וירטואלית. אשכול הוא אוסף של צמתים שיכולים להיחשב ליחידה אחת שבה אתה פורס יישום עם מיכל.
• תרמילים. ב-Kubernetes, מכולות פועלות בתרמילים. Pod in Kubernetes הוא יחידה בלתי ניתנת לחלוקה. פוד מכיל מיכל אחד או יותר. אתה פורס קונטיינרים של שרתים ו loadgen בתרמילים נפרדים. כאשר ישנם מספר מכולות בפוד (לדוגמה, שרת יישומים ו שרת פרוקסי), מכולות מנוהלות כישות אחת ומשתפות משאבי פוד.
• פריסות. ב-Kubernetes, פריסה היא אובייקט שהוא אוסף של תרמילים זהים. הפריסה משיקה העתקים מרובים של תרמילים המפוזרים על פני צמתי אשכול. הפריסה מחליפה אוטומטית פודים שנכשלו או שאינם מגיבים.
• שירות Kubernetes. בעת הפעלת קוד יישום ב-GKE, החיבור בין loadgen и שרת. כאשר התחלת שירותים במחשב וירטואלי או בשולחן העבודה של Cloud Shell, שלחת בקשות אל שרת по адресу 8080. לאחר הפריסה ל-GKE, הפודים מבוצעים על צמתים זמינים. כברירת מחדל, אין לך שליטה על איזה צומת הפוד פועל, אז אתה תרמילים אין כתובות IP קבועות.
  כדי לקבל כתובת IP עבור שרת, עליך להגדיר הפשטת רשת על גבי הפודים. זה מה שזה שירות Kubernetes. שירות Kubernetes מספק נקודת קצה מתמשכת עבור קבוצה של תרמילים. יש כמה סוגי שירותים. שרת использует LoadBalancer, המספק כתובת IP חיצונית ליצירת קשר שרת מחוץ לאשכול.
  ל-Kubernetes יש גם מערכת DNS מובנית שמקצה שמות DNS (לדוגמה, helloserver.default.cluster.local) שירותים. הודות לכך, פודים בתוך האשכול מתקשרים עם פודים אחרים באשכול בכתובת קבועה. לא ניתן להשתמש בשם ה-DNS מחוץ לאשכול, כגון ב-Cloud Shell או במחשב.

Kubernetes מניפסט

כשהרצת את היישום מהמקור, השתמשת בפקודה הציווית פיתון 3

server.py

ציווי מרמז על פועל: "עשה זאת."

Kubernetes משתמש מודל הצהרתי. זה אומר שאנחנו לא אומרים ל-Kubernetes בדיוק מה לעשות, אלא מתארים את המצב הרצוי. לדוגמה, Kubernetes מפעיל ומפסיק תרמילים לפי הצורך כדי לשמור על המצב בפועל של המערכת בהתאם למצב הרצוי.

אתה מציין את המצב הרצוי במניפסטים או בקבצים ימל. קובץ YAML מכיל מפרטים עבור אובייקט Kubernetes אחד או יותר.

הדוגמה מכילה קובץ YAML עבור שרת и loadgen. כל קובץ 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

• סוג מציין את סוג האובייקט.
• metadata.name מציין את שם הפריסה.
• שדה ראשון מפרט מכיל תיאור של המצב הרצוי.
• spec.replicas מציין את המספר הרצוי של תרמילים.
• סעיף spec.template מגדיר תבנית פוד. יש שדה במפרט הפוד תמונה, המציין את שם התמונה שיש לחלץ מ-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 в דוקרפיל לא סיפק יציאות. אתה מספק את הנמל 8080כדי שתוכל ליצור קשר עם המכולה שרת מחוץ לאשכול. במקרה שלנו hellosvc.default.cluster.local:80 (שם קצר: hellosvc) מתאים ליציאה 8080 כתובות IP של פוד שלום שרת.
• נמל: זהו מספר היציאה אליו ישלחו שירותים אחרים באשכול בקשות.

loadgen.yaml

אובייקט פריסה ל loadgen.yaml נראה כמו server.yaml. ההבדל הוא שאובייקט הפריסה מכיל קטע env. הוא מגדיר את משתני הסביבה הדרושים loadgen ואשר התקנת בעת הפעלת האפליקציה מהמקור.

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

זמן loadgen אינו מקבל בקשות נכנסות, לתחום סוג ציין אשכול IP. סוג זה מספק כתובת 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 שלך.
4) שמור וסגור server.yaml.
5) פרוס את קובץ YAML ל-Kubernetes:

kubectl apply -f server.yaml

לאחר סיום מוצלח, הפקודה מייצרת את הקוד הבא:

deployment.apps/helloserver created
service/hellosvc created

6) עבור אל המדריך שבו loadgen:

cd ../loadgen

7) פתח loadgen.yaml בעורך טקסט.
8) החלף את השם בשדה תמונה לשם תמונת Docker שלך.

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

החלף PROJECT_ID למזהה פרויקט GCP שלך.
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) חלץ יומני יישומים מהפוד loadgen. החלף 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. loadgen יכול להשתמש ב- Kubernetes DNS (hellosvc:80) לשלוח בקשות אליהם שרתואתה יכול לשלוח בקשות ל שרת לפי כתובת IP חיצונית. למרות של-Kubernetes יש תכונות רבות, חסר מידע על השירותים:

• כיצד מקיימים שירותים? מהם היחסים בין השירותים? איך זורמת התעבורה בין שירותים? האם אתה מודע לכך loadgen שולח בקשות ל שרת, אבל תאר לעצמך שאתה לא יודע כלום על היישום. כדי לענות על שאלות אלו, הבה נסתכל על רשימת הפודים הפועלים ב-GKE.
• מדדים. כמה זמן שרת עונה לבקשה נכנסת? כמה בקשות בשנייה מתקבלות על ידי השרת? האם זה נותן הודעות שגיאה?
• מידע אבטחה. תנועה בין loadgen и שרת פשוט עובר HTTP או על ידי mTLS?

איסטיו עונה על כל השאלות הללו. לשם כך, Istio מציב פרוקסי צדדי שַׁגְרִיר בכל תרמיל. ה-Proxy של Envoy מיירט את כל התעבורה הנכנסת והיוצאת אל מיכלי יישומים. זה אומר ש שרת и loadgen לקבל דרך Proxy Sidecar Envoy, וכל התעבורה ממנו loadgen к שרת עובר דרך פרוקסי ה-Envoy.

חיבורים בין נציגי השליח יוצרים רשת שירות. ארכיטקטורת רשת השירות מספקת שכבת שליטה על גבי Kubernetes.

מכיוון שפרוקסי Envoy פועלים בקונטיינרים משלהם, ניתן להתקין את Istio על גבי אשכול GKE כמעט ללא שינויים בקוד האפליקציה. אבל עשית קצת עבודה כדי להכין את היישום שלך לניהול על ידי Istio:

• שירותים לכל המכולות. לפריסות שרת и loadgen קשור לשירות Kubernetes. אֲפִילוּ loadgen, שאינו מקבל בקשות נכנסות, יש שירות.
• נמלים בשירותים חייבים להיות בעלי שמות. למרות שניתן להשאיר יציאות שירות ללא שם ב-GKE, Istio דורש ממך לציין שם הנמל בהתאם לפרוטוקול שלו. בקובץ YAML הפורט עבור שרת נקרא httpכי השרת משתמש בפרוטוקול HTTP... אם שרות בשימוש גר"פ, תיתן שם לנמל grpc.
• פריסות מסומנות. לכן, ניתן להשתמש בתכונות ניהול התעבורה של Istio, כמו פיצול תעבורה בין גרסאות של אותו שירות.

התקנת Istio

ישנן שתי דרכים להתקין את Istio. פחית אפשר Istio על סיומת GKE או התקן את גרסת הקוד הפתוח של Istio על האשכול. עם Istio ב-GKE, אתה יכול לנהל בקלות התקנות ושדרוגים של Istio לאורך כל מחזור החיים של אשכול GKE. אם אתה רוצה את הגרסה העדכנית ביותר של Istio או שליטה רבה יותר על תצורת לוח הבקרה של Istio, התקן את גרסת הקוד הפתוח במקום התוסף Istio on GKE. כדי להחליט על הגישה, קרא את המאמר האם אני צריך את Istio ב-GKE?.

בחר אפשרות, קרא את המדריך המתאים ובצע את ההוראות להתקנת Istio באשכול שלך. אם אתה רוצה להשתמש ב-Istio עם היישום החדש שלך שנפרס, לאפשר יישום צדדיות עבור מרחב שמות ברירת מחדל.

ניקוי

כדי להימנע מחיוב חשבון Google Cloud Platform שלך עבור המשאבים שבהם השתמשת במדריך זה, מחק את אשכול המכילים לאחר שהתקנת את Istio ושיחקת עם היישום לדוגמה. פעולה זו תסיר את כל משאבי האשכול, כגון מופעי מחשוב, דיסקים ומשאבי רשת.

מה הלאה?

• חקור את הטכנולוגיות הבאות:

  1. סַוָר
  2. מיכלים
  3. רישום מיכלים
  4. קוברנט
  5. G.K.E.
  6. רשת שירות
  7. Istio

• חקור את הכלים הבאים:

  1. SDK בענן
  2. מדריך ל gcloud
  3. קובקטל
  4. סַוָר

• למד מושגי Kubernetes:

  1. אשכולות
  2. צמתים
  3. תרמילים
  4. שירותים
  5. פְּרִיסָה

מקור: www.habr.com