הגדרת תמיכה בכמה רשתות לקבוצות Pod

Autopilot Standard

אתם יכולים להגדיר אשכולות של Google Kubernetes Engine (GKE) עם תמיכה בכמה רשתות לפודים, כדי לחבר פודים וצמתים לכמה רשתות נפרדות בו-זמנית. היכולת הזו עוזרת לכם לעמוד בדרישות רשת מיוחדות, כמו בידוד תנועה או שיפור התפוקה של עומסי עבודה של מחשוב עתיר ביצועים (HPC) או וירטואליזציה של פונקציות רשת (NFV).

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

מידע נוסף זמין במאמר מידע על תמיכה במספר רשתות לפודים.

דרישות ומגבלות

אלה הדרישות והמגבלות של תמיכה בכמה רשתות לפודים:

דרישות

• התמיכה בכמה רשתות לפודים משתמשת באותם מפרטים ברמת ה-VM כמו multi-NIC ל-Compute Engine.
• כדי להשתמש בתמיכה בכמה רשתות לפודים, צריך להשתמש ב-GKE Dataplane V2.
• במערכת הפעלה שמותאמת לקונטיינרים יש תמיכה בכמה רשתות לפודים. התמיכה ב-Ubuntu זמינה בצמתים שבהם פועלת גרסה 1.32.3-gke.1785000 ומעלה של GKE.

מגבלות כלליות

• התמיכה של Pods ברשתות מרובות לא פועלת באשכולות שמופעלת בהם רשת עם מחסנית כפולה. באשכולות IPv6 עם מחסנית אחת (גרסת טרום-השקה (Preview)), יש תמיכה ב-Pods עם כמה רשתות ברשתות IPv4 משניות בלבד (רשתות VPC בשכבה 3). אין תמיכה ברשתות Pods משניות עם IPv6.
• אפשר להשתמש ב-Multi-Pod CIDR רק ברשת ברירת המחדל של Pod.
• לרשתות Pod באשכול GKE יחיד לא יכולים להיות טווחי CIDR חופפים.
• כשמפעילים תמיכה בכמה רשתות ל-Pods, אי אפשר להוסיף או להסיר ממשקי רשת של צמתים או רשתות Pod אחרי שיוצרים מאגר צמתים. כדי לשנות את ההגדרות האלה, צריך ליצור מחדש את מאגר הצמתים.
• כברירת מחדל, אין גישה לאינטרנט בממשקים נוספים של רשתות Pod בתוך ה-Pod. עם זאת, אפשר להפעיל אותו ידנית באמצעות Cloud NAT.
• אי אפשר לשנות דרך ה-API את שער ברירת המחדל בתוך Pod עם כמה ממשקים. שער ברירת המחדל חייב להיות מחובר לרשת ברירת המחדל של Pod.
• רשת Pod שמוגדרת כברירת מחדל תמיד צריכה להיכלל ב-Pods, גם אם יוצרים רשתות Pod או ממשקים נוספים.
• אי אפשר להגדיר את התכונה "רשתות מרובות" כשהתכונה "Hubble מנוהל" מוגדרת.
• בפריסות של VPC משותף, כל ממשקי הרשת (NIC) שמחוברים לצמתים צריכים להיות שייכים לאותו פרויקט כמו הפרויקט המארח.
• השם של אובייקטי רשת מסוג מכשיר לא יכול להכיל יותר מ-41 תווים. הנתיב המלא של כל שקע דומיין של UNIX מורכב, כולל שם הרשת המתאים. ב-Linux יש מגבלה על אורך הנתיב של שקע (פחות מ-107 בייטים). אחרי שמביאים בחשבון את הספרייה, את הקידומת של שם הקובץ ואת הסיומת .sock, שם הרשת מוגבל ל-41 תווים לכל היותר.
• אי אפשר לשנות אובייקטים מסוג Network ו-GKENetworkParamSet. כדי לעדכן את האובייקטים האלה, צריך למחוק וליצור אותם מחדש.

מגבלות על מכשירים ועל ערכת פיתוח למישור הנתונים (DPDK)

• כרטיס רשת של מכונה וירטואלית שמועבר ל-Pod ככרטיס רשת מסוג Device לא זמין ל-Pods אחרים באותו צומת.
• כדי לגשת למכשירי VFIO, צריך להפעיל פודים שמשתמשים במצב DPDK במצב הרשאות.
• במצב אוטומטי אין תמיכה ב-DPDK.
• במצב DPDK, המכשיר נחשב למשאב של צומת והוא מחובר רק לקונטיינר הראשון (לא init) ב-Pod. אם רוצים לפצל כמה התקני DPDK בין קונטיינרים באותו Pod, צריך להריץ את הקונטיינרים האלה ב-Pods נפרדים.
• בצומתי Ubuntu, רשתות DPDK-VFIO נתמכות רק ב-GKE מגרסה 1.33.1-gke.1959000 ואילך.

מגבלות על שינוי קנה מידה

ל-GKE יש ארכיטקטורת רשת גמישה שמאפשרת לשנות את קנה המידה של האשכול. אתם יכולים להוסיף לאשכול רשתות נוספות של צמתים ו-Pod. כך משנים את קנה המידה של האשכול:

• אפשר להוסיף עד 8 רשתות צמתים לכל מאגר צמתים ב-GKE. זו אותה מגבלת קנה מידה של מכונות וירטואליות ב-Compute Engine.
• לכל Pod אפשר לצרף עד 8 מחברי רשת נוספים.
• אפשר להגדיר עד 35 רשתות Pod ב-8 רשתות הצמתים במאגר צמתים אחד. אפשר לחלק את התקציב לשילובים שונים, למשל:
  • 7 רשתות של צמתים עם 5 רשתות של Pod בכל אחת
  • ‫5 רשתות של צמתים עם 7 רשתות של Pods בכל אחת
  • רשת צומת אחת עם 30 רשתות Pod. המגבלה לטווחי משנה לכל רשת משנה היא 30.
• אפשר להגדיר עד 50 רשתות Pod לכל אשכול.
• אפשר להגדיר עד 32 פודים עם כמה רשתות לכל צומת.
• יכולים להיות עד 5,000 צמתים עם כמה ממשקים.
• אפשר להוסיף עד 100,000 ממשקים נוספים בכל ה-Pods.

פריסת פודים עם כמה רשתות

כדי לפרוס פודים עם כמה רשתות:

1. מכינים VPC נוסף, רשת משנה (node-network) וטווחים משניים (Pod-network).
2. יוצרים אשכול GKE עם תמיכה בכמה רשתות באמצעות הפקודה של Google Cloud CLI.
3. יוצרים מאגר צמתים חדש של GKE שמחובר לרשת הצמתים ולרשת ה-Pod הנוספות באמצעות הפקודה של Google Cloud CLI.
4. יוצרים רשת Pod ומפנים ל-VPC, לתת-הרשת ולטווחים המשניים הנכונים באובייקטים של ריבוי רשתות באמצעות Kubernetes API.
5. בהגדרת עומס העבודה, מפנים לאובייקט ה-Network המוכן של Kubernetes באמצעות ה-API של Kubernetes.

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את המשימות הבאות:

• מפעילים את Google Kubernetes Engine API.
הפעלת Google Kubernetes Engine API
• כדי להשתמש ב-Google Cloud CLI למשימה הזו, מתקינים ואז מאתחלים את ה-CLI של gcloud. אם כבר התקנתם את ה-CLI של gcloud, הריצו את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.
  הערה: אם ה-CLI של gcloud כבר מותקן, צריך להגדיר את המאפיין compute/region. אם אתם משתמשים בעיקר באשכולות אזוריים, הגדירו במקום זאת את compute/zone. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

• קוראים את הדרישות וההגבלות.

הכנת VPC נוסף

Google Cloud יוצר רשת Pod שמשויכת למאגר הצמתים של GKE שמשמש ליצירה הראשונית של אשכול ה-GKE. רשת ה-Pod שמוגדרת כברירת מחדל זמינה בכל הצמתים וה-Pods באשכול. כדי להפעיל יכולות של כמה רשתות במאגר הצמתים, צריך להכין רשתות VPC קיימות או חדשות שתומכות ברשתות מסוג Layer 3 ו-Device.

כדי להכין VPC נוסף, צריך לעמוד בדרישות הבאות:

• רשת מסוג Layer 3 ו-Netdevice:

  • אם אתם משתמשים ברשתות מסוג Layer 3, אתם צריכים ליצור טווח משני.
  • חשוב לוודא שגודל ה-CIDR של הטווח המשני גדול מספיק כדי להכיל את מספר הצמתים במאגר הצמתים ואת מספר ה-Pods לכל צומת שרוצים שיהיו.
  • בדומה לרשת הפודים שמוגדרת כברירת מחדל, רשתות הפודים האחרות משתמשות בהקצאת יתר של כתובות IP. טווח כתובות ה-IP המשני חייב להכיל פי שניים כתובות IP לכל צומת ממספר ה-Pods לכל צומת.

• דרישות הרשת של סוג Device: יצירת רשת משנה רגילה ב-VPC. אתם לא צריכים טווח משני.

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

הערה: אחרי שיוצרים את מאגר הצמתים, אי אפשר להוסיף VPC חדש כדי להתחבר למאגר הצמתים הקיים.

יצירת רשת VPC שתומכת במכשיר מסוג Layer 3

כדי ליצור רשת VPC שתומכת במכשיר מסוג Layer 3:

• חשוב לוודא שגודל ה-CIDR של הטווח המשני גדול מספיק כדי להכיל את מספר הצמתים במאגר הצמתים ואת מספר ה-Pods לכל צומת שרוצים שיהיו.

• בדומה לרשת ברירת המחדל של Pod, רשתות Pod אחרות משתמשות בהקצאת יתר של כתובות IP. טווח כתובות ה-IP המשני חייב לכלול פי שניים כתובות IP לכל צומת ממספר ה-Pods לכל צומת.

gcloud

gcloud compute networks subnets create SUBNET_NAME \
    --project=PROJECT_ID \
    --range=SUBNET_RANGE \
    --network=NETWORK_NAME \
    --region=REGION \
    --secondary-range=SECONDARY_RANGE_NAME=<SECONDARY_RANGE_RANGE>

מחליפים את מה שכתוב בשדות הבאים:

• ‫SUBNET_NAME: שם תת-הרשת.
• ‫PROJECT_ID: מזהה הפרויקט שמכיל את רשת ה-VPC שבה נוצרה רשת המשנה.
• ‫SUBNET_RANGE: טווח כתובות ה-IPv4 הראשי של תת-הרשת החדשה, בסימון CIDR.
• ‫NETWORK_NAME: השם של רשת ה-VPC שמכילה את תת-הרשת החדשה.
• ‫REGION: האזור ב- Google Cloud שבו נוצרת תת-הרשת החדשה.
• ‫SECONDARY_RANGE_NAME: השם של הטווח המשני.
• ‫SECONDARY_IP_RANGE טווח כתובות ה-IPv4 המשני בסימון CIDR.

המסוף

1. נכנסים לדף VPC networks במסוף Google Cloud .

2. לוחצים על Create VPC network.

3. בשדה שם, מזינים את שם הרשת. לדוגמה, l3-vpc.

4. כדי להגדיר את יחידת השידור המקסימלית (MTU) של הרשת:

   • כדי להשתמש בערך ברירת המחדל של 1460, משאירים את התיבה הגדרת MTU באופן אוטומטי מסומנת.
   • כדי להגדיר ערך בהתאמה אישית:
     1. קוראים את המידע בקטע יחידת שידור מקסימלית.
     2. מבטלים את הסימון בתיבה הגדרת MTU באופן אוטומטי.
     3. בשדה Maximum transmission unit (MTU), בוחרים ערך MTU.

5. בקטע Subnet creation mode, בוחרים באפשרות Custom.

6. לוחצים על ADD SUBNET.

7. בקטע New subnet, מציינים את הפרמטרים הבאים להגדרת רשת משנה:

   1. מזינים שם. לדוגמה, l3-subnet.

   2. בוחרים Region.

   3. מזינים טווח של כתובות IP. זהו טווח ה-IPv4 הראשי של רשת המשנה.

      אם בוחרים טווח שהוא לא כתובת RFC 1918, צריך לוודא שהטווח לא מתנגש עם הגדרה קיימת. למידע נוסף, ראו טווחי רשתות משנה של IPv4.

   4. כדי להגדיר טווח משני לרשת המשנה, לוחצים על Create secondary IP address range.

      אם בוחרים טווח שהוא לא כתובת RFC 1918, צריך לוודא שהטווח לא מתנגש עם הגדרה קיימת. למידע נוסף, ראו טווחי רשתות משנה של IPv4.

   5. גישה פרטית ל-Google: אתם יכולים להפעיל גישה פרטית ל-Google ברשת המשנה כשאתם יוצרים אותה, או מאוחר יותר על ידי עריכה שלה.

   6. יומני תנועה: אתם יכולים להפעיל יומני תנועה של VPC בשביל רשת המשנה כשאתם יוצרים אותה, או מאוחר יותר על ידי עריכה שלה.

   7. לוחצים על סיום.

   הערה: כדי להוסיף עוד רשתות משנה, לוחצים על Add subnet. אפשר גם להוסיף עוד רשתות משנה לרשת אחרי שיוצרים אותה.

8. בקטע Firewall rules, בקטע IPv4 firewall rules, בוחרים אפס או יותר כללים מוגדרים מראש של חומת אש.

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

9. בקטע IPv4 firewall rules, כדי לערוך את כלל חומת האש המוגדר מראש לתעבורת נתונים נכנסת (ingress) בשם allow-custom, לוחצים על EDIT.

   אפשר לערוך רשתות משנה, להוסיף טווחי IPv4 ולציין פרוטוקולים ויציאות.

   כלל חומת האש allow-custom לא מתעדכן באופן אוטומטי אם מוסיפים עוד רשתות משנה בשלב מאוחר יותר. אם אתם צריכים כללים לחומת האש בשביל רשתות המשנה החדשות, תצטרכו לעדכן את ההגדרות של חומת האש כדי להוסיף את הכללים.

10. בקטע Dynamic routing mode של רשת ה-VPC. מידע נוסף זמין במאמר מצב ניתוב דינמי. אפשר לשנות את מצב הניתוב הדינמי בהמשך.

11. לוחצים על יצירה.

יצירת רשת VPC שתומכת במכשירים מסוג Netdevice או DPDK

gcloud

gcloud compute networks subnets create SUBNET_NAME \
    --project=PROJECT_ID \
    --range=SUBNET_RANGE \
    --network=NETWORK_NAME \
    --region=REGION

מחליפים את מה שכתוב בשדות הבאים:

• ‫SUBNET_NAME: שם תת-הרשת.
• ‫PROJECT_ID: מזהה הפרויקט שמכיל את רשת ה-VPC שבה נוצרה רשת המשנה.
• ‫SUBNET_RANGE: טווח כתובות ה-IPv4 הראשי של תת-הרשת החדשה, בסימון CIDR.
• ‫NETWORK_NAME: השם של רשת ה-VPC שמכילה את תת-הרשת החדשה.
• ‫REGION: האזור ב- Google Cloud שבו נוצרת תת-הרשת החדשה.

המסוף

1. נכנסים לדף VPC networks במסוף Google Cloud .

2. לוחצים על Create VPC network.

3. בשדה שם, מזינים את שם הרשת. לדוגמה, netdevice-vpc או dpdk-vpc.

4. בתפריט הנפתח Maximum transmission unit (MTU), בוחרים את ערך ה-MTU המתאים.

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

5. בקטע Subnet creation mode, בוחרים באפשרות Custom.

6. בקטע New subnet, מציינים את הפרמטרים הבאים להגדרת רשת משנה:

   1. מזינים שם. לדוגמה, netdevice-subnet או dpdk-vpc.

   2. בוחרים Region.

   3. מזינים טווח של כתובות IP. זהו טווח ה-IPv4 הראשי של רשת המשנה.

      אם בוחרים טווח שהוא לא כתובת RFC 1918, צריך לוודא שהטווח לא מתנגש עם הגדרה קיימת. למידע נוסף, ראו טווחי רשתות משנה של IPv4.

   4. גישה פרטית ל-Google: בוחרים אם להפעיל את הגישה הפרטית ל-Google ברשת המשנה כשיוצרים אותה, או מאוחר יותר על ידי עריכה שלה.

   5. יומני תנועה: אתם יכולים להפעיל יומני תנועה של VPC בשביל רשת המשנה כשאתם יוצרים אותה, או מאוחר יותר על ידי עריכה שלה.

   6. לוחצים על סיום.

      הערה: כדי להוסיף עוד תת-רשתות, לוחצים על Add subnet. אפשר גם להוסיף עוד רשתות משנה לרשת אחרי שיוצרים אותה.

7. בקטע Firewall rules, בקטע IPv4 firewall rules, בוחרים אפס או יותר כללים מוגדרים מראש של חומת אש.

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

8. בקטע IPv4 firewall rules, כדי לערוך את כלל חומת האש המוגדר מראש לתעבורת נתונים נכנסת (ingress) בשם allow-custom, לוחצים על EDIT.

   אפשר לערוך רשתות משנה, להוסיף טווחי IPv4 ולציין פרוטוקולים ויציאות.

   כלל חומת האש allow-custom לא מתעדכן באופן אוטומטי אם מוסיפים עוד רשתות משנה בשלב מאוחר יותר. אם אתם צריכים כללים לחומת האש בשביל רשתות המשנה החדשות, תצטרכו לעדכן את ההגדרות של חומת האש כדי להוסיף את הכללים.

9. בקטע Dynamic routing mode של רשת ה-VPC. מידע נוסף זמין במאמר מצב ניתוב דינמי. אפשר לשנות את מצב הניתוב הדינמי בהמשך.

10. לוחצים על יצירה.

יצירת אשכול GKE עם יכולות של כמה רשתות

כשמפעילים כמה ממשקי רשת באשכול, הגדרות ה-CustomResourceDefinitions‏ (CRD) הנדרשות מתווספות לשרת ה-API של האשכול. הוא גם פורס את network-controller-manager, שאחראי על התאמה וניהול של אובייקטים בכמה רשתות. אי אפשר לשנות את הגדרות האשכול אחרי שהוא נוצר.

יצירת אשכול GKE Autopilot עם יכולות של כמה רשתות

יוצרים אשכול GKE Autopilot עם יכולות של כמה רשתות:

gcloud container clusters create-auto CLUSTER_NAME \
    --cluster-version=CLUSTER_VERSION \
    --enable-multi-networking

מחליפים את מה שכתוב בשדות הבאים:

• ‫CLUSTER_NAME: שם האשכול.
• ‫CLUSTER_VERSION: גרסת האשכול.

הדגל --enable-multi-networking מפעיל הגדרות של משאבים בהתאמה אישית (CRD) עם כמה רשתות בשרת ה-API של האשכול הזה, ופורס את network-controller-manager שמכיל את ניהול ההתאמה ומחזור החיים של אובייקטים עם כמה רשתות.

יצירת אשכול GKE Standard עם יכולות של ריבוי רשתות

gcloud

יוצרים אשכול GKE Standard עם יכולות של ריבוי רשתות:

gcloud container clusters create CLUSTER_NAME \
    --cluster-version=CLUSTER_VERSION \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --enable-multi-networking

מחליפים את מה שכתוב בשדות הבאים:

• ‫CLUSTER_NAME: שם האשכול.
• ‫CLUSTER_VERSION: גרסת האשכול.

הפקודה הזו כוללת את הדגלים הבאים:

• הדגל --enable-multi-networking: מפעיל הגדרות של משאבים בהתאמה אישית (CRD) עם כמה רשתות בשרת ה-API של האשכול הזה, ופורס את network-controller-manager שמכיל את ההתאמה ואת ניהול מחזור החיים של אובייקטים עם כמה רשתות.
• ‫--enable-dataplane-v2: מפעיל את GKE Dataplane V2. הדגל הזה נדרש כדי להפעיל את התכונה "רשתות מרובות".

המסוף

1. נכנסים לדף Create a Kubernetes cluster במסוף Google Cloud .

   יצירת אשכול Kubernetes

2. מגדירים את האשכול הרגיל. מידע נוסף זמין במאמרים יצירת אשכול אזורי ויצירת אשכול בכמה אזורים. בזמן יצירת האשכול, בוחרים את הרשת ואת רשת המשנה של הצומת המתאימות.
3. בחלונית הניווט, בקטע Cluster, לוחצים על Networking.
4. מסמנים את התיבה Enable Dataplane V2.
5. בוחרים באפשרות הפעלת ריבוי רשתות.
6. לוחצים על יצירה.

יצירת מאגר צמתים ב-GKE Standard שמחובר ל-VPC נוספים

יוצרים מאגר צמתים שכולל צמתים שמחוברים לרשת הצמתים (VPC ורשת משנה) ולרשת Pod (טווח משני) שנוצרו בקטע יצירת רשת Pod.

כדי ליצור את מאגר הצמתים החדש ולשייך אותו לרשתות הנוספות באשכול ה-GKE:

gcloud

gcloud container node-pools create POOL_NAME \
  --cluster=CLUSTER_NAME \
  --additional-node-network network=NETWORK_NAME,subnetwork=SUBNET_NAME \
  --additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=POD_IP_RANGE,max-pods-per-node=NUMBER_OF_PODS

מחליפים את מה שכתוב בשדות הבאים:

• POOL_NAME בשם של מאגר הצמתים החדש.
• ‫CLUSTER_NAME בשם של האשכול הקיים שאליו רוצים להוסיף את מאגר הצמתים.
• ‫NETWORK_NAME בשם הרשת שאליה רוצים לצרף את הצמתים של מאגר הצמתים.
• ‫SUBNET_NAME עם השם של רשת המשנה בתוך הרשת שבה רוצים להשתמש בשביל הצמתים.
• ‫POD_IP_RANGE טווח כתובות ה-IP של הפודים בתת-הרשת.
• ‫NUMBER_OF_PODS פודים לכל צומת.

הפקודה הזו מכילה את הדגלים הבאים:

• ‫--additional-node-network: מגדיר את הפרטים של ממשק הרשת, הרשת ורשת המשנה הנוספים. השדה הזה משמש לציון רשתות הצמתים לחיבור לצמתים של מאגר הצמתים. צריך לציין את הפרמטר הזה כשרוצים להתחבר ל-VPC אחר. אם לא מציינים את הפרמטר הזה, המערכת משתמשת ב-VPC שמשויך לאשכול כברירת מחדל. ברשתות מסוג Layer 3, מציינים את הדגל additional-pod-network שמגדיר את רשת ה-Pod, שנחשפת בתוך אשכול GKE כאובייקט Network. כשמשתמשים בדגל --additional-node-network, צריך לציין רשת ורשת משנה כפרמטרים חובה. חשוב להפריד בין ערכי הרשת ורשת המשנה באמצעות פסיק, ולא להשתמש ברווחים.

  אפשר גם לציין את הפרמטר stack-type (גרסת טרום-השקה (Preview)) כדי להגדיר את סוג מחסנית כתובות ה-IP של ממשק הרשת (הערכים התקינים הם ipv4,‏ ipv4-ipv6 או ipv6). ההגדרה הסופית של ממשק הרשת תלויה בערך שציינתם בשדה stack-type ובהגדרה של רשת המשנה הבסיסית:

  • ברשתות משנה מסוג IPv4_ONLY, הערך החוקי בשדה stack-type הוא ipv4.
  • ברשתות משנה מסוג IPv4_IPv6, הערכים התקינים בשדה stack-type הם ipv4,‏ ipv4-ipv6 ו-ipv6.
  • ברשתות משנה מסוג IPv6_ONLY, הערך התקין בשדה stack-type הוא ipv6.

  אם לא מציינים ערך בשדה stack-type, סוג המחסנית מוגדר כברירת מחדל לכתובת IPv4 ב-NIC לרשתות משנה עם IPv4 בלבד או רשתות משנה בשני פרוטוקולים, ולכתובת IPv6 לרשתות משנה עם IPv6 בלבד. כדי לשמור על תאימות לדורות קודמים, הערך של השדה stack-type ברשתות משנה בשני פרוטוקולים הוא ipv4 כברירת מחדל, אלא אם משנים אותו באופן מפורש. מידע נוסף זמין במאמר סוגי מחסניות.

• ‫--additional-pod-network: מציין את הפרטים של הטווח המשני שישמש לרשת ה-Pod. הפרמטר הזה לא נדרש אם משתמשים ברשת מסוג Device. הארגומנט הזה מציין את ערכי המפתחות הבאים: subnetwork,‏ pod-ipv4-range ו-max-pods-per-node. כשמשתמשים ב---additional-pod-network, צריך לציין את הערכים של pod-ipv4-range ו-max-pods-per-node, מופרדים בפסיקים וללא רווחים.

  • ‫subnetwork: מקשר בין רשת הצמתים לרשת ה-Pod. רשת המשנה היא אופציונלית. אם לא מציינים את זה, רשת ה-Pod הנוספת משויכת לרשת המשנה שמוגדרת כברירת מחדל במהלך יצירת האשכול.
  • ‫--max-pods-per-node: צריך לציין את max-pods-per-node, והוא חייב להיות חזקה של 2. הערך המינימלי הוא 4. הערך של max-pods-per-node לא יכול להיות גדול מהערך של max-pods-per-node במאגר הצמתים.

המסוף

1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

   כניסה ל-Google Kubernetes Engine

2. בחלונית הניווט, לוחצים על Clusters.

3. בקטע Kubernetes clusters, לוחצים על האשכול שיצרתם.

4. לוחצים על הכרטיסייה Nodes.

5. ‫לוחצים על Create user-managed node pool.

6. בקטע פרטי מאגר הצמתים, מבצעים את הפעולות הבאות:

   1. מזינים שם למאגר הצמתים.
   2. מזינים את מספר הצמתים שרוצים ליצור במאגר הצמתים.

7. בחלונית הניווט, בקטע מאגרי צמתים, לוחצים על צמתים.

   1. בתפריט הנפתח Image type, בוחרים את קובץ האימג' של הצומת מערכת הפעלה שמותאמת לקונטיינרים עם containerd (cos_containerd).

8. כשיוצרים מכונה וירטואלית, בוחרים סוג מכונה מתוך משפחת מכונות שקובעת את המשאבים שזמינים למכונה הווירטואלית הזו. לדוגמה, סוג מכונה כמו e2-standard-4 מכיל 4 מעבדי vCPU, ולכן יכול לתמוך בעד 4 רשתות VPC בסך הכול. יש כמה משפחות מכונות שאפשר לבחור מתוכן, וכל משפחת מכונות מאורגנת לפי סדרות מכונות וסוגי מכונות מוגדרים מראש או סוגי מכונות בהתאמה אישית בכל סדרה. כל סוג מכונה מחויב באופן שונה. מידע נוסף זמין בגיליון המחירים של סוגי המכונות.

9. בחלונית הניווט, בוחרים באפשרות Networking.

10. בקטע Node Networking, מציינים את המספר המקסימלי של Pods לכל צומת. בקטע Node Networks מוצגת רשת ה-VPC ששימשה ליצירת האשכול. צריך להגדיר רשתות צמתים נוספות שתואמות לרשתות ה-VPC ולסוגי המכשירים שהוגדרו קודם.

11. יצירת שיוך של מאגר צמתים:

    1. במכשיר מסוג Layer 3:
       1. בקטע Node Networks, לוחצים על ADD A NODE NETWORK.
       2. ברשימה הנפתחת של הרשת, בוחרים באפשרות VPC that supports Layer 3 type device.
       3. בוחרים את רשת המשנה שנוצרה ל-VPC של Layer 3.
       4. בקטע Alias Pod IP address ranges, לוחצים על Add Pod IP address range.
       5. בוחרים את Secondary subnet ומציינים את Max number of Pods per node.
       6. לוחצים על סיום.
    2. במכשירים מסוג Netdevice ו-DPDK:
       1. בקטע Node Networks, לוחצים על ADD A NODE NETWORK.
       2. ברשימה הנפתחת של הרשת, בוחרים את ה-VPC שתומך במכשירים מסוג Netdevice או DPDK.
       3. בוחרים את רשת המשנה שנוצרה ל-VPC של Netdevice או DPDK.
       4. לוחצים על סיום.

12. לוחצים על יצירה.

הערות:

• כשמפעילים כתובת IPv6 בכרטיסי רשת נוספים באמצעות הגדרת stack-type, צריך לוודא שמדיניות חומת האש ב-VPC מוגדרת בצורה נכונה לכתובות IPv6. בניגוד לכתובות IPv4, אם משתמשים בכתובות Global Unicast ‏(GUA), הצמתים עלולים להיות חשופים לאינטרנט הציבורי אם הם לא מוגבלים כראוי.
• אם מציינים כמה רשתות Pod נוספות באותה רשת צמתים, הן חייבות להיות באותה רשת משנה.
• אי אפשר להפנות לאותו טווח משני של רשת משנה כמה פעמים.

דוגמה בדוגמה הבאה נוצר מאגר צמתים בשם pool-multi-net שמצרף שני רשתות נוספות לצמתים, dataplane (רשת מסוג Layer 3) ו-highperformance (רשת מסוג netdevice). בדוגמה הזו, נניח שכבר יצרתם אשכול GKE בשם cluster-1:

gcloud container node-pools create pool-multi-net \
  --project my-project \
  --cluster cluster-1 \
  --location us-central1-c \
  --additional-node-network network=dataplane,subnetwork=subnet-dp \
  --additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-blue,max-pods-per-node=8 \
  --additional-node-network network=highperformance,subnetwork=subnet-highperf

כדי לציין ממשקים נוספים של רשתות צמתים ורשתות Pod, מגדירים את הפרמטרים --additional-node-network ו---additional-pod-network כמה פעמים, כמו בדוגמה הבאה:

--additional-node-network network=dataplane,subnetwork=subnet-dp \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-blue,max-pods-per-node=8 \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-green,max-pods-per-node=8 \
--additional-node-network network=managementdataplane,subnetwork=subnet-mp \
--additional-pod-network subnetwork=subnet-mp,pod-ipv4-range=sec-range-red,max-pods-per-node=4

כדי לציין רשתות Pod נוספות ישירות בממשק ה-VPC הראשי של מאגר הצמתים, כמו בדוגמה הבאה:

--additional-pod-network subnetwork=subnet-def,pod-ipv4-range=sec-range-multinet,max-pods-per-node=8

כדי להוסיף ממשק רשת משני מסוג IPv6 בלבד, מוסיפים את הפרמטר stack-type כמו בדוגמה הבאה:

--additional-node-network network=highperformance,subnetwork=ipv6-only-subnet,stack-type=ipv6

כדי להוסיף ממשק רשת משני עם שני סוגי כתובות IP, לקישוריות של כתובות IPv4 ו-IPv6, מוסיפים את הפרמטר stack-type כמו בדוגמה הבאה:

--additional-node-network network=service-net,subnetwork=dual-stack-subnet,stack-type=ipv4-ipv6

יצירת רשת Pod

מגדירים את רשתות ה-Pod שאליהן ה-Pods ייגשו, על ידי הגדרת אובייקטים של Kubernetes וקישור שלהם למשאבים המתאימים של Compute Engine, כמו רשתות VPC, רשתות משנה וטווחי כתובות IP משניים.

כדי ליצור רשת Pod, צריך להגדיר את אובייקטי ה-CRD של הרשת באשכול.

הגדרת רשת VPC של Layer 3

YAML

ל-VPC של Layer 3, יוצרים אובייקטים של Network ו-GKENetworkParamSet:

1. שומרים את המניפסט לדוגמה הבא בתור blue-network.yaml:

   apiVersion: networking.gke.io/v1
   kind: Network
   metadata:
     name: blue-network
   spec:
     type: "L3"
     parametersRef:
       group: networking.gke.io
       kind: GKENetworkParamSet
       name: "l3-vpc"
   

   המניפסט מגדיר משאב Network בשם blue-network מסוג Layer 3. האובייקט Network מפנה לאובייקט GKENetworkParamSet שנקרא l3-vpc, שמשייך רשת למשאבים של Compute Engine.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f blue-network.yaml
   

3. שומרים את המניפסט הבא בתור l3-vpc.yaml :

   apiVersion: networking.gke.io/v1
   kind: GKENetworkParamSet
   metadata:
     name: "l3-vpc"
   spec:
     vpc: "l3-vpc"
     vpcSubnet: "subnet-dp"
     podIPv4Ranges:
       rangeNames:
       - "sec-range-blue"
   

   המניפסט הזה מגדיר את האובייקט GKENetworkParamSet בשם l3-vpc על ידי הגדרת שם ה-VPC כ-l3-vpc, שם רשת המשנה כ-subnet-dp וטווח הכתובות המשני של IPv4 לפודים כ-sec-range-blue.

4. מחילים את המניפסט על האשכול:

   kubectl apply -f l3-vpc.yaml
   

המסוף

1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

   כניסה ל-Google Kubernetes Engine

2. בחלונית הניווט, לוחצים על Network Function Optimizer.

3. בחלק העליון של הדף, לוחצים על Create כדי ליצור את רשת ה-Pod.

4. בקטע לפני שמתחילים, מאמתים את הפרטים.

5. לוחצים על NEXT: POD NETWORK LOCATION.

6. בקטע Pod network location, בתפריט הנפתח Cluster בוחרים את אשכול GKE שבו מופעלים multi-networking ו-GKE Dataplane V2.

7. לוחצים על NEXT: VPC NETWORK REFERENCE.

8. בקטע VPC network reference, בתפריט הנפתח VPC network reference בוחרים את רשת ה-VPC שמשמשת לפודים של Layer 3 עם כמה כרטיסי רשת.

9. לוחצים על NEXT: POD NETWORK TYPE.

10. בקטע Pod network type, בוחרים באפשרות L3 ומזינים את הערך של Pod network name.

11. לוחצים על NEXT: POD NETWORK SECONDARY RANGE.

12. בקטע Pod network secondary range, מזינים את הטווח המשני (Secondary range).

13. לוחצים על NEXT: POD NETWORK ROUTES.

14. בקטע Pod network routes, כדי להגדיר Custom routes, לוחצים על ADD ROUTE.

15. לוחצים על CREATE POD NETWORK.

הגדרת רשת DPDK

YAML

ב-DPDK VPC, יוצרים אובייקטים מסוג Network ו-GKENetworkParamSet.

1. שומרים את המניפסט לדוגמה הבא בתור dpdk-network.yaml:

   apiVersion: networking.gke.io/v1
   kind: Network
   metadata:
     name: dpdk-network
   spec:
     type: "Device"
     parametersRef:
       group: networking.gke.io
       kind: GKENetworkParamSet
       name: "dpdk"
   

   המניפסט הזה מגדיר משאב Network בשם dpdk-network מסוג Device. המשאב Network מפנה לאובייקט GKENetworkParamSet שנקרא dpdk בשביל ההגדרה שלו.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f dpdk-network.yaml
   

3. לאובייקט GKENetworkParamSet, שומרים את המניפסט הבא בתור dpdk.yaml:

   apiVersion: networking.gke.io/v1
   kind: GKENetworkParamSet
   metadata:
     name: "dpdk"
   spec:
     vpc: "dpdk"
     vpcSubnet: "subnet-dpdk"
     deviceMode: "DPDK-VFIO"
   

   המניפסט הזה מגדיר את האובייקט GKENetworkParamSet בשם dpdk, מגדיר את שם ה-VPC בתור dpdk, את שם תת-הרשת בתור subnet-dpdk ואת שם ה-deviceMode בתור DPDK-VFIO.

4. מחילים את המניפסט על האשכול:

   kubectl apply -f dpdk.yaml
   

המסוף

1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

   כניסה ל-Google Kubernetes Engine

2. בחלונית הניווט, לוחצים על Network Function Optimizer.

3. בחלק העליון של הדף, לוחצים על Create כדי ליצור את רשת ה-Pod.

4. בקטע לפני שמתחילים, מאמתים את הפרטים.

5. לוחצים על NEXT: POD NETWORK LOCATION.

6. בקטע Pod network location, בתפריט הנפתח Cluster בוחרים את אשכול GKE שבו מופעלים multi-networking ו-GKE Dataplane V2.

7. לוחצים על NEXT: VPC NETWORK REFERENCE.

8. בקטע VPC network reference, בתפריט הנפתח VPC network reference בוחרים את רשת ה-VPC שמשמשת לפודים של dpdk multinic.

9. לוחצים על NEXT: POD NETWORK TYPE.

10. בקטע Pod network type, בוחרים באפשרות DPDK-VFIO (Device) ומזינים את הערך של Pod network name.

11. לוחצים על NEXT: POD NETWORK SECONDARY RANGE. הקטע של טווח המשנה של רשת Pod לא יהיה זמין

12. לוחצים על NEXT: POD NETWORK ROUTES. בקטע Pod network routes, לוחצים על ADD ROUTE כדי להגדיר מסלולים בהתאמה אישית.

13. לוחצים על CREATE POD NETWORK.

הערה: ברשת DPDK, ה-NIC מקושר למנהל ההתקן של VFIO, שלא יופיע כמכשיר רשת רגיל של ליבה (kernel) שמוצג ב-ip link.

הגדרת רשת netdevice

ל-VPC של netdevice, יוצרים אובייקטים של Network ו-GKENetworkParamSet.

YAML

1. שומרים את המניפסט לדוגמה הבא בתור netdevice-network.yaml:

   apiVersion: networking.gke.io/v1
   kind: Network
   metadata:
       name: netdevice-network
   spec:
       type: "Device"
       parametersRef:
         group: networking.gke.io
         kind: GKENetworkParamSet
         name: "netdevice"
   

   המניפסט הזה מגדיר משאב Network בשם netdevice-network מסוג Device. הוא מפנה לאובייקט GKENetworkParamSet בשם netdevice.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f netdevice-network.yaml
   

3. שומרים את המניפסט הבא בתור netdevice.yaml :

   apiVersion: networking.gke.io/v1
   kind: GKENetworkParamSet
   metadata:
     name: netdevice
   spec:
     vpc: "netdevice"
     vpcSubnet: "subnet-netdevice"
     deviceMode: "NetDevice"
   

   המניפסט הזה מגדיר משאב GKENetworkParamSet בשם netdevice, מגדיר את שם ה-VPC בתור netdevice, את שם רשת המשנה בתור subnet-netdevice ומציין את מצב המכשיר בתור NetDevice.

4. מחילים את המניפסט על האשכול:

   kubectl apply -f netdevice.yaml
   

המסוף

1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

   כניסה ל-Google Kubernetes Engine

2. בחלונית הניווט, לוחצים על Network Function Optimizer.

3. בחלק העליון של הדף, לוחצים על Create כדי ליצור את רשת ה-Pod.

4. בקטע לפני שמתחילים, מאמתים את הפרטים.

5. לוחצים על NEXT: POD NETWORK LOCATION.

6. בקטע Pod network location, בתפריט הנפתח Cluster בוחרים את אשכול GKE שבו מופעלים multi-networking ו-GKE Dataplane V2.

7. לוחצים על NEXT: VPC NETWORK REFERENCE.

8. בקטע VPC network reference, בתפריט הנפתח VPC network reference בוחרים את רשת ה-VPC שמשמשת לפודים עם כמה כרטיסי רשת (multinic) של netdevice.

9. לוחצים על NEXT: POD NETWORK TYPE.

10. בקטע Pod network type, בוחרים באפשרות NetDevice (Device)‎ ומזינים את השם של Pod network name.

11. לוחצים על NEXT: POD NETWORK SECONDARY RANGE. הקטע של טווח המשנה של רשת Pod לא יהיה זמין

12. לוחצים על NEXT: POD NETWORK ROUTES. בקטע Pod network routes, כדי להגדיר נתיבים בהתאמה אישית, לוחצים על ADD ROUTE.

13. לוחצים על CREATE POD NETWORK.

הגדרת נתיבי רשת

הגדרת נתיב רשת מאפשרת להגדיר נתיבים בהתאמה אישית לרשת ספציפית, שמוגדרים ב-Pods כדי לנתב את התנועה לממשק המתאים ב-Pod.

YAML

1. שומרים את המניפסט הבא בתור red-network.yaml:

   apiVersion: networking.gke.io/v1
   kind: Network
   metadata:
     name: red-network
   spec:
     type: "L3"
     parametersRef:
       group: networking.gke.io
       kind: GKENetworkParamSet
       name: "management"
     routes:
     -   to: "10.0.2.0/28"
   

   המניפסט הזה מגדיר משאב רשת בשם red-network מסוג Layer 3 ונתיב בהתאמה אישית "10.0.2.0/28" דרך ממשק הרשת הזה.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f red-network.yaml
   

המסוף

1. נכנסים לדף Network Function Optimizer במסוף Google Cloud .

   כניסה לכלי לשיפור התפקוד של הרשת

2. לוחצים על יצירה.

3. בוחרים אשכול שמופעלת בו תמיכה בכמה רשתות.

4. מגדירים את העדפות הרשת.

5. לוחצים על Create Pod network.

עיינו בNetwork שהכנתם

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

חיבור Pod לרשתות ספציפיות

כדי לחבר Pods לרשתות שצוינו, צריך לכלול את השמות של האובייקטים של Network כהערות בתוך ההגדרות של ה-Pod. כדי ליצור את החיבורים, חשוב לכלול בהערות גם את default Network וגם את הרשתות הנוספות שנבחרו.

1. שומרים את המניפסט לדוגמה הבא בתור sample-l3-pod.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: sample-l3-pod
     annotations:
       networking.gke.io/default-interface: 'eth0'
       networking.gke.io/interfaces: |
         [
           {"interfaceName":"eth0","network":"default"},
           {"interfaceName":"eth1","network":"blue-network"}
         ]
   spec:
     containers:
     - name: sample-l3-pod
       image: busybox
       command: ["sleep", "10m"]
       ports:
       - containerPort: 80
     restartPolicy: Always
   

   המניפסט הזה יוצר Pod בשם sample-l3-pod עם שני ממשקי רשת, eth0 ו-eth1, שמשויכים לרשתות default ו-blue-network, בהתאמה.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f sample-l3-pod.yaml
   

חיבור של Pod לכמה רשתות

1. שומרים את המניפסט לדוגמה הבא בתור sample-l3-netdevice-pod.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: sample-l3-netdevice-pod
     annotations:
       networking.gke.io/default-interface: 'eth0'
       networking.gke.io/interfaces: |
         [
           {"interfaceName":"eth0","network":"default"},
           {"interfaceName":"eth1","network":"blue-network"},
           {"interfaceName":"eth2","network":"netdevice-network"}
         ]
   spec:
     containers:
     - name: sample-l3-netdevice-pod
       image: busybox
       command: ["sleep", "10m"]
       ports:
       - containerPort: 80
     restartPolicy: Always
   

   המניפסט הזה יוצר Pod בשם sample-l3-netdevice-pod עם שלושה ממשקי רשת, eth0,‏ eth1 ו-eth2, שמשויכים לרשתות default,‏ blue-network ו-netdevice, בהתאמה.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f sample-l3-netdevice-pod.yaml
   

אפשר להשתמש באותו הסבר בכל ReplicaSet‏ (Deployment או DaemonSet) בקטע ההסברים של התבנית.

הגדרת דוגמה של Pod עם כמה ממשקים:

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
      valid_lft forever preferred_lft forever
2: eth0@if9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue state UP group default
    link/ether 2a:92:4a:e5:da:35 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 10.60.45.4/24 brd 10.60.45.255 scope global eth0
      valid_lft forever preferred_lft forever
10: eth1@if11: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue state UP group default qlen 1000
    link/ether ba:f0:4d:eb:e8:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.16.1.2/32 scope global eth1
      valid_lft forever preferred_lft forever

אימות

• חשוב לוודא שיוצרים אשכולות עם --enable-multi-networking רק אם --enable-dataplane-v2 מופעל.
• מוודאים שכל מאגרי הצמתים באשכול מריצים קובצי אימג' של מערכת הפעלה שמותאמת לקונטיינרים בזמן היצירה של האשכול ומאגר הצמתים.
• מוודאים שמאגרי הצמתים נוצרים עם --additional-node-network או עם --additional-pod-network רק אם מופעלת ריבוי רשתות באשכול.
• חשוב לוודא שאותה רשת משנה לא צוינה פעמיים כארגומנט --additional-node-network למאגר צמתים.
• מוודאים שאותו טווח משני לא צוין כארגומנט --additional-pod-network למאגר צמתים.
• חשוב לפעול לפי מגבלות קנה המידה שצוינו לאובייקטים ברשת, תוך התחשבות במספר המקסימלי המותר של צמתים, Pods וכתובות IP.
• מוודאים שיש רק אובייקט GKENetworkParamSet אחד שמתייחס לרשת משנה ולטווח משני מסוימים.
• מוודאים שכל אובייקט רשת מתייחס לאובייקט GKENetworkParamSet אחר.
• אם אובייקט הרשת נוצר עם רשת משנה ספציפית עם רשת Device, צריך לוודא שהוא לא נמצא בשימוש באותו צומת עם רשת אחרת עם טווח משני. אפשר לאמת את זה רק בזמן הריצה.
• מוודאים שאין חפיפה בין כתובות ה-IP בטווחי המשנה השונים שהוקצו למאגרי הצמתים.

פתרון בעיות בפרמטרים של ריבוי רשתות ב-GKE

כדי לוודא שהגדרת הרשת נכונה, Google Cloud מאמת את הפרמטרים של ריבוי הרשתות כשיוצרים אשכולות ומאגרי צמתים.

הערה: כשפותרים בעיות ברשתות מסוג Device, צריך לוודא ש-high-perf-device-plugin ו-anetd מותקנים בצמתים. בנוסף, צריך לוודא שתווית הצומת google.cloud.com/run-high-perf-daemons: "true" קיימת בצמתים. התווית הזו שולטת באופן ספציפי בhigh-perf-device-plugin.

החל מגרסה 1.32 של GKE, צריך את high-perf-config-daemon רק כשיש רשת DPDK-VFIO בצומת. כדי לבדוק את high-perf-config-daemon, מוודאים שתווית הצומת cloud.google.com/run-high-perf-config-daemons: "true" קיימת. אם חסרים הפלאגינים או תוויות הצמתים הנדרשים לסוג הרשת הספציפי, יכול להיות שההגדרה לא מלאה או לא נכונה.

שגיאה: סוג המקבץ לא תקין

כשיוצרים מאגר צמתים עם ממשק רשת נוסף, יכול להיות שתופיע השגיאה הבאה:

Google Compute Engine: Invalid value for field 'resource.properties.networkInterfaces[1].stackType': 'UNSPECIFIED_STACK_TYPE'.

השגיאה הזו בדרך כלל מתרחשת כשמשתמשים ברשת משנה מסוג IPv6 בלבד בלי להגדיר במפורש את הערך של השדה stack-type בגרסאות או בהגדרות קודמות של GKE. כדי לפתור את הבעיה, צריך לעדכן את הרכיבים של ה-CLI של gcloud, להשתמש בגרסה חדשה יותר של GKE ולכלול באופן מפורש את הפרמטר stack-type=ipv6 בפקודה.

אם לא הצלחתם ליצור עומסי עבודה בכמה רשתות, אתם יכולים לבדוק את הסטטוס והאירועים של ה-Pod כדי לקבל מידע נוסף:

kubectl describe pods samplepod

הפלט אמור להיראות כך:

Name:         samplepod
Namespace:    default
Status:       Running
IP:           192.168.6.130
IPs:
  IP:  192.168.6.130
...
Events:
  Type     Reason                  Age   From               Message
  ----     ------                  ----  ----               -------
  Normal   NotTriggerScaleUp  9s               cluster-autoscaler  pod didn't trigger scale-up:
  Warning  FailedScheduling   8s (x2 over 9s)  default-scheduler   0/1 nodes are available: 1 Insufficient networking.gke.io.networks/my-net.IP. preemption: 0/1 nodes are available: 1 No preemption victims found for incoming pod

אלה הסיבות הכלליות לכך שהפוד לא נוצר:

• התזמון של Pod נכשל כי לא התקיימו דרישות המשאבים של ריבוי רשתות
• זיהוי הרשתות שצוינו נכשל

פתרון בעיות ביצירת רשתות Kubernetes

אחרי שיוצרים רשת, צמתים שצריכה להיות להם גישה לרשת שהוגדרה מקבלים הערה של סטטוס הרשת.

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

kubectl describe node NODE_NAME

מחליפים את NODE_NAME בשם הצומת.

הפלט אמור להיראות כך:

networking.gke.io/network-status: [{"name":"default"},{"name":"dp-network"}]

בפלט מופיעה רשימה של כל הרשתות שזמינות בצומת. אם סטטוס הרשת הצפוי לא מופיע בצומת, מבצעים את הפעולות הבאות:

בודקים אם לצומת יש גישה לרשת

אם הרשת לא מופיעה בהערה של סטטוס הרשת של הצומת:

1. מוודאים שהצומת הוא חלק ממאגר שמוגדר לריבוי רשתות.
2. בודקים את הממשקים של הצומת כדי לראות אם יש לו ממשק לרשת שאתם מגדירים.
3. אם לצומת חסר network-status ויש לו רק ממשק רשת אחד, עדיין צריך ליצור מאגר של צמתים עם multi-networking מופעל.
4. אם הצומת מכיל את הממשק של הרשת שאתם מגדירים אבל הוא לא מופיע בהערה של סטטוס הרשת, בדקו את המשאבים Network ו-GKENetworkParamSet (GNP).

בודקים את המשאבים של Network ו-GKENetworkParamSet

הסטטוס של המשאבים Network ו-GKENetworkParamSet (GNP) כולל שדה תנאים לדיווח על שגיאות בהגדרות. מומלץ לבדוק קודם את GNP, כי הוא לא מסתמך על משאב אחר כדי להיות תקף.

כדי לבדוק את שדה התנאים, מריצים את הפקודה הבאה:

kubectl get gkenetworkparamsets GNP_NAME -o yaml

מחליפים את GNP_NAME בשם של המשאב GKENetworkParamSet.

כשהתנאי Ready שווה ל-true, ההגדרות תקינות והפלט דומה לזה:

apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
...
spec:
  podIPv4Ranges:
    rangeNames:
    -   sec-range-blue
  vpc: dataplane
  vpcSubnet: subnet-dp
status:
  conditions:
  -   lastTransitionTime: "2023-06-26T17:38:04Z"
    message: ""
    reason: GNPReady
    status: "True"
    type: Ready
  networkName: dp-network
  podCIDRs:
    cidrBlocks:
    -   172.16.1.0/24

אם התנאי Ready הוא false, הפלט מציג את הסיבה ונראה בערך כך:

apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
...
spec:
  podIPv4Ranges:
    rangeNames:
    -   sec-range-blue
  vpc: dataplane
  vpcSubnet: subnet-nonexist
status:
  conditions:
  -   lastTransitionTime: "2023-06-26T17:37:57Z"
    message: 'subnet: subnet-nonexist not found in VPC: dataplane'
    reason: SubnetNotFound
    status: "False"
    type: Ready
  networkName: ""

אם מופיעה הודעה דומה, ודאו שהגדרתם את ה-GNP בצורה נכונה. אם היא כבר מוגדרת, צריך לוודא שהגדרות הרשת של Google Cloud נכונות. אחרי עדכון הגדרות הרשת של Google Cloud , יכול להיות שתצטרכו ליצור מחדש את המשאב של GNP כדי להפעיל סנכרון מחדש באופן ידני. כדי למנוע דגימה אינסופית של ה-API שלGoogle Cloud.

כשה-GNP מוכן, בודקים את המשאב Network.

kubectl get networks NETWORK_NAME -o yaml

מחליפים את NETWORK_NAME בשם של המשאב Network.

הפלט של תצורה תקינה דומה לזה:

apiVersion: networking.gke.io/v1
kind: Network
...
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: dp-gnp
  type: L3
status:
  conditions:
  -   lastTransitionTime: "2023-06-07T19:31:42Z"
    message: ""
    reason: GNPParamsReady
    status: "True"
    type: ParamsReady
  -   lastTransitionTime: "2023-06-07T19:31:51Z"
    message: ""
    reason: NetworkReady
    status: "True"
    type: Ready

• ‫reason: NetworkReady מציין שמשאב הרשת מוגדר בצורה נכונה. הערך reason: NetworkReady לא מציין שמשאב הרשת זמין בהכרח בצומת ספציפי או שהוא בשימוש פעיל.
• אם יש שגיאה או הגדרה שגויה, השדה reason בתנאי מציין את הסיבה המדויקת לבעיה. במקרים כאלה, צריך לשנות את ההגדרות בהתאם.
• ‫GKE מאכלס את השדה ParamsReady אם השדה parametersRef מוגדר למשאב GKENetworkParamSet שקיים באשכול. אם ציינתם את GKENetworkParamSet מסוג parametersRef והתנאי לא מופיע, ודאו שהשם, הסוג והקבוצה תואמים למשאב ה-GNP שקיים באשכול.

הגדרת תמיכה בכמה רשתות באשכולות IPv6 עם מחסנית אחת

תצוגה מקדימה

השימוש במוצר או בתכונה כפוף לתנאי השימוש במוצרים בשלב טרום-GA, בחלק "תנאים כלליים לשירות" של התנאים הספציפיים לשירות. השימוש בתכונות ובמוצרים בגרסת טרום-GA הוא "כפי שהם" (As is), ויכול להיות שהתמיכה בהם תהיה מוגבלת. אתם יכולים לקרוא מידע נוסף בקטע תיאור שלבי ההשקה.

באשכולות IPv6 עם סטאק יחיד, אתם יכולים להגדיר תמיכה בכמה רשתות לפודים כדי לצרף רשתות פודים משניות מסוג IPv4 בלבד, שמגובות על ידי רשת VPC וזוג תת-רשתות, לעומסי עבודה שהממשק הראשי שלהם משתמש ברשת IPv6. ההגדרה הזו מאפשרת תקשורת היברידית של IPv4/IPv6 עם משאבי IPv4 ברשתות משנה משניות של VPC.

נקודות מרכזיות ומגבלות באשכולות IPv6

לפני שמגדירים תמיכה בכמה רשתות באשכול IPv6 עם מחסנית אחת, כדאי לקרוא את השיקולים והמגבלות הבאים:

• ממשק ראשי: ממשק הרשת של Pod שמוגדר כברירת מחדל (eth0) פועל ברשת IPv6 עם מחסנית אחת.
• ממשקים משניים: רשתות Pod משניות חייבות להיות מסוג IPv4 בלבד (סוג מחסנית IPV4) ולהשתמש ברשתות VPC בשכבה 3. באשכולות IPv6 עם מחסנית אחת אי אפשר להשתמש ברשתות Pod משניות של IPv6.
• ניתוב ממשק ברירת המחדל: ההערה networking.gke.io/default-interface מגדירה את ממשק שער ברירת המחדל רק לתנועת IPv4. לא מוגדר ממשק ברירת מחדל לתנועת IPv6.

הגדרת רשתות IPv4 משניות באשכולות IPv6 עם מחסנית אחת

כדי להגדיר רשתות IPv4 משניות באשכול IPv6 עם מחסנית אחת:

1. יצירת האשכול: כשיוצרים את אשכול ה-IPv6 במחסנית יחידה, מוסיפים את הדגל --enable-multi-networking:

   • באשכולות Autopilot:

     gcloud container clusters create-auto CLUSTER_NAME \
         --enable-dataplane-v2 \
         --cluster-dns=clouddns \
         --enable-multi-networking \
         --network=NETWORK_NAME \
         --subnetwork=NODE_SUBNET_NAME \
         --private-endpoint-subnetwork=PSC_SUBNET_NAME \
         --location=COMPUTE_LOCATION
     

   • באשכולות רגילים:

     gcloud container clusters create CLUSTER_NAME \
         --enable-dataplane-v2 \
         --cluster-dns=clouddns \
         --stack-type=ipv6 \
         --enable-multi-networking \
         --network=NETWORK_NAME \
         --subnetwork=NODE_SUBNET_NAME \
         --private-endpoint-subnetwork=PSC_SUBNET_NAME \
         --location=COMPUTE_LOCATION
     

2. יוצרים את המשאבים Network ו-GKENetworkParamSet: מגדירים את המשאבים GKENetworkParamSet ו-Network שמפנים לרשת ה-VPC ולרשת המשנה המשניות של IPv4, כמו שמתואר במאמר הגדרת רשת VPC של Layer 3.

3. הקצאת מאגרי צמתים:

   • באשכולות Autopilot ובאשכולות רגילים עם צמתים מנוהלים, GKE מקצה באופן אוטומטי מאגרי צמתים עם הממשקים המשניים הנדרשים כשמתזמנים Pod שמפנה לרשת.

   • באשכולות רגילים עם מאגרי צמתים רגילים, יוצרים מאגר צמתים עם הדגל --additional-pod-network שמפנה לרשת המשנית:

     gcloud container node-pools create POOL_NAME \
         --cluster=CLUSTER_NAME \
         --additional-pod-network=subnetwork=SECONDARY_SUBNET_NAME \
         --location=COMPUTE_LOCATION
     

4. פריסת Pods עם הערות רשת: מפנים גם לרשת IPv6 הראשית (default) וגם לרשת IPv4 המשנית במניפסט של ה-Pod:

   apiVersion: v1
   kind: Pod
   metadata:
     name: ipv6-ipv4-multinetwork-pod
     annotations:
       networking.gke.io/default-interface: 'eth1'
       networking.gke.io/interfaces: |
         [
           {"interfaceName":"eth0","network":"default"},
           {"interfaceName":"eth1","network":"secondary-ipv4-net"}
         ]
   spec:
     containers:
     - name: workload
       image: busybox
       command: ["sleep", "3600"]
   

   בהגדרה הזו, הממשק eth0 מקבל כתובת IPv6 מטווח ה-CIDR של Pod ב-IPv6 שמוגדר כברירת מחדל באשכול, והממשק eth1 מקבל כתובת IPv4 מהרשת secondary-ipv4-net. ההערה networking.gke.io/default-interface: 'eth1' מגדירה את הממשק eth1 כממשק ברירת המחדל לתעבורת נתונים יוצאת (egress) של IPv4.

המאמרים הבאים

• איך יוצרים אשכולות שמותאמים ל-VPC
• יצירה וניהול של אשכולות IPv6 עם מחסנית אחת
• Codelabs
• סרטון הדגמה