הגדרה של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי עם קצוות עורפיים של קבוצת מופעי מכונה של VM

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

לחצו על תראו לי איך כדי לקרוא הסבר מפורט על המשימה ישירות במסוף Google Cloud :

תראו לי איך

הרשאות

כדי לפעול לפי המדריך הזה, צריך ליצור מופעים ולשנות רשת בפרויקט. צריכות להיות לכם הרשאות בעלים או עריכה בפרויקט, או שיוקצו לכם כל תפקידי ה-IAM הבאים ב-Compute Engine:

משימה התפקיד הנדרש
יצירת רשתות, רשתות משנה ורכיבים של מאזן עומסים אדמין ברשת Compute
(roles/compute.networkAdmin)
הוספה והסרה של כללים לחומת האש אדמין לענייני אבטחה ב-Compute
(roles/compute.securityAdmin)
יצירת מופעים אדמין מכונות של Compute
(roles/compute.instanceAdmin)

מידע נוסף זמין במדריכים הבאים:

הגדרת מאזן עומסים עם רשתות משנה ושרתי בק-אנד מסוג IPv4 בלבד

במדריך הזה מוסבר איך להגדיר ולבדוק מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי. בשלבים שבקטע הזה מוסבר איך להגדיר את הדברים הבאים:

  1. דוגמה לשימוש ברשת VPC במצב מותאם אישית בשם lb-network.
  2. תת-רשת single-stack (הערך של stack-type מוגדר ל-IPv4), שנדרשת לתנועת נתונים ב-IPv4. כשיוצרים רשת משנה עם מחסנית אחת ברשת VPC במצב מותאם אישית, בוחרים טווח של רשת משנה IPv4 לרשת המשנה.
  3. כללי חומת אש שמאפשרים חיבורים נכנסים למכונות וירטואליות (VM) של שרתים עורפיים.
  4. קבוצת המכונות העורפיות, שנמצאת באזור ובתת-הרשת הבאים בדוגמה הזו:
    • אזור: us-west1
    • תת-רשת: lb-subnet, עם טווח כתובות IPv4 ראשי 10.1.2.0/24.
  5. ארבע מכונות וירטואליות בבק-אנד: שתי מכונות וירטואליות בקבוצת מכונות לא מנוהלת בתחום us-west1-a ושתי מכונות וירטואליות בקבוצת מכונות לא מנוהלת בתחום us-west1-c. כדי להדגים גישה גלובלית, בדוגמה הזו נוצרת מכונת VM שנייה של לקוח לבדיקה באזור ובתת-רשת שונים:
    • אזור: europe-west1
    • רשת משנה: europe-subnet, עם טווח כתובות IP ראשי 10.3.4.0/24
  6. מכונת VM של לקוח אחת לבדיקת חיבורים.
  7. הרכיבים הבאים של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי:
    • בדיקת תקינות של שירות הקצה העורפי.
    • שירות פנימי לקצה עורפי באזור us-west1 לניהול חלוקת החיבורים לשתי קבוצות של מופעי מכונה אזוריים.
    • כלל העברה פנימי וכתובת IP פנימית לחלק הקדמי של מאזן העומסים.

הארכיטקטורה של הדוגמה הזו נראית כך:

דוגמה להגדרה של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי.
דוגמה להגדרה של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי (לוחצים כדי להגדיל).

הגדרת רשת, אזור ורשת משנה

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

המסוף

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

    מעבר לרשתות VPC

  2. לוחצים על יצירת רשת VPC.

  3. בשדה Name (שם), מזינים lb-network.

  4. בקטע Subnets (רשתות משנה), מבצעים את הפעולות הבאות:

    1. מגדירים את מצב יצירת רשתות משנה לבהתאמה אישית.
    2. בקטע New subnet (רשת משנה חדשה), מזינים את הפרטים הבאים:
      • Name (שם): lb-subnet
      • אזור: us-west1
      • סוג מחסנית פרוטוקולי IP: IPv4 (מחסנית יחידה)
      • טווח כתובות IP: 10.1.2.0/24
    3. לוחצים על סיום.
    4. לוחצים על הוספת רשת משנה ומזינים את הפרטים הבאים:
      • Name (שם): europe-subnet
      • אזור: europe-west1
      • סוג מחסנית פרוטוקולי IP: IPv4 (מחסנית יחידה)
      • טווח כתובות IP: 10.3.4.0/24
    5. לוחצים על סיום.

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

gcloud

  1. יוצרים את רשת ה-VPC המותאמת אישית:

    gcloud compute networks create lb-network --subnet-mode=custom

  2. ברשת lb-network, יוצרים רשת משנה לשרתי קצה באזור us-west1:

    gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1

  3. ברשת lb-network, יוצרים רשת משנה נוספת לבדיקת גישה גלובלית באזור europe-west1:

    gcloud compute networks subnets create europe-subnet \
    --network=lb-network \
    --range=10.3.4.0/24 \
    --region=europe-west1

API

שולחים בקשת POST אל ה-method‏ networks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

שולחים שתי בקשות POST אל ה-method‏ subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.0/24",
  "privateIpGoogleAccess": false
}

הגדרת כללים לחומת אש

בדוגמה הזו נעשה שימוש בכללים הבאים של חומת האש:

  • ‫fw-allow-lb-access: כלל כניסה (ingress) שחל על כל היעדים ברשת ה-VPC, ומאפשר תעבורה ממקורות בטווחים 10.1.2.0/24 ו-10.3.4.0/24. הכלל הזה מאפשר תנועה נכנסת מכל לקוח שנמצא באחת משתי רשתות המשנה. בהמשך תוכלו להגדיר ולבדוק גישה גלובלית.

  • ‫fw-allow-ssh: כלל תעבורת נתונים נכנסת (ingress) שחל על המכונות שמתבצע עליהן איזון עומסים, שמאפשר קישוריות SSH נכנסת ביציאה 22 ב-TCP מכל כתובת. אתם יכולים לבחור טווח IP של מקור מוגבל יותר לכלל הזה. לדוגמה, אתם יכולים לציין רק את טווחי ה-IP של המערכת שממנה תפעילו סשנים של SSH. בדוגמה הזו נעשה שימוש בתג היעד allow-ssh כדי לזהות את מכונות ה-VM שאליהן התג צריך להתייחס.

  • ‫fw-allow-health-check: כלל כניסה שחל על המופעים שעוברים איזון עומסים, שמאפשר תעבורה ממערכות בדיקת תקינות ( Google Cloud , ‏ 130.211.0.0/22 ו-35.191.0.0/16). בדוגמה הזו נעשה שימוש בתג היעד allow-health-check כדי לזהות את המופעים שבהם הכלל צריך לחול.

בלי כללי חומת האש האלה, הכלל default deny ingress חוסם תנועה נכנסת למופעי ה-Backend.

המסוף

  1. נכנסים לדף Firewall policies במסוף Google Cloud .

    לדף Firewall policies

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

    • Name (שם): fw-allow-lb-access
    • רשת: lb-network
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: כל המופעים ברשת
    • מסנן מקור: טווחים של IPv4
    • טווחים של כתובות IPv4 של המקור: 10.1.2.0/24
    • פרוטוקולים ויציאות: אישור הכול

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

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

    • Name (שם): fw-allow-ssh
    • רשת: lb-network
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-ssh
    • מסנן מקור: טווחים של IPv4
    • טווחים של כתובות IPv4 של המקור: 0.0.0.0/0
    • פרוטוקולים ויציאות: בוחרים באפשרות פרוטוקולים ויציאות שצוינו, מסמנים את תיבת הסימון TCP ומזינים 22 ביציאות.

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

  6. כדי לאפשר Google Cloud בדיקות תקינות, לוחצים על יצירת כלל חומת אש בפעם השלישית ומזינים את הפרטים הבאים:

    • Name (שם): fw-allow-health-check
    • רשת: lb-network
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-health-check
    • מסנן מקור: טווחים של IPv4
    • טווחי IPv4 של המקור: 130.211.0.0/22 ו-35.191.0.0/16
    • פרוטוקולים ויציאות: אישור הכול

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

gcloud

  1. יוצרים את כלל חומת האש fw-allow-lb-access כדי לאפשר תקשורת מתוך תת-הרשת:

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24,10.3.4.0/24 \
    --rules=tcp,udp,icmp

  2. יוצרים את כלל חומת האש fw-allow-ssh כדי לאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh. אם לא מציינים את source-ranges,‏Google Cloud מפרש את הכלל כאילו הוא מתייחס לכל מקור.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  3. יוצרים את הכלל fw-allow-health-check כדי לאפשר Google Cloudבדיקות תקינות.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --rules=tcp,udp,icmp

API

כדי ליצור את הכלל של חומת האש fw-allow-lb-access, שולחים בקשת POST אל ה-method‏ firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-lb-access",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

כדי ליצור את הכלל של חומת האש fw-allow-ssh, שולחים בקשת POST אל ה-method‏ firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-ssh",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

כדי ליצור את הכלל של חומת האש fw-allow-health-check, שולחים בקשת POST אל ה-method‏ firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-health-check",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "allow-health-check"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

יצירת מכונות וירטואליות בעורף וקבוצות של מופעים

בדוגמה הזו יש שתי קבוצות של מופעי מכונה לא מנוהלים, ולכל אחת מהן יש שני מכונות וירטואליות של קצה עורפי (שרת). כדי להדגים את האופי האזורי של מאזני עומסי רשת פנימיים להעברת סיגנל ללא שינוי, שתי קבוצות המופעים ממוקמות באזורים נפרדים, us-west1-a ו-us-west1-c.

  • קבוצת המופעים ig-a מכילה את שתי המכונות הווירטואליות האלה:
    • vm-a1
    • vm-a2
  • קבוצת המופעים ig-c מכילה את שתי המכונות הווירטואליות האלה:
    • vm-c1
    • vm-c2

התנועה לכל ארבעת מכונות ה-VM בקצה העורפי מאוזנת.

כדי לתמוך בדוגמה הזו ובאפשרויות ההגדרה הנוספות, כל אחת מארבע המכונות הווירטואליות מריצה שרת אינטרנט של Apache שמקשיב ליציאות ה-TCP הבאות: 80,‏ 8008,‏ 8080,‏ 8088,‏ 443 ו-8443.

לכל מכונה וירטואלית מוקצית כתובת IP פנימית בפורמט lb-subnet וכתובת IP חיצונית (ציבורית) זמנית. אפשר להסיר את כתובות ה-IP החיצוניות בהמשך.

לא נדרשות כתובות IP חיצוניות למכונות הווירטואליות של ה-Backend, אבל הן שימושיות בדוגמה הזו כי הן מאפשרות למכונות הווירטואליות של ה-Backend להוריד את Apache מהאינטרנט, והן יכולות להתחבר באמצעות SSH.

כברירת מחדל, Apache מוגדר להתחבר לכל כתובת IP. מאזני עומסי רשת פנימיים להעברת סיגנל ללא שינוי מעבירים מנות תוך שמירה על כתובת ה-IP של היעד. מוודאים שתוכנת השרת שפועלת במכונות הווירטואליות של הקצה העורפי מאזינה לכתובת ה-IP של כלל ההעברה הפנימי של מאזן העומסים. אם מגדירים כמה כללי העברה פנימיים, צריך לוודא שהתוכנה מאזינה לכתובת ה-IP הפנימית שמשויכת לכל אחד מהם. כתובת ה-IP של היעד של חבילת נתונים שמועברת למכונה וירטואלית (VM) בקצה העורפי על ידי מאזן עומסי רשת פנימי מסוג העברת סיגנל ללא שינוי היא כתובת ה-IP הפנימית של כלל ההעברה.

כדי לפשט את ההוראות, מכונות ה-VM של ה-Backend פועלות ב-Debian GNU/Linux 12.

המסוף

יצירת מכונות וירטואליות של קצה עורפי

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. חוזרים על שלבים 3 עד 8 לכל מכונה וירטואלית, ומשתמשים בשילובים הבאים של שם ואזור.

    • שם: vm-a1, אזור: us-west1-a
    • שם: vm-a2, אזור: us-west1-a
    • שם: vm-c1, אזור: us-west1-c
    • שם: vm-c2, אזור: us-west1-c

  3. לוחצים על Create instance.

  4. מגדירים את השם כמו שמופיע בשלב 2.

  5. בשדה Region, בוחרים us-west1, ובשדה Zone, בוחרים אזור כמו שמוסבר בשלב 2.

  6. בקטע Boot disk מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ מסומנת באפשרויות של דיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

  7. לוחצים על אפשרויות מתקדמות.

  8. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-allow-health-check.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network
      • Subnet: lb-subnet
      • סוג מחסנית פרוטוקולי IP: IPv4 (מחסנית יחידה)
      • כתובת IPv4 פנימית ראשית: זמנית (אוטומטית)
      • כתובת IPv4 חיצונית: זמנית

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

    
#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

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

יצירת קבוצות של מכונות וירטואליות

  1. נכנסים לדף Instance groups במסוף Google Cloud .

    כניסה לדף Instance groups

  2. כדי ליצור שתי קבוצות של מכונות וירטואליות לא מנוהלות, שבכל אחת מהן יש שתי מכונות וירטואליות, חוזרים על השלבים הבאים ומשתמשים בשילובים האלה.

    • שם קבוצת המופעים: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
    • שם קבוצת המופעים: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

  3. לוחצים על יצירת קבוצת מופעים.

  4. לוחצים על קבוצת מופעים חדשה לא מנוהלת.

  5. מגדירים את השם כמו שמוסבר בשלב 2.

  6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שמוסבר בשלב 2.

  7. בקטע רשת, בוחרים באפשרות lb-network.

  8. בשדה Subnetwork, בוחרים באפשרות lb-subnet.

  9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמוסבר בשלב 2.

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

gcloud

  1. כדי ליצור את ארבע מכונות ה-VM, מריצים את הפקודה הבאה ארבע פעמים, ומשתמשים בארבעת השילובים האלה עבור [VM-NAME] ו-[ZONE]. תוכן הסקריפט זהה בכל ארבע המכונות הווירטואליות.

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c
    • VM-NAME: vm-c2, ZONE: us-west1-c
      gcloud compute instances create VM-NAME \
      --zone=ZONE \
      --image-family=debian-12 \
      --image-project=debian-cloud \
      --tags=allow-ssh,allow-health-check \
      --subnet=lb-subnet \
      --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. יוצרים את שתי הקבוצות של מופעי מכונה לא מנוהלים בכל אזור:

    gcloud compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. מוסיפים את המכונות הווירטואליות לקבוצות המופעים המתאימות:

    gcloud compute instance-groups unmanaged add-instances ig-a \
    --zone=us-west1-a \
    --instances=vm-a1,vm-a2
gcloud compute instance-groups unmanaged add-instances ig-c \
    --zone=us-west1-c \
    --instances=vm-c1,vm-c2

API

למכונות הווירטואליות, משתמשים בשמות ובאזורים הבאים:

  • VM-NAME: vm-a1, ZONE: us-west1-a
  • VM-NAME: vm-a2, ZONE: us-west1-a
  • VM-NAME: vm-c1, ZONE: us-west1-c
  • VM-NAME: vm-c2, ZONE: us-west1-c

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

gcloud compute images list \
 --filter="family=debian-12"

יוצרים ארבע מכונות וירטואליות (VM) בעורף על ידי שליחת ארבע בקשות POST ל-method‏ instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

כדי ליצור שתי קבוצות של מופעי מכונה, שולחים בקשת POST אל ה-method‏ instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

כדי להוסיף מכונות לכל קבוצת מכונות, שולחים בקשת POST אל ה-method‏ instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

הגדרת רכיבים של מאזן עומסים

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

  • בדיקת תקינות. בדוגמה הזו, משתמשים בבדיקת תקינות של HTTP שבודקת קוד סטטוס של HTTP 200 OK. מידע נוסף זמין בקטע בדיקת תקינות.

  • שירות לקצה העורפי. מכיוון שצריך להעביר תנועת HTTP דרך מאזן העומסים הפנימי, צריך להשתמש ב-TCP ולא ב-UDP.

  • כלל העברה. בדוגמה הזו נוצר כלל העברה פנימי יחיד.

  • כתובת IP פנימית. בדוגמה הזו, מציינים כתובת IP פנימית, 10.1.2.99, כשיוצרים את כלל ההעברה.

המסוף

התחלת ההגדרה

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף Load balancing

  2. לוחצים על Create load balancer (יצירת מאזן עומסים).
  3. בקטע Type of load balancer (סוג מאזן העומסים), בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL) (מאזן עומסים ברשת (TCP/UDP/SSL)) ולוחצים על Next (הבא).
  4. בקטע Proxy or passthrough (פרוקסי או העברה), בוחרים באפשרות Passthrough load balancer (מאזן עומסים להעברה) ולוחצים על Next (הבא).
  5. בקטע גלוי לכולם או פנימי, בוחרים באפשרות פנימי ולוחצים על הבא.
  6. לוחצים על Configure (הגדרה).

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer (יצירת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי), מזינים את הפרטים הבאים:

  • שם של מאזן עומסים: be-ilb
  • אזור: us-west1
  • רשת: lb-network

הגדרת הקצוות העורפיים

  1. לוחצים על Backend configuration.

  2. ברשימה בדיקת תקינות, לוחצים על יצירת בדיקת תקינות ומזינים את הפרטים הבאים.

    • שם: hc-http-80
    • פרוטוקול: HTTP
    • יציאה: 80
    • פרוטוקול proxy: ללא
    • בקשה: /

    שימו לב: כשמשתמשים במסוף Google Cloud כדי ליצור מאזן עומסים, בדיקת התקינות היא גלובלית. אם רוצים ליצור בדיקת תקינות אזורית, משתמשים ב-gcloud או ב-API.

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

  4. כדי לטפל בתנועה של IPv4 בלבד, בקטע New Backend, בשדה IP stack type, בוחרים באפשרות IPv4 (single-stack).

  5. ברשימה Instance group, בוחרים את קבוצת המכונות ig-c ולוחצים על Done.

  6. לוחצים על הוספת קצה עורפי וחוזרים על השלב כדי להוסיף את קבוצת המופעים ig-a.

  7. לפני שממשיכים, מוודאים שלצד הגדרות ה-Backend מופיע סימן וי כחול.

הגדרת הקצה הקדמי

  1. לוחצים על Frontend configuration.
  2. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
    1. בשדה Name (שם), מזינים fr-ilb.
    2. בשדה רשת משנה, בוחרים באפשרות lb-subnet.
    3. בקטע Internal IP purpose, ברשימה IP address, בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve.
      • שם: ip-ilb
      • ‫IP version: ‏IPv4
      • כתובת IP סטטית: אני רוצה לבחור
      • כתובת IP מותאמת אישית: 10.1.2.99
    4. בקטע יציאות, בוחרים באפשרות כמה ואז בשדה מספרי יציאות מזינים 80,8008,8080 ו-8088.
    5. לפני שממשיכים, מוודאים שלצד Frontend configuration מופיע סימן וי כחול.

בדיקת ההגדרות האישיות

  1. לוחצים על Review and finalize.
  2. בודקים את הגדרות ההגדרה של מאזן העומסים.
  3. אופציונלי: לוחצים על Equivalent code (קוד מקביל) כדי לראות את בקשת API בארכיטקטורת REST שתשמש ליצירת מאזן העומסים.
  4. לוחצים על יצירה.

gcloud

  1. יוצרים בדיקת תקינות חדשה של HTTP ברמה האזורית כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

    gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. יוצרים את שירות הקצה העורפי לתנועת HTTP:

    gcloud compute backend-services create be-ilb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. מוסיפים את שתי קבוצות המופעים לשירות ה-Backend:

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a
gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. יוצרים כלל העברה לשירות לקצה העורפי. כשיוצרים את כלל ההעברה, מציינים 10.1.2.99 לכתובת ה-IP הפנימית ברשת המשנה.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

כדי ליצור את בדיקת תקינות, שולחים בקשת POST אל ה-method‏ regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

כדי ליצור את השירות לקצה עורפי אזורי, שולחים בקשת POST אל ה-method‏ regionBackendServices.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

כדי ליצור את כלל ההעברה, שולחים בקשת POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

בדיקת מאזן העומסים

בבדיקות האלה מוסבר איך לאמת את ההגדרה של מאזן העומסים ואיך ללמוד על ההתנהגות הצפויה שלו.

יצירת מכונה וירטואלית של לקוח

בדוגמה הזו נוצרת מכונה וירטואלית של לקוח (vm-client) באותו אזור שבו נמצאות המכונות הווירטואליות של השרת (בק-אנד). הלקוח משמש לאימות ההגדרה של מאזן העומסים ולהדגמת ההתנהגות הצפויה כפי שמתואר בקטע בדיקה.

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create instance.

  3. בשדה Name (שם), מזינים vm-client.

  4. בשדה אזור, בוחרים באפשרות us-west1.

  5. בשדה Zone, בוחרים באפשרות us-west1-a.

  6. לוחצים על אפשרויות מתקדמות.

  7. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים allow-ssh.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network
      • Subnet: lb-subnet

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

gcloud

המכונה הווירטואלית של הלקוח יכולה להיות בכל אזור באותו אזור שבו נמצא מאזן העומסים, והיא יכולה להשתמש בכל רשת משנה באותו אזור. בדוגמה הזו, הלקוח נמצא באזור us-west1-a והוא משתמש באותה רשת משנה כמו המכונות הווירטואליות של הבק-אנד.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

שולחים בקשת POST אל ה-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

בדיקת החיבור ממכונה וירטואלית של לקוח

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

  1. מתחברים למופע ה-VM של הלקוח.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. שולחים בקשת אינטרנט למאזן העומסים באמצעות curl כדי ליצור קשר עם כתובת ה-IP שלו. חוזרים על הבקשה כדי לראות שהתשובות מגיעות ממכונות וירטואליות שונות בעורף. שם המכונה הווירטואלית שמייצרת את התגובה מוצג בטקסט בתגובת ה-HTML, בהתאם לתוכן של /var/www/html/index.html בכל מכונה וירטואלית של השרת העורפי. לדוגמה, תשובות צפויות נראות כך: Page served from: vm-a1 ו-Page served from: vm-a2.

    curl http://10.1.2.99

    כלל ההעברה מוגדר להעברת נתונים ביציאות 80, 8008, 8080 ו-8088. כדי לשלוח תנועה ליציאות האחרות האלה, מוסיפים נקודתיים (:) ואת מספר היציאה אחרי כתובת ה-IP, כך:

    curl http://10.1.2.99:8008

    אם מוסיפים תווית שירות לכלל ההעברה הפנימית, אפשר להשתמש ב-DNS פנימי כדי ליצור קשר עם מאזן העומסים באמצעות שם השירות שלו.

    curl http://web-test.fr-ilb.il4.us-west1.lb.PROJECT_ID.internal

ביצוע פינג לכתובת ה-IP של מאזן העומסים

הבדיקה הזו מדגימה התנהגות צפויה: אי אפשר לבצע פינג לכתובת ה-IP של מאזן העומסים. הסיבה לכך היא שמאזני עומסי רשת פנימיים להעברת סיגנל ללא שינוי מיושמים בתכנות של רשת וירטואלית – הם לא מכשירים נפרדים.

  1. מתחברים למופע ה-VM של הלקוח.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. מנסים לשלוח פינג לכתובת ה-IP של מאזן העומסים. שימו לב שלא מתקבלת תשובה, ושהפקודה ping מגיעה לזמן קצוב לתפוגה אחרי 10 שניות בדוגמה הזו.

    timeout 10 ping 10.1.2.99

שליחת בקשות ממכונות וירטואליות עם איזון עומסים

הבדיקה הזו מדגימה שכאשר מכונת VM של בק-אנד שולחת חבילות לכתובת ה-IP של כלל ההעברה של מאזן העומסים שלה, הבקשות האלה מנותבות חזרה אל עצמה. זה קורה ללא קשר למצב בדיקת התקינות של המכונה הווירטואלית בעורף.

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

מכיוון שהנתיב המקומי הזה נמצא בתוך המכונה הווירטואלית עצמה (ולא בנתיב ברשת ה-VPC), חבילות שנשלחות לכתובת ה-IP של מאזן העומסים לא מעובדות על ידי רשת ה-VPC. במקום זאת, מנות שנשלחות לכתובת ה-IP של איזון העומסים נשארות במערכת ההפעלה של המכונה הווירטואלית.

  1. מתחברים למכונת VM של בק-אנד, כמו vm-a1:

    gcloud compute ssh vm-a1 --zone=us-west1-a

  2. שולחים בקשת אינטרנט למאזן העומסים (לפי כתובת IP או שם שירות) באמצעות curl. התשובה מגיעה מאותה מכונה וירטואלית בעורף המערכת ששולחת את הבקשה. תשובות חוזרות ונשנות לבקשות זהות. התגובה הצפויה כשבודקים מ-vm-a1 היא תמיד Page served from: vm-a1.

    curl http://10.1.2.99

  3. בודקים את טבלת הניתוב המקומית ומחפשים יעד שתואם לכתובת ה-IP של מאזן העומסים עצמו, 10.1.2.99. הנתיב הזה הוא חלק חיוני במאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי, אבל הוא גם מדגים למה בקשה ממכונה וירטואלית מאחורי מאזן העומסים תמיד מקבלת תגובה מאותה מכונה וירטואלית.

    ip route show table local | grep 10.1.2.99

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

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

הגדרת מאזן עומסים עם רשתות משנה וקצוות עורפיים בתצורת dual-stack

במאמר הזה מוסבר איך להגדיר ולבדוק מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שתומך בתנועת IPv4 ובתנועת IPv6. בשלבים שבקטע הזה מוסבר איך להגדיר את הפריטים הבאים:

  1. בדוגמה שבדף הזה נעשה שימוש ברשת VPC במצב מותאם אישית בשם lb-network-dual-stack. תנועה של IPv6 דורשת רשת משנה במצב מותאם אישית.
  2. תת-רשת dual-stack (stack-type מוגדר ל-IPV4_IPV6), שנדרשת לתנועה ב-IPv6. כשיוצרים רשת משנה עם פרוטוקול כפול ברשת VPC במצב מותאם אישית, בוחרים סוג גישה ל-IPv6 עבור רשת המשנה. בדוגמה הזו, הגדרנו את הפרמטר ipv6-access-type של רשת המשנה ל-INTERNAL. המשמעות היא שאפשר להקצות למכונות וירטואליות חדשות ברשת המשנה הזו גם כתובות IPv4 פנימיות וגם כתובות IPv6 פנימיות. הוראות מפורטות זמינות במאמר בנושא הוספת רשת משנה עם תמיכה ב-IPv4 ו-IPv6 במסמכי ה-VPC.
  3. כללי חומת אש שמאפשרים חיבורים נכנסים למכונות וירטואליות של שרתים עורפיים.
  4. קבוצת המכונות העורפיות, שנמצאת באזור ובתת-הרשת הבאים בדוגמה הזו:
    • אזור: us-west1
    • תת-רשת: lb-subnet, עם טווח כתובות IPv4 ראשי 10.1.2.0/24. אתם בוחרים איזה טווח כתובות IPv4 להגדיר בתת-הרשת, אבל טווח כתובות ה-IPv6 מוקצה באופן אוטומטי. ‫Google מספקת בלוק CIDR של IPv6 בגודל קבוע (/64).
  5. ארבע מכונות וירטואליות בבק-אנד עם תמיכה ב-dual-stack: שתי מכונות וירטואליות בקבוצת מכונות לא מנוהלת בתחום us-west1-a ושתי מכונות וירטואליות בקבוצת מכונות לא מנוהלת בתחום us-west1-c. כדי להדגים גישה גלובלית, בדוגמה הזו נוצרת מכונה וירטואלית שנייה של לקוח לבדיקה באזור וברשת משנה שונים:
    • אזור: europe-west1
    • רשת משנה: europe-subnet, עם טווח כתובות IP ראשי 10.3.4.0/24
  6. מכונת VM של לקוח אחת לבדיקת חיבורים.
  7. הרכיבים הבאים של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי:
    • בדיקת תקינות של שירות הקצה העורפי.
    • שירות פנימי לקצה עורפי באזור us-west1 לניהול חלוקת החיבורים לשתי קבוצות של מופעי מכונה אזוריים.
    • שני כללי העברה פנימיים לקצה הקדמי של מאזן העומסים.

התרשים הבא מציג את הארכיטקטורה של הדוגמה הזו:

רשת VPC עם תמיכה בשני פרוטוקולים עם שירות קצה עורפי לניהול חלוקת החיבורים לשתי קבוצות של מכונות באזורים שונים.
דוגמה להגדרה של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי (לוחצים כדי להגדיל).

הגדרת רשת, אזור ורשת משנה

מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שמתואר בדף הזה נוצר ברשת VPC במצב מותאם אישית בשם lb-network-dual-stack.

כדי להגדיר רשתות משנה עם טווחי IPv6 פנימיים, צריך להפעיל טווח IPv6 פנימי של ULA ברשת VPC. טווחים של רשתות משנה פנימיות של IPv6 מוקצים מתוך הטווח הזה.

המסוף

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

    מעבר לרשתות VPC

  2. לוחצים על יצירת רשת VPC.

  3. בשדה Name (שם), מזינים lb-network-dual-stack.

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

    1. בקטע Private IPv6 address settings (הגדרות של כתובות IPv6 פרטיות), בוחרים באפשרות Configure a ULA internal IPv6 range for this VPC Network (הגדרת טווח פנימי של כתובות IPv6 מסוג ULA לרשת ה-VPC הזו).
    2. בקטע הקצאת טווח פנימי של IPv6, בוחרים באפשרות אוטומטית או ידנית. אם בוחרים באפשרות Manually, צריך להזין טווח של /48 מתוך הטווח fd20::/20. אם הטווח נמצא בשימוש, תתבקשו לספק טווח אחר.

  5. בקטע Subnet creation mode (מצב יצירת רשת משנה), בוחרים באפשרות Custom (בהתאמה אישית).

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

    • Name (שם): lb-subnet
    • אזור: us-west1
    • סוג מחסנית IP: IPv4 ו-IPv6 (מחסנית כפולה)
    • טווח IPv4: 10.1.2.0/24.
    • סוג הגישה ל-IPv6: פנימי

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

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

    • Name (שם): europe-subnet
    • אזור: europe-west1
    • סוג מחסנית פרוטוקולי IP: IPv4 (מחסנית יחידה)
    • טווח כתובות IP: 10.3.4.0/24

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

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

gcloud

  1. כדי ליצור רשת VPC חדשה במצב מותאם אישית, מריצים את הפקודה gcloud compute networks create.

    כדי להגדיר טווחי IPv6 פנימיים בכל רשת משנה ברשת הזו, משתמשים בדגל --enable-ula-internal-ipv6. האפשרות הזו מקצה קידומת /48 ULA מתוך טווח fd20::/20 שמשמש את Google Cloud לטווחים פנימיים של רשתות משנה ב-IPv6. אם רוצים לבחור את טווח ה-IPv6‏ /48 שהוקצה, משתמשים בדגל --internal-ipv6-range כדי לציין טווח.

    gcloud compute networks create lb-network-dual-stack \
   --subnet-mode=custom \
   --enable-ula-internal-ipv6 \
   --internal-ipv6-range=ULA_IPV6_RANGE \
   --bgp-routing-mode=regional

    מחליפים את ULA_IPV6_RANGE בתחילית /48 מתוך טווח fd20::/20 שמשמש את Google לטווחים פנימיים של רשתות משנה ב-IPv6. אם לא משתמשים בדגל --internal-ipv6-range, Google בוחרת קידומת /48 לרשת, כמו fd20:bc7:9a1c::/48.

  2. ברשת NETWORK, יוצרים רשת משנה עבור שרתים עורפיים באזור us-west1 ורשת משנה נוספת לבדיקת גישה גלובלית באזור europe-west1.

    כדי ליצור את רשתות המשנה, מריצים את הפקודה gcloud compute networks subnets create.

    gcloud compute networks subnets create lb-subnet \
   --network=lb-network-dual-stack \
   --range=10.1.2.0/24 \
   --region=us-west1 \
   --stack-type=IPV4_IPV6 \
   --ipv6-access-type=INTERNAL

    gcloud compute networks subnets create europe-subnet \
   --network=lb-network-dual-stack \
   --range=10.3.4.0/24 \
   --region=europe-west1 \
   --stack-type=IPV4_IPV6 \
   --ipv6-access-type=INTERNAL

API

יוצרים רשת VPC חדשה במצב מותאם אישית.

כדי להגדיר טווחי IPv6 פנימיים ברשתות משנה ברשת הזו, מגדירים את enableUlaInternalIpv6 כ-true. באפשרות הזו מוקצה טווח /48 מתוך הטווח fd20::/20 שבו Google משתמשת לטווחים פנימיים של רשתות משנה IPv6. אם רוצים לבחור את טווח כתובות ה-IPv6 שיוקצה, צריך להשתמש גם בשדה internalIpv6Range כדי לציין טווח./48

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }

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

  • ‫PROJECT_ID: מזהה הפרויקט שבו נוצרה רשת ה-VPC.
  • ‫MTU: יחידת השידור המקסימלית של הרשת. הערך של MTU יכול להיות 1460 (ברירת מחדל) או 1500. לפני שמגדירים את ה-MTU ל-1500, כדאי לעיין בסקירה הכללית על יחידת השידור המקסימלית.
  • ‫ULA_IPV6_RANGE: קידומת /48 מתוך הטווח fd20::/20 שמשמש את Google לטווחים פנימיים של רשתות משנה ב-IPv6. אם לא תציינו ערך ל-internalIpv6Range, Google תבחר קידומת /48 לרשת.

  • ‫DYNAMIC_ROUTING_MODE: ‏global או regional כדי לשלוט בהתנהגות של פרסום ניתוב (route advertisement) של Cloud Routers ברשת. מידע נוסף זמין במאמר בנושא מצב ניתוב דינמי.

    מידע נוסף זמין במאמר בנושא השיטה networks.insert.

שולחים שתי בקשות POST אל ה-method‏ subnetworks.insert.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.3.4.0/24",
   "network": "lb-network-dual-stack",
   "name": "europe-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }

הגדרת כללים לחומת אש

בדוגמה הזו נעשה שימוש בכללים הבאים של חומת האש:

  • ‫fw-allow-lb-access: כלל תעבורה נכנסת שחל על כל היעדים ברשת ה-VPC, שמאפשר תעבורה ממקורות בטווחים 10.1.2.0/24 ו-10.3.4.0/24. הכלל הזה מאפשר תנועה נכנסת מכל לקוח שנמצא באחת משתי רשתות המשנה. בהמשך, תוכלו להגדיר ולבדוק גישה גלובלית.

  • ‫fw-allow-lb-access-ipv6: כלל תעבורה נכנסת (ingress) שחל על כל יעדי התעבורה ברשת ה-VPC, ומאפשר תעבורה ממקורות בטווח IPv6 שהוגדר ברשת המשנה. הכלל הזה מאפשר תנועה נכנסת של IPv6 מכל לקוח שנמצא באחת משתי רשתות המשנה. בהמשך, תוכלו להגדיר ולבדוק גישה גלובלית.

  • ‫fw-allow-ssh: כלל תעבורת נתונים נכנסת (ingress) שחל על המכונות שמתבצע עליהן איזון עומסים, שמאפשר קישוריות SSH נכנסת ביציאה 22 ב-TCP מכל כתובת. אתם יכולים לבחור טווח IP של מקור מגביל יותר לכלל הזה. לדוגמה, אתם יכולים לציין רק את טווחי ה-IP של המערכת שממנה אתם מפעילים סשנים של SSH. בדוגמה הזו נעשה שימוש בתג היעד allow-ssh כדי לזהות את מכונות ה-VM שאליהן התג צריך להתייחס.

  • ‫fw-allow-health-check: כלל כניסה שחל על המופעים שעוברים איזון עומסים, שמאפשר תעבורה ממערכות בדיקת תקינות ( Google Cloud , ‏ 130.211.0.0/22 ו-35.191.0.0/16). בדוגמה הזו נעשה שימוש בתג היעד allow-health-check כדי לזהות את המופעים שבהם הכלל צריך לחול.

  • ‫fw-allow-health-check-ipv6: כלל תעבורת נתונים נכנסת (ingress) שחל על המופעים שמתבצע איזון העומסים שלהם, שמאפשר תעבורת נתונים ממערכות בדיקת תקינות (2600:2d00:1:b029::/64) של Google Cloud . בדוגמה הזו נעשה שימוש בתג היעד allow-health-check-ipv6 כדי לזהות את המופעים שצריך להחיל עליהם את הכלל.

בלי כללי חומת האש האלה, הכלל default deny ingress חוסם תנועה נכנסת למופעי ה-Backend.

המסוף

  1. נכנסים לדף Firewall policies במסוף Google Cloud .

    לדף Firewall policies

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

    • Name (שם): fw-allow-lb-access
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: כל המופעים ברשת
    • מסנן מקור: טווחים של IPv4
    • טווחי IPv4 של המקור: 10.1.2.0/24 ו-10.3.4.0/24
    • פרוטוקולים ויציאות: אישור הכול

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

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

    • Name (שם): fw-allow-lb-access-ipv6
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: כל המופעים ברשת
    • מסנן מקור: טווחים של IPv6
    • טווחי IPv6 של המקור: IPV6_ADDRESS שהוקצו ב-lb-subnet
    • פרוטוקולים ויציאות: אישור הכול

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

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

    • Name (שם): fw-allow-ssh
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-ssh
    • מסנן מקור: טווחים של IPv4
    • טווחים של כתובות IPv4 של המקור: 0.0.0.0/0
    • פרוטוקולים ויציאות: בוחרים באפשרות פרוטוקולים ויציאות שצוינו, מסמנים את תיבת הסימון TCP ומזינים 22 ביציאות.

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

  8. כדי לאפשר בדיקות תקינות של Google Cloud IPv6, לוחצים שוב על יצירת כלל חומת אש ומזינים את הפרטים הבאים:

    • Name (שם): fw-allow-health-check-ipv6
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-health-check-ipv6
    • מסנן מקור: טווחים של IPv6
    • טווחים של כתובות IPv6 של המקור: 2600:2d00:1:b029::/64
    • פרוטוקולים ויציאות: אישור הכול

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

  10. כדי לאפשר בדיקות תקינות, לוחצים שוב על יצירת כלל חומת אש ומזינים את הפרטים הבאים: Google Cloud

    • Name (שם): fw-allow-health-check
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: תעבורת נתונים נכנסת (ingress)
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-health-check
    • מסנן מקור: טווחים של IPv4
    • טווחי IPv4 של המקור: 130.211.0.0/22 ו-35.191.0.0/16
    • פרוטוקולים ויציאות: אישור הכול

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

gcloud

  1. יוצרים את כלל חומת האש fw-allow-lb-access כדי לאפשר תקשורת עם תת-הרשת:

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24,10.3.4.0/24 \
    --rules=all

  2. יוצרים את כלל חומת האש fw-allow-lb-access-ipv6 כדי לאפשר תקשורת עם תת-הרשת:

    gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --source-ranges=IPV6_ADDRESS \
    --rules=all

    מחליפים את IPV6_ADDRESS בכתובת ה-IPv6 שהוקצתה ב-lb-subnet.

  3. יוצרים את כלל חומת האש fw-allow-ssh כדי לאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh. אם לא מציינים את source-ranges,‏Google Cloud מפרש את הכלל כאילו הוא מתייחס לכל מקור.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  4. יוצרים את כלל fw-allow-health-check-ipv6 כדי לאפשר בדיקות תקינות שלGoogle Cloud IPv6.

    gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check-ipv6 \
    --source-ranges=2600:2d00:1:b029::/64 \
    --rules=tcp,udp

  5. יוצרים את הכלל fw-allow-health-check כדי לאפשר Google Cloudבדיקות תקינות.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --rules=tcp,udp,icmp

API

  1. כדי ליצור את הכלל של חומת האש fw-allow-lb-access, שולחים בקשת POST אל ה-method‏ firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
"name": "fw-allow-lb-access",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "10.1.2.0/24", "10.3.4.0/24"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

  2. כדי ליצור את הכלל של חומת האש fw-allow-lb-access-ipv6, שולחים בקשת POST אל ה-method‏ firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-lb-access-ipv6",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

    מחליפים את IPV6_ADDRESS בכתובת IPv6 שהוקצתה ב-lb-subnet.

  3. כדי ליצור את הכלל של חומת האש fw-allow-ssh, שולחים בקשת POST אל ה-method‏ firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
"name": "fw-allow-ssh",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "0.0.0.0/0"
],
"targetTags": [
  "allow-ssh"
],
"allowed": [
 {
   "IPProtocol": "tcp",
   "ports": [
     "22"
   ]
 }
],
"direction": "INGRESS",
"logConfig": {
 "enable": false
},
"disabled": false
}

  4. כדי ליצור את הכלל של חומת האש fw-allow-health-check-ipv6, שולחים בקשת POST אל ה-method‏ firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
"name": "fw-allow-health-check-ipv6",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "2600:2d00:1:b029::/64"
],
"targetTags": [
  "allow-health-check-ipv6"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

  5. כדי ליצור את הכלל של חומת האש fw-allow-health-check, שולחים בקשת POST אל ה-method‏ firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
"name": "fw-allow-health-check",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "130.211.0.0/22",
  "35.191.0.0/16"
],
"targetTags": [
  "allow-health-check"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

יצירת מכונות וירטואליות בעורף וקבוצות של מופעים

בדוגמה הזו יש שתי קבוצות של מופעי מכונה לא מנוהלים, ולכל אחת מהן יש שני מכונות וירטואליות של קצה עורפי (שרת). כדי להדגים את האופי האזורי של מאזני עומסי רשת פנימיים להעברת סיגנל ללא שינוי, שתי קבוצות המופעים ממוקמות באזורים נפרדים, us-west1-a ו-us-west1-c.

  • קבוצת המופעים ig-a מכילה את שתי המכונות הווירטואליות האלה:
    • vm-a1
    • vm-a2
  • קבוצת המופעים ig-c מכילה את שתי המכונות הווירטואליות האלה:
    • vm-c1
    • vm-c2

התנועה לכל ארבעת מכונות ה-VM בקצה העורפי מאוזנת.

כדי לתמוך בדוגמה הזו ובאפשרויות ההגדרה הנוספות, כל אחת מארבע המכונות הווירטואליות מפעילה שרת אינטרנט של Apache שמקשיב ליציאות ה-TCP הבאות: 80,‏ 8008,‏ 8080,‏ 8088,‏ 443 ו-8443.

לכל מכונה וירטואלית מוקצית כתובת IP פנימית בפורמט lb-subnet וכתובת IP חיצונית (ציבורית) זמנית. אפשר להסיר את כתובות ה-IP החיצוניות בהמשך.

לא נדרשות כתובות IP חיצוניות למכונות הווירטואליות של ה-Backend, אבל הן שימושיות בדוגמה הזו כי הן מאפשרות למכונות הווירטואליות של ה-Backend להוריד את Apache מהאינטרנט, והן יכולות להתחבר באמצעות SSH.

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

מוודאים שתוכנת השרת שפועלת במכונות הווירטואליות של הקצה העורפי מאזינה לכתובת ה-IP של כלל ההעברה הפנימי של מאזן העומסים. אם מגדירים כמה כללי העברה פנימיים, צריך לוודא שהתוכנה מאזינה לכתובת ה-IP הפנימית שמשויכת לכל אחד מהם. כתובת ה-IP של היעד של חבילת נתונים שמועברת למכונה וירטואלית (VM) בקצה העורפי על ידי מאזן עומסי רשת פנימי מסוג העברת סיגנל ללא שינוי היא כתובת ה-IP הפנימית של כלל ההעברה.

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

כדי לפשט את ההוראות, מכונות ה-VM של ה-Backend פועלות ב-Debian GNU/Linux 12.

המסוף

יצירת מכונות וירטואליות של קצה עורפי

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. חוזרים על שלבים 3 עד 8 לכל מכונה וירטואלית, ומשתמשים בשילובים הבאים של שם ואזור.

    • שם: vm-a1, אזור: us-west1-a
    • שם: vm-a2, אזור: us-west1-a
    • שם: vm-c1, אזור: us-west1-c
    • שם: vm-c2, אזור: us-west1-c

  3. לוחצים על Create instance.

  4. מגדירים את השם כמו שמופיע בשלב 2.

  5. בשדה Region, בוחרים באפשרות us-west1 ובוחרים Zone כמו שמוסבר בשלב 2.

  6. בקטע Boot disk מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ מסומנת באפשרויות של דיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

  7. לוחצים על אפשרויות מתקדמות.

  8. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-allow-health-check-ipv6.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network-dual-stack
      • Subnet: lb-subnet
      • סוג מחסנית IP: IPv4 ו-IPv6 (מחסנית כפולה)
      • כתובת IPv4 פנימית ראשית: זמנית (אוטומטית)
      • כתובת IPv4 חיצונית: זמנית

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

      #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

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

יצירת קבוצות של מופעי מכונה

  1. נכנסים לדף Instance groups במסוף Google Cloud .

    כניסה לדף Instance groups

  2. כדי ליצור שתי קבוצות של מכונות וירטואליות לא מנוהלות, שבכל אחת מהן יש שתי מכונות וירטואליות, חוזרים על השלבים הבאים ומשתמשים בשילובים האלה.

    • שם קבוצת המופעים: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
    • שם קבוצת המופעים: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

  3. לוחצים על יצירת קבוצת מופעים.

  4. לוחצים על קבוצת מופעים חדשה לא מנוהלת.

  5. מגדירים את השם כמו שמוסבר בשלב 2.

  6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שמוסבר בשלב 2.

  7. בקטע רשת, בוחרים באפשרות lb-network-dual-stack.

  8. בשדה רשת משנה, בוחרים באפשרות lb-subnet.

  9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמוסבר בשלב 2.

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

gcloud

  1. כדי ליצור את ארבע המכונות הווירטואליות, מריצים את הפקודה gcloud compute instances create ארבע פעמים, ומשתמשים בארבעת השילובים האלה ל-[VM-NAME] ול-[ZONE]. תוכן הסקריפט זהה בכל ארבע המכונות הווירטואליות.

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c

    • VM-NAME: vm-c2, ZONE: us-west1-c

      gcloud compute instances create VM-NAME \
  --zone=ZONE \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --tags=allow-ssh,allow-health-check-ipv6 \
  --subnet=lb-subnet \
  --stack-type=IPV4_IPV6 \
  --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. יוצרים את שתי הקבוצות של מופעי מכונה לא מנוהלים בכל אזור:

    gcloud compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. מוסיפים את המכונות הווירטואליות לקבוצות המופעים המתאימות:

    gcloud compute instance-groups unmanaged add-instances ig-a \
    --zone=us-west1-a \
    --instances=vm-a1,vm-a2
gcloud compute instance-groups unmanaged add-instances ig-c \
    --zone=us-west1-c \
    --instances=vm-c1,vm-c2

api

למכונות הווירטואליות, משתמשים בשמות ובאזורים הבאים:

  • VM-NAME: vm-a1, ZONE: us-west1-a
  • VM-NAME: vm-a2, ZONE: us-west1-a
  • VM-NAME: vm-c1, ZONE: us-west1-c
  • VM-NAME: vm-c2, ZONE: us-west1-c

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

gcloud compute images list \
 --filter="family=debian-12"

יוצרים ארבע מכונות וירטואליות (VM) בעורף על ידי שליחת ארבע בקשות POST ל-method‏ instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check-ipv6",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

כדי ליצור שתי קבוצות של מופעי מכונה, שולחים בקשת POST אל ה-method‏ instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

כדי להוסיף מכונות לכל קבוצת מכונות, שולחים בקשת POST אל ה-method‏ instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

הגדרת רכיבים של מאזן עומסים

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

  • בדיקת תקינות. בדוגמה הזו, משתמשים בבדיקת תקינות של HTTP שבודקת קוד מצב HTTP 200 OK. מידע נוסף זמין בקטע בנושא בדיקות תקינות בסקירה הכללית של מאזן עומסי רשת פנימי מסוג passthrough.

  • שירות לקצה העורפי. מכיוון שצריך להעביר תנועת HTTP דרך מאזן העומסים הפנימי, צריך להשתמש ב-TCP ולא ב-UDP.

  • כלל העברה. בדוגמה הזו נוצרים שני כללי העברה פנימיים לתנועת IPv4 ו-IPv6.

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

המסוף

התחלת ההגדרה

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף Load balancing

  2. לוחצים על Create load balancer (יצירת מאזן עומסים).
  3. בקטע Type of load balancer (סוג מאזן העומסים), בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL) (מאזן עומסים ברשת (TCP/UDP/SSL)) ולוחצים על Next (הבא).
  4. בקטע Proxy or passthrough (פרוקסי או העברה), בוחרים באפשרות Passthrough load balancer (מאזן עומסים להעברה) ולוחצים על Next (הבא).
  5. בקטע גלוי לכולם או פנימי, בוחרים באפשרות פנימי ולוחצים על הבא.
  6. לוחצים על Configure (הגדרה).

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer (יצירת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי), מזינים את הפרטים הבאים:

  • שם של מאזן עומסים: be-ilb
  • אזור: us-west1
  • רשת: lb-network-dual-stack

הגדרת הקצה העורפי

  1. לוחצים על Backend configuration.
  2. ברשימה בדיקת תקינות, לוחצים על יצירת בדיקת תקינות ומזינים את הפרטים הבאים:
    • Name (שם): hc-http-80
    • היקף: אזורי
    • Protocol: HTTP
    • יציאה: 80
    • פרוטוקול פרוקסי: NONE
    • בקשה: /
  3. לוחצים על יצירה.
  4. בקטע New Backend (קצה עורפי חדש), בשדה IP stack type (סוג ערימת IP), בוחרים באפשרות IPv4 and IPv6 (dual-stack) (IPv4 ו-IPv6 (ערימה כפולה)).
  5. בקטע Instance group, בוחרים את קבוצת המכונות ig-a ולוחצים על Done.
  6. לוחצים על הוספת קצה עורפי וחוזרים על השלב כדי להוסיף את קבוצת המופעים ig-c.
  7. מוודאים שמופיע סימן וי כחול לצד Backend configuration.

הגדרות הקצה הקדמי

  1. לוחצים על Frontend configuration. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
    1. בשדה Name (שם), מזינים fr-ilb-ipv6.
    2. כדי לטפל בתעבורת IPv6:
      1. בשביל IP version, בוחרים IPv6.
      2. בשדה Subnetwork, בוחרים באפשרות lb-subnet. טווח כתובות ה-IPv6 בכלל ההעברה הוא תמיד זמני.
      3. בשדה יציאות, בוחרים באפשרות כמה, ואז בשדה מספר יציאה מזינים 80,8008,8080,8088.
      4. לוחצים על סיום.
    3. כדי לטפל בתעבורת IPv4:
      1. לוחצים על Add frontend IP and port.
      2. בשדה Name (שם), מזינים fr-ilb.
      3. בשדה רשת משנה, בוחרים באפשרות lb-subnet.
      4. בקטע Internal IP purpose, ברשימה כתובת IP, בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve.
        • שם: ip-ilb
        • ‫IP version: ‏IPv4
        • כתובת IP סטטית: אני רוצה לבחור
        • כתובת IP מותאמת אישית: 10.1.2.99
      5. בקטע יציאות, בוחרים באפשרות כמה, ואז בשדה מספרי יציאות מזינים 80,8008,8080 ו-8088.
      6. לוחצים על סיום.
      7. לפני שממשיכים, מוודאים שלצד Frontend configuration מופיע סימן וי כחול.

בדיקת ההגדרות האישיות

  1. לוחצים על Review and finalize. בודקים את כל ההגדרות.
  2. אם ההגדרות נכונות, לוחצים על יצירה. יצירת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי נמשכת כמה דקות.

gcloud

  1. יוצרים בדיקת תקינות חדשה של HTTP ברמה האזורית כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

    gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. יוצרים את שירות הקצה העורפי לתנועת HTTP:

    gcloud compute backend-services create be-ilb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. מוסיפים את שתי קבוצות המופעים לשירות ה-Backend:

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a
gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. יוצרים שני כללי העברה לשירות לקצה העורפי. כשיוצרים את כלל ההעברה של IPv4, צריך לציין 10.1.2.99 לכתובת ה-IP הפנימית ברשת המשנה של כתובות IPv4.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

    gcloud compute forwarding-rules create fr-ilb-ipv6 \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --subnet=lb-subnet \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

api

כדי ליצור את בדיקת תקינות, שולחים בקשת POST אל ה-method‏ regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

כדי ליצור את השירות לקצה עורפי אזורי, שולחים בקשת POST אל ה-method‏ regionBackendServices.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

כדי ליצור את כלל ההעברה, שולחים בקשת POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-ipv6",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

כדי ליצור את כלל ההעברה, שולחים בקשת POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

בדיקת מאזן העומסים

כדי לבדוק את מאזן העומסים, יוצרים מכונת VM של לקוח באותו אזור שבו נמצא מאזן העומסים, ואז שולחים תעבורה מהלקוח למאזן העומסים.

יצירת מכונה וירטואלית של לקוח

בדוגמה הזו נוצרת מכונה וירטואלית של לקוח (vm-client) באותו אזור שבו נמצאות המכונות הווירטואליות של השרת (בק-אנד). הלקוח משמש לאימות ההגדרה של מאזן העומסים ולהדגמת ההתנהגות הצפויה כפי שמתואר בקטע בדיקה.

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create instance.

  3. בשדה Name (שם), מזינים vm-client.

  4. בשדה אזור, בוחרים באפשרות us-west1.

  5. בשדה Zone, בוחרים באפשרות us-west1-a.

  6. לוחצים על אפשרויות מתקדמות.

  7. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים allow-ssh.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network-dual-stack
      • Subnet: lb-subnet
      • סוג מחסנית IP: IPv4 ו-IPv6 (מחסנית כפולה)
      • כתובת IP פנימית ראשית: זמנית (אוטומטית)
      • כתובת IP חיצונית: זמנית
    3. לוחצים על סיום.

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

gcloud

המכונה הווירטואלית של הלקוח יכולה להיות בכל אזור באותו אזור שבו נמצא מאזן העומסים, והיא יכולה להשתמש בכל רשת משנה באותו אזור. בדוגמה הזו, הלקוח נמצא באזור us-west1-a והוא משתמש באותה רשת משנה כמו המכונות הווירטואליות של הבק-אנד.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

שולחים בקשת POST אל ה-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

בדיקת החיבור

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

  1. מתחברים למופע ה-VM של הלקוח.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. תאר את כלל ההעברה של IPv6‏ fr-ilb-ipv6. שימו לב לIPV6_ADDRESS בתיאור.

    gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1

  3. תאר את כלל ההעברה של IPv4‏ fr-ilb.

    gcloud compute forwarding-rules describe fr-ilb --region=us-west1

  4. מלקוחות עם קישוריות IPv6, מריצים את הפקודה הבאה:

    curl -m 10 -s http://IPV6_ADDRESS:80

    לדוגמה, אם כתובת ה-IPv6 שהוקצתה היא [fd20:1db0:b882:802:0:46:0:0/96]:80, הפקודה צריכה להיראות כך:

    curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80

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

    curl -m 10 -s http://10.1.2.99:80

    מחליפים את ה-placeholders בערכים תקינים:

    • ‫IPV6_ADDRESS היא כתובת ה-IPv6 הזמנית בכלל ההעברה fr-ilb-ipv6.

הגדרת מאזן עומסים עם רשתות משנה וקצה עורפי מסוג IPv6 בלבד

במאמר הזה מוסבר איך להגדיר ולבדוק מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שתומך רק בתנועת IPv6. בשלבים שבקטע הזה מוסבר איך להגדיר את הפריטים הבאים:

  1. רשת VPC במצב מותאם אישית בשם lb-network-ipv6-only. תנועת IPv6 דורשת תת-רשת במצב מותאם אישית.
  2. רשת משנה פנימית IPv6-only בשם lb-subnet-ipv6-only (stack-type מוגדר כ-IPV6_ONLY), שנדרשת לתנועה מסוג IPv6-only.
  3. כללי חומת אש שמאפשרים חיבורים נכנסים למכונות וירטואליות של שרתים עורפיים.
  4. קבוצת המופעים של ה-Backend, שנמצאת באזור וברשת המשנה הבאים בדוגמה הזו:
    • אזור: us-west1
    • תת-רשת: lb-subnet-ipv6-only טווח כתובות ה-IPv6 של תת-הרשת מוקצה באופן אוטומטי. ‫Google מספקת בלוק CIDR של IPv6 בגודל קבוע (/64).
  5. ארבע מכונות וירטואליות בבק-אנד עם IPv6 בלבד – שתי מכונות וירטואליות בקבוצת מופעים לא מנוהלת באזור us-west1-a ושתי מכונות וירטואליות בקבוצת מופעים לא מנוהלת באזור us-west1-c.
  6. שרת TCP של IPv6 במכונות הווירטואליות של העורף. השרת מאזין לחיבורים נכנסים בכתובת ה-IP הווירטואלית שצוינה בכלל ההעברה של מאזן העומסים ובממשק הרשת שצוין. השרת מקבל חיבורים נכנסים של לקוחות, שולח תגובה ואז סוגר את החיבור.
  7. מכונת VM של לקוח אחת לבדיקת חיבורים.
  8. הרכיבים הבאים של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי:
    • בדיקת תקינות של שירות הקצה העורפי
    • שירות קצה עורפי פנימי באזור us-west1 לניהול חלוקת החיבורים לשתי קבוצות של מופעים אזוריים
    • כלל העברה של IPv6

אפשר גם להגדיר מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי עם קצה עורפי פנימי של IPv6 בלבד באמצעות מכונת VM שמשמשת כשער NAT. מידע נוסף על ההגדרה הזו זמין במאמר בנושא הגדרת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי עם קצה עורפי פנימי מסוג IPv6 בלבד.

הגדרת רשת, אזור ורשת משנה

מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שמתואר בדף הזה נוצר ברשת VPC במצב מותאם אישית בשם lb-network-ipv6-only.

כדי להגדיר רשתות משנה עם טווחי IPv6 פנימיים, צריך להפעיל טווח IPv6 פנימי של ULA ברשת VPC. טווחים של רשתות משנה פנימיות של IPv6 מוקצים מתוך הטווח הזה.

בהמשך, בקטע Install an IPv6 TCP server on the backend VMs using a startup Bash script במסמך הזה, נעשה שימוש בטווח של רשת המשנה הפנימית של IPv6 כדי ליצור כלל ניתוב לניתוב תנועה מרשת המשנה של ה-VPC דרך השער וממשק הרשת שצוינו.

המסוף

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

    מעבר לרשתות VPC

  2. לוחצים על יצירת רשת VPC.

  3. בשדה Name (שם), מזינים lb-network-ipv6-only.

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

    1. בקטע Private IPv6 address settings (הגדרות של כתובות IPv6 פרטיות), בוחרים באפשרות Configure a ULA internal IPv6 range for this VPC Network (הגדרת טווח פנימי של כתובות IPv6 מסוג ULA לרשת ה-VPC הזו).
    2. בקטע הקצאת טווח פנימי של IPv6, בוחרים באפשרות אוטומטית או ידנית. אם בוחרים באפשרות Manually, צריך להזין טווח של /48 מתוך הטווח fd20::/20. אם הטווח כבר בשימוש, תתבקשו לספק טווח אחר.

  5. בקטע Subnet creation mode (מצב יצירת רשת משנה), בוחרים באפשרות Custom (בהתאמה אישית).

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

    • Name (שם): lb-subnet-ipv6-only
    • אזור: us-west1
    • סוג מחסנית IP: IPv6 (single-stack)
    • סוג הגישה ל-IPv6: פנימי

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

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

gcloud

  1. כדי ליצור רשת VPC חדשה במצב מותאם אישית, מריצים את הפקודה gcloud compute networks create.

    כדי להגדיר טווחים פנימיים של IPv6 בכל רשת משנה ברשת הזו, משתמשים בדגל --enable-ula-internal-ipv6.

    gcloud compute networks create lb-network-ipv6-only \
  --subnet-mode=custom \
  --enable-ula-internal-ipv6 \
  --bgp-routing-mode=regional

  2. מגדירים רשת משנה עם ipv6-access-type שמוגדר ל-INTERNAL. המשמעות היא שלמכונות הווירטואליות ברשת המשנה הזו יכולות להיות רק כתובות IPv6 פנימיות.כדי ליצור את רשת המשנה, מריצים את הפקודה gcloud compute networks subnets create.

    gcloud compute networks subnets create lb-subnet-ipv6-only \
  --network=lb-network-ipv6-only \
  --region=us-west1 \
  --stack-type=IPV6_ONLY \
  --ipv6-access-type=INTERNAL

הגדרת כללים לחומת אש

בדוגמה הזו נעשה שימוש בכללים הבאים של חומת האש:

  • ‫fw-allow-lb-access-ipv6-only: כלל כניסה שחל על כל היעדים ברשת ה-VPC, שמאפשר תנועה מכל מקורות ה-IPv6.

  • ‫fw-allow-ssh: כלל תעבורת נתונים נכנסת שחל על המכונות שמתבצע עליהן איזון עומסים, שמאפשר קישוריות SSH נכנסת ביציאת TCP‏ 22 מכל כתובת. אתם יכולים לבחור טווח IP של מקור מגביל יותר לכלל הזה. לדוגמה, אתם יכולים לציין רק את טווחי ה-IP של המערכת שממנה אתם מפעילים סשנים של SSH. בדוגמה הזו נעשה שימוש בתג היעד allow-ssh כדי לזהות את מכונות ה-VM שצריך להחיל עליהן את התג.

  • ‫fw-allow-health-check-ipv6-only: כלל כניסה שחל על המופעים שעוברים איזון עומסים, שמאפשר תעבורת נתונים ממערכות בדיקת תקינות (2600:2d00:1:b029::/64). בדוגמה הזו נעשה שימוש בתג היעד allow-health-check-ipv6 כדי לזהות את המופעים שצריך להחיל עליהם את הכלל. Google Cloud

בלי כללי חומת האש האלה, הכלל default deny ingress חוסם תנועה נכנסת למופעי ה-Backend.

המסוף

  1. נכנסים לדף Firewall policies במסוף Google Cloud .

    לדף Firewall policies

  2. כדי לאפשר תעבורה של רשת משנה ב-IPv6, לוחצים שוב על יצירת כלל חומת אש ומזינים את הפרטים הבאים:

    • Name (שם): fw-allow-lb-access-ipv6-only
    • רשת: lb-network-ipv6-only
    • עדיפות: 1000
    • כיוון התנועה: כניסה
    • פעולה במקרה של התאמה: אישור
    • יעדים: כל המופעים ברשת
    • מסנן מקור: טווחים של IPv6
    • טווחים של כתובות IPv6 של המקור: ::/0
    • פרוטוקולים ויציאות: אישור הכול

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

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

    • Name (שם): fw-allow-ssh
    • רשת: lb-network-ipv6-only
    • עדיפות: 1000
    • כיוון התנועה: כניסה
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-ssh
    • מסנן מקור: טווחים של IPv4
    • טווחים של כתובות IPv4 של המקור: 0.0.0.0/0
    • פרוטוקולים ויציאות: בוחרים באפשרות פרוטוקולים ויציאות שצוינו, מסמנים את תיבת הסימון TCP ומזינים 22 ביציאות.

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

  6. כדי לאפשר בדיקות תקינות של IPv6, לוחצים שוב על יצירת כלל חומת אש ומזינים את הפרטים הבאים: Google Cloud

    • Name (שם): fw-allow-health-check-ipv6-only
    • רשת: lb-network-ipv6-only
    • עדיפות: 1000
    • כיוון התנועה: כניסה
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי טירגוט: allow-health-check-ipv6
    • מסנן מקור: טווחים של IPv6
    • טווחים של כתובות IPv6 של המקור: 2600:2d00:1:b029::/64
    • פרוטוקולים ויציאות: אישור הכול

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

gcloud

  1. יוצרים את fw-allow-lb-access-ipv6-only כלל חומת האש כדי לאפשר תעבורת IPv6 לכל המכונות הווירטואליות ברשת ה-VPC.

    gcloud compute firewall-rules create fw-allow-lb-access-ipv6-only \
    --network=lb-network-ipv6-only \
    --action=allow \
    --direction=ingress \
    --source-ranges=::/0 \
    --rules=all

  2. יוצרים את כלל חומת האש fw-allow-ssh כדי לאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh. אם לא מציינים את source-ranges,‏Google Cloud מפרש את הכלל כאילו הוא מתייחס לכל מקור.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network-ipv6-only \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  3. יוצרים את כלל fw-allow-health-check-ipv6 כדי לאפשר בדיקות תקינות שלGoogle Cloud IPv6.

    gcloud compute firewall-rules create fw-allow-health-check-ipv6-only \
    --network=lb-network-ipv6-only \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check-ipv6 \
    --source-ranges=2600:2d00:1:b029::/64 \
    --rules=tcp,udp

יצירת מכונות וירטואליות בעורף וקבוצות של מופעים

בדוגמה הזו אנחנו משתמשים בשתי קבוצות של מופעי מכונה לא מנוהלים, שלכל אחת מהן יש שתי מכונות וירטואליות של קצה עורפי. כדי להדגים את האופי האזורי של מאזני עומסי רשת פנימיים להעברת סיגנל ללא שינוי, שתי קבוצות המופעים ממוקמות באזורים נפרדים, us-west1-a ו-us-west1-c.

  • קבוצת המופעים ig-a מכילה את שתי המכונות הווירטואליות האלה:
    • vm-a1
    • vm-a2
  • קבוצת המופעים ig-c מכילה את שתי המכונות הווירטואליות האלה:
    • vm-c1
    • vm-c2

התנועה לכל ארבעת מכונות ה-VM בקצה העורפי מאוזנת.

המסוף

יצירת מכונות וירטואליות של קצה עורפי

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. חוזרים על השלבים האלה לכל מכונה וירטואלית, באמצעות השילובים הבאים של שם ואזור.

    • שם: vm-a1, אזור: us-west1-a
    • שם: vm-a2, אזור: us-west1-a
    • שם: vm-c1, אזור: us-west1-c
    • שם: vm-c2, אזור: us-west1-c

  3. לוחצים על Create instance.

  4. מגדירים את השם כמו שמופיע בשלב 2.

  5. בשדה Region, בוחרים באפשרות us-west1 ובוחרים Zone כמו שמוסבר בשלב 2.

  6. בקטע Boot disk מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ מסומנת באפשרויות של דיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

  7. לוחצים על אפשרויות מתקדמות.

  8. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-allow-health-check-ipv6.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • סוג מחסנית IP: IPv6 (single-stack)
      • כתובת IPv6 פנימית ראשית: זמנית (אוטומטית)

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

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

יצירת קבוצות של מופעי מכונה

  1. נכנסים לדף Instance groups במסוף Google Cloud .

    כניסה לדף Instance groups

  2. כדי ליצור שתי קבוצות של מכונות וירטואליות לא מנוהלות, שבכל אחת מהן יש שתי מכונות וירטואליות, חוזרים על השלבים הבאים ומשתמשים בשילובים האלה.

    • שם קבוצת המופעים: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
    • שם קבוצת המופעים: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

  3. לוחצים על יצירת קבוצת מופעים.

  4. לוחצים על קבוצת מופעים חדשה לא מנוהלת.

  5. מגדירים את השם כמו שמוסבר בשלב 2.

  6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שמוסבר בשלב 2.

  7. בקטע רשת, בוחרים באפשרות lb-network-ipv6-only.

  8. בשדה רשת משנה, בוחרים באפשרות lb-subnet-ipv6-only.

  9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמוסבר בשלב 2.

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

gcloud

  1. כדי ליצור את ארבע המכונות הווירטואליות, מריצים את הפקודה gcloud compute instances create ארבע פעמים, ומשתמשים בארבעת השילובים האלה ל-[VM-NAME] ול-[ZONE].

    • VM-NAME: vm-a1, ZONE: us-west1-a
    • VM-NAME: vm-a2, ZONE: us-west1-a
    • VM-NAME: vm-c1, ZONE: us-west1-c
    • VM-NAME: vm-c2, ZONE: us-west1-c
    gcloud beta compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check-ipv6 \
    --subnet=lb-subnet-ipv6-only \
    --stack-type=IPV6_ONLY

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

  2. יוצרים את שתי הקבוצות של מופעי מכונה לא מנוהלים בכל אזור:

    gcloud beta compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud beta compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. מוסיפים את המכונות הווירטואליות לקבוצות המופעים המתאימות:

    gcloud beta compute instance-groups unmanaged add-instances ig-a \
  --zone=us-west1-a \
  --instances=vm-a1,vm-a2
gcloud beta compute instance-groups unmanaged add-instances ig-c \
  --zone=us-west1-c \
  --instances=vm-c1,vm-c2

הגדרת רכיבים של מאזן עומסים

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

המסוף

התחלת ההגדרה

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף Load balancing

  2. לוחצים על Create load balancer (יצירת מאזן עומסים).
  3. בקטע Type of load balancer (סוג מאזן העומסים), בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL) (מאזן עומסים ברשת (TCP/UDP/SSL)) ולוחצים על Next (הבא).
  4. בקטע Proxy or passthrough (פרוקסי או העברה), בוחרים באפשרות Passthrough load balancer (מאזן עומסים להעברה) ולוחצים על Next (הבא).
  5. בקטע גלוי לכולם או פנימי, בוחרים באפשרות פנימי ולוחצים על הבא.
  6. לוחצים על Configure (הגדרה).

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer (יצירת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי), מזינים את הפרטים הבאים:

  • שם של מאזן עומסים: ilb-ipv6-only
  • אזור: us-west1
  • רשת: lb-network-ipv6-only

הגדרת הקצה העורפי

  1. לוחצים על Backend configuration.
  2. ברשימה בדיקת תקינות, לוחצים על יצירת בדיקת תקינות ומזינים את הפרטים הבאים:
    • Name (שם): hc-http-80
    • היקף: אזורי
    • Protocol: HTTP
    • יציאה: 80
    • פרוטוקול שרת proxy: ללא
    • בקשה: /
  3. לוחצים על יצירה.
  4. בקטע New Backend, בהגדרה IP stack type, בוחרים באפשרות IPv6 (single-stack).
  5. בקטע Instance group, בוחרים את קבוצת המכונות ig-a ולוחצים על Done.
  6. לוחצים על הוספת קצה עורפי וחוזרים על השלב כדי להוסיף את קבוצת המופעים ig-c.
  7. מוודאים שמופיע סימן וי כחול לצד Backend configuration.

הגדרות הקצה הקדמי

  1. לוחצים על Frontend configuration. בקטע New Frontend IP and port מבצעים את הפעולות הבאות:
    1. בשדה Name (שם), מזינים fr-ilb-ipv6-only.
    2. כדי לטפל בתעבורת IPv6:
      1. בשביל IP version, בוחרים IPv6. שרת ה-TCP של IPv6 שתיצרו בקטע הבא יקשר ל-VIP של כלל ההעברה.
      2. בשדה Subnetwork, בוחרים באפשרות lb-subnet-ipv6-only. טווח כתובות ה-IPv6 בכלל ההעברה הוא תמיד זמני.
      3. בשדה יציאות, בוחרים באפשרות כמה, ואז בשדה מספר היציאה, מזינים 80,8008,8080,8088.
      4. לוחצים על סיום.
    3. לפני שממשיכים, מוודאים שלצד Frontend configuration מופיע סימן אישור כחול.

בדיקת ההגדרות האישיות

  1. לוחצים על Review and finalize. בודקים את כל ההגדרות.
  2. אם ההגדרות נכונות, לוחצים על יצירה. יצירת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי נמשכת כמה דקות.

gcloud

  1. יוצרים בדיקת תקינות חדשה של HTTP ברמה האזורית כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

    gcloud beta compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. יוצרים את שירות הקצה העורפי:

    gcloud beta compute backend-services create ilb-ipv6-only \
    --load-balancing-scheme=INTERNAL \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. מוסיפים את שתי קבוצות המופעים לשירות ה-Backend:

    gcloud beta compute backend-services add-backend ilb-ipv6-only \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

    gcloud beta compute backend-services add-backend ilb-ipv6-only \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. יוצרים את כלל ההעברה של IPv6 עם כתובת IPv6 זמנית.

    gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
    --region=us-west1 \
    --load-balancing-scheme=INTERNAL \
    --subnet=lb-subnet-ipv6-only \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=ilb-ipv6-only \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

    שרת ה-TCP של IPv6 שתיצרו בקטע הבא יקשר ל-VIP של כלל ההעברה.

התקנת שרת TCP של IPv6 במכונות הווירטואליות של ה-Backend באמצעות סקריפט Bash להפעלה

בדוגמה הזו, סקריפט לטעינה בזמן ההפעלה של Bash למכונות וירטואליות של קצה עורפי מכיל את הפקודות הבאות:

  • פקודות רשת לניתוב כל החבילות היוצאות שמקורן ברשת משנה דרך שער וממשק רשת שצוינו.
  • סקריפט שרת Python‏ (server.py), שהוא שרת TCP של IPv6, שמקשיב לחיבורים נכנסים בכתובת ה-VIP ובממשק הרשת שצוינו. הוא מקבל חיבורים נכנסים של לקוחות, שולח תגובה ואז סוגר את החיבור.

צריך להוסיף את הפרטים הבאים בסקריפט Bash:

  • כתובת השער
  • טווח תת-רשת
  • ה-VIP של כלל ההעברה
  • ממשק רשת

כדי לזהות את כתובת השער ואת טווח רשת המשנה, מריצים את הפקודה ip -6 route show table all במכונה הווירטואלית של הבק-אנד. מידע נוסף על הפקודות שמשמשות בסקריפט Bash להפעלה מופיע בסעיף נספח.

כדי להוסיף סקריפט לטעינה בזמן ההפעלה למופע של מכונה וירטואלית:

המסוף

  1. ברשימת המכונות הווירטואליות שיצרתם קודם, לוחצים על המכונה הווירטואלית שצריך לעדכן.

  2. לוחצים על Edit.

  3. בקטע מטא-נתונים, מזינים את הסקריפט הבא בשדה סקריפט לטעינה בזמן ההפעלה.

    #!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

  4. לוחצים על Save.

  5. מפעילים מחדש את המכונה.

gcloud

  1. יוצרים סקריפט לטעינה בזמן ההפעלה.

    nano startup.sh

  2. מוסיפים את הסקריפט הבא ושומרים את הקובץ.

    #!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

  3. מוסיפים את קובץ המטא-נתונים למכונה הווירטואלית.

    gcloud compute instances add-metadata VM-NAME \
  --metadata-from-file=startup-script=startup.sh

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

בדיקת מאזן העומסים

כדי לבדוק את מאזן העומסים, יוצרים מכונת VM של לקוח באותו אזור שבו נמצא מאזן העומסים, ואז שולחים תעבורה מהלקוח למאזן העומסים.

יצירת מכונה וירטואלית של לקוח

בדוגמה הזו נוצרת מכונה וירטואלית של לקוח (vm-client) באותו אזור שבו נמצאות המכונות הווירטואליות של השרת (בק-אנד). הלקוח משמש לאימות ההגדרה של מאזן העומסים ולהדגמת ההתנהגות הצפויה כפי שמתואר בקטע בדיקה.

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create instance.

  3. בשדה Name (שם), מזינים vm-client.

  4. בשדה אזור, בוחרים באפשרות us-west1.

  5. בשדה Zone, בוחרים באפשרות us-west1-a.

  6. לוחצים על אפשרויות מתקדמות.

  7. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים allow-ssh.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • סוג מחסנית IP: IPv6 (single-stack)
    3. לוחצים על סיום.

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

gcloud

המכונה הווירטואלית של הלקוח יכולה להיות בכל אזור באותו אזור שבו נמצא מאזן העומסים, והיא יכולה להשתמש בכל רשת משנה באותו אזור. בדוגמה הזו, הלקוח נמצא באזור us-west1-a והוא משתמש באותה רשת משנה כמו המכונות הווירטואליות של הבק-אנד.

gcloud beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

בדיקת החיבור

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

  1. מתחברים למכונה הווירטואלית של הלקוח באמצעות SSH.

    gcloud compute ssh vm-client --zone=us-west1-a

  2. תאר את כלל ההעברה של IPv6‏ fr-ilb-ipv6-only. שימו לב לIPV6_ADDRESS בתיאור.

    gcloud beta compute forwarding-rules describe fr-ilb-ipv6-only \
    --region=us-west1

  3. מלקוחות עם קישוריות IPv6, מריצים את הפקודה הבאה:

    curl http://IPV6_ADDRESS:80

    לדוגמה, אם כתובת ה-IPv6 שהוקצתה היא [fd20:307:120c:2000:0:1:0:0/96]:80, הפקודה צריכה להיראות כך:

    curl http://[fd20:307:120c:2000:0:1:0:0]:80

אפשרויות הגדרה נוספות

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

הפעלה של גישה גלובלית

אתם יכולים להפעיל גישה גלובלית למאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי לדוגמה, כדי שהלקוחות יוכלו לגשת אליו בכל האזורים. שרתי הבק-אנד של מאזן העומסים לדוגמה עדיין צריכים להיות ממוקמים באזור אחד (us-west1).

‫ מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי עם גישה גלובלית.
מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי עם גישה גלובלית (לחצו כדי להגדיל).

כדי להגדיר גישה גלובלית, מבצעים את שינויי ההגדרה הבאים.

המסוף

עריכת כלל ההעברה של מאזן העומסים

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף איזון עומסים

  2. בעמודה Name (שם), לוחצים על מאזן עומסי הרשת הפנימי להעברת סיגנל ללא שינוי. מאזן העומסים לדוגמה נקרא be-ilb.

  3. לוחצים על Frontend configuration.

  4. לוחצים על Edit ‏.

  5. בקטע גישה גלובלית, בוחרים באפשרות הפעלה.

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

  7. לוחצים על עדכון.

בדף Load balancer details (פרטי מאזן העומסים), מוודאים שבהגדרות הקצה הקדמי מופיע Regional (REGION) with global access (אזורי (REGION) עם גישה גלובלית).

gcloud

  1. מעדכנים את כלל ההעברה של מאזן העומסים לדוגמה, fr-ilb, כך שיכלול את הדגל --allow-global-access.

     gcloud compute forwarding-rules update fr-ilb \
     --region=us-west1 \
     --allow-global-access

  2. אפשר להשתמש בפקודה forwarding-rules describe כדי לבדוק אם הופעלה גישה גלובלית לכלל העברה. לדוגמה:

     gcloud compute forwarding-rules describe fr-ilb \
     --region=us-west1 \
     --format="get(name,region,allowGlobalAccess)"

    המילה True מופיעה בפלט, אחרי השם והאזור של כלל ההעברה, כשהגישה הגלובלית מופעלת.

API

שולחים בקשת PATCH אל ה-method‏ forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

יצירת לקוח VM לבדיקת גישה גלובלית

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create instance.

  3. מגדירים את Name לערך vm-client2.

  4. מגדירים את Region (אזור) לערך europe-west1.

  5. מגדירים את Zone לערך europe-west1-b.

  6. לוחצים על אפשרויות מתקדמות.

  7. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים allow-ssh.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network
      • Subnet: europe-subnet

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

gcloud

המכונה הווירטואלית של הלקוח יכולה להיות בכל אזור באותו אזור שבו נמצא מאזן העומסים, והיא יכולה להשתמש בכל רשת משנה באותו אזור. בדוגמה הזו, הלקוח נמצא באזור europe-west1-b והוא משתמש באותה רשת משנה כמו המכונות הווירטואליות של הבק-אנד.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

שולחים בקשת POST אל ה-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
  {
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
    "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

התחברות ללקוח ה-VM ובדיקת הקישוריות

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

  gcloud compute ssh vm-client2 --zone=europe-west1-b

בודקים את החיבור למאזן העומסים בכל היציאות שהוגדרו, כמו שעשיתם מ-vm-client באזור us-west1. בודקים את קישוריות ה-HTTP בארבע היציאות שהוגדרו בכלל ההעברה:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088

הגדרת קבוצות של מופעי מכונה מנוהלים

ההגדרה לדוגמה יצרה שתי קבוצות של מופעים לא מנוהלים. במקום זאת, אתם יכולים להשתמש בקבוצות של מופעי מכונה מנוהלים, כולל קבוצות של מופעי מכונה מנוהלים אזוריים ואזוריים, כשרתי קצה (backend) למאזני עומסים פנימיים מסוג העברת תעבורה (passthrough) ברשת.

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

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

בקטע הזה מוסבר איך לשנות את שירות לקצה העורפי של מאזן העומסים הפנימי לדוגמה מסוג passthrough Network Load Balancer, כך שישתמש בקבוצת מופעי מכונה מנוהלים אזורית.

המסוף

תבנית של הגדרות מכונה

  1. נכנסים לדף VM instance templates במסוף Google Cloud .

    לדף VM instance templates

  2. לוחצים על Create instance template.

  3. מגדירים את Name לערך template-vm-ilb.

  4. בוחרים סוג מכונה.

  5. בקטע Boot disk מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ מסומנת באפשרויות של דיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

  6. לוחצים על אפשרויות מתקדמות.

  7. לוחצים על Networking ומגדירים את השדות הבאים:

    1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-allow-health-check.
    2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
      • רשת: lb-network
      • Subnet: lb-subnet

  8. לוחצים על ניהול, ואז בשדה סקריפט לטעינה בזמן ההפעלה מזינים את הסקריפט הבא:

    #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

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

קבוצת מופעי מכונה מנוהלים

  1. נכנסים לדף Instance groups במסוף Google Cloud .

    כניסה לדף Instance groups

  2. לוחצים על יצירת קבוצת מופעים.

  3. מגדירים את Name לערך ig-ilb.

  4. בקטע Location בוחרים באפשרות Multi-zone ומגדירים את Region ל-us-west1.

  5. מגדירים את תבנית של הגדרות מכונה ל-template-vm-ilb.

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

  7. מגדירים את מספר המכונות המינימלי ל-1 ואת מספר המכונות המקסימלי ל-6.

  8. אופציונלי: מגדירים תיקון תוכנה אוטומטי. אם מגדירים תיקון תוכנה אוטומטי (autohealing), צריך להשתמש באותה בדיקת תקינות שמשמשת את שירות לקצה העורפי עבור מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי. בדוגמה הזו, נשתמש בערך hc-http-80.

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

gcloud

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

    gcloud compute instance-templates create template-vm-ilb \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --region=us-west1 \
    --network=lb-network \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. יוצרים קבוצה אחת של מופעי מכונה מנוהלים אזוריים באמצעות התבנית:

    gcloud compute instance-groups managed create ig-ilb \
    --template=template-vm-ilb \
    --region=us-west1 \
    --size=6

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

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-ilb \
    --instance-group-region=us-west1

  4. מנתקים את שתי קבוצות המכונות הלא מנוהלות (אזוריות) משירות ה-backend:

    gcloud compute backend-services remove-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a
gcloud compute backend-services remove-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

הסרה של כתובות IP חיצוניות ממכונות וירטואליות של קצה עורפי

כשיצרתם את מכונות ה-VM של ה-Backend, לכל אחת מהן הוקצתה כתובת IP חיצונית זמנית כדי שתוכל להוריד את Apache באמצעות סקריפט לטעינה בזמן ההפעלה. מכיוון שהמכונות הווירטואליות בקצה העורפי משמשות רק מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי, אפשר להסיר את כתובות ה-IP החיצוניות שלהן. הסרה של כתובות IP חיצוניות מונעת מהמכונות הווירטואליות של ה-Backend גישה ישירה לאינטרנט.

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. חוזרים על השלבים הבאים לכל מכונה וירטואלית של קצה העורף.

  3. לוחצים על השם של מכונת ה-VM של ה-Backend, לדוגמה, vm-a1.

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

  5. בקטע Network interfaces לוחצים על הרשת.

  6. ברשימה כתובת IP חיצונית בוחרים באפשרות None ולוחצים על Done.

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

gcloud

  1. כדי לחפש את האזור של מכונה – למשל, אם אתם משתמשים בקבוצת מופעי מכונה מנוהלים אזורית – מריצים את הפקודה הבאה לכל מכונה כדי לקבוע את האזור שלה. מחליפים את [SERVER-VM] בשם המכונה הווירטואלית שרוצים לחפש.

    gcloud compute instances list --filter="name=[SERVER-VM]"

  2. חוזרים על השלב הבא לכל מכונה וירטואלית של קצה העורף. מחליפים את [SERVER-VM] בשם של המכונה הווירטואלית, ואת [ZONE] בתחום (zone) של המכונה הווירטואלית.

    gcloud compute instances delete-access-config [SERVER-VM] \
    --zone=[ZONE] \
    --access-config-name=external-nat

API

שולחים בקשת POST לשיטת instances.deleteAccessConfig לכל מכונה וירטואלית בקצה העורפי, מחליפים את vm-a1 בשם המכונה, ואת us-west1-a באזור של המכונה הווירטואלית.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

שימוש בכתובת IP פנימית שמורה

כשיוצרים מכונות וירטואליות (VM) של קצה עורפי וקבוצות של מכונות וירטואליות, המכונה הווירטואלית משתמשת בכתובת IPv4 או IPv6 פנימית וארעית.

בשלבים הבאים מוסבר איך להפוך כתובת IPv4 או IPv6 פנימית לכתובת IPv4 או IPv6 פנימית סטטית, ואז לעדכן את מכונת ה-VM כך שתשתמש בכתובת ה-IP הפנימית הסטטית:

  1. העברה של כתובת IPv4 או IPv6 פנימית ארעית שנמצאת בשימוש לכתובת סטטית.
  2. שינוי או הקצאה של כתובת IPv6 פנימית למכונה קיימת.

לחלופין, אפשר לבצע את השלבים הבאים כדי להזמין כתובת IPv4 או IPv6 פנימית סטטית חדשה, ואז לעדכן את מכונת ה-VM כך שתשתמש בכתובת ה-IP הפנימית הסטטית:

  1. שמירת כתובת IPv4 או IPv6 פנימית סטטית חדשה.

    בניגוד להזמנת כתובת IPv4 פנימית, בהזמנת כתובת IPv6 פנימית אין תמיכה בהזמנת כתובת IP ספציפית מתת-הרשת. במקום זאת, מוקצה באופן אוטומטי טווח כתובות IPv6 פנימיות /96 מתוך טווח כתובות ה-IPv6 הפנימיות /64 של תת-הרשת.

  2. שינוי או הקצאה של כתובת IPv6 פנימית למכונה קיימת.

מידע נוסף מופיע במאמר איך שומרים כתובת IP פנימית סטטית.

אישור תנועה בכל היציאות

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

כשיצרתם את כלל ההעברה של מאזן העומסים בדוגמה הזו, הגדרתם את היציאות 80, 8008, 8080 ו-8088. סקריפט לטעינה בזמן ההפעלה שמתקין את Apache גם מגדיר אותו לקבלת חיבורי HTTPS ביציאות 443 ו-8443.

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

במאמר הזה מוסבר איך למחוק את כלל ההעברה הנוכחי של מאזן העומסים וליצור כלל חדש שמקבל תנועה בכל היציאות.

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

המסוף

מחיקת כלל ההעברה ויצירת כלל חדש

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף איזון עומסים

  2. לוחצים על be-ilb מאזן העומסים ואז על עריכה.

  3. לוחצים על Frontend configuration.

  4. מעבירים את העכבר מעל כלל ההעברה 10.1.2.9 ולוחצים על מחיקה.

  5. לוחצים על Add frontend IP and port.

  6. בקטע New Frontend IP and port (כתובת IP חדשה של חזית האתר ופורט), מזינים את הפרטים הבאים ולוחצים על Done (סיום):

    • Name (שם): fr-ilb
    • Subnetwork: lb-subnet
    • כתובת IP פנימית: ip-ilb
    • יציאות: הכול.

  7. לפני שממשיכים, מוודאים שלצד Frontend configuration מופיע סימן וי כחול.

  8. לוחצים על בדיקה וסיום ובודקים את ההגדרות של איזון העומסים.

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

gcloud

  1. מוחקים את כלל ההעברה הקיים, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. יוצרים כלל העברה חלופי, עם אותו שם, שהגדרת היציאה שלו משתמשת במילת המפתח ALL. הפרמטרים האחרים של כלל ההעברה יישארו ללא שינוי.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=ALL \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

כדי למחוק את כלל ההעברה, שולחים בקשת DELETE ל-method‏ forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

כדי ליצור את כלל ההעברה, שולחים בקשת POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

בדיקת התנועה בכל היציאות שהוגדרו

מתחברים למופע של מכונת הלקוח הווירטואלית ובודקים חיבורי HTTP ו-HTTPS.

  • מתחברים למכונה הווירטואלית של הלקוח:

    gcloud compute ssh vm-client --zone=us-west1-a

  • בודקים את הקישוריות ל-HTTP בכל ארבע היציאות:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • בודקים את הקישוריות של HTTPS ביציאות 443 ו-8443. הדגל --insecure נדרש כי כל שרת Apache בהגדרת הדוגמה משתמש באישור בחתימה עצמית. 

    curl https://10.1.2.99 --insecure
curl https://10.1.2.99:8443 --insecure

  • שימו לב שבקשות HTTP (בכל ארבע היציאות) ובקשות HTTPS (בשתי היציאות) מפוזרות בין כל מכונות ה-VM של העורף.

קבלת תנועה בכמה יציאות באמצעות שני כללי העברה

כשיצרתם את כלל ההעברה של מאזן העומסים בדוגמה הזו, הגדרתם את היציאות 80, 8008, 8080 ו-8088. סקריפט לטעינה בזמן ההפעלה שמתקין את Apache גם מגדיר אותו לקבלת חיבורי HTTPS ביציאות 443 ו-8443.

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

במאמר הזה מוסבר איך להחליף את כלל ההעברה של מאזן העומסים לדוגמה בשני כללי העברה. כלל אחד לטיפול בתנועה ביציאות 80, 8008, 8080 ו-8088, וכלל שני לטיפול בתנועה ביציאות 443 ו-8443.

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

המסוף

  1. נכנסים לדף Forwarding rules במסוף Google Cloud .

    מעבר לכללי העברה

  2. בעמודה שם, לוחצים על fr-ilb ואז על מחיקה.

  3. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף איזון עומסים

  4. בעמודה שם, לוחצים על be-ilb.

  5. לוחצים על Edit.

  6. לוחצים על Frontend configuration.

  7. לוחצים על Add frontend IP and port.

  8. בקטע New Frontend IP and port:

    1. בשדה Name (שם), מזינים fr-ilb-http.
    2. בשדה Subnetwork, בוחרים באפשרות lb-subnet.
    3. בשדה Internal IP purpose (מטרת כתובת ה-IP הפנימית), בוחרים באפשרות Shared (משותפת).
    4. ברשימה IP address, בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve:
      • Name (שם): internal-10-1-2-99
      • כתובת IP סטטית: אני רוצה לבחור
      • כתובת IP מותאמת אישית: 10.1.2.99
    5. בקטע יציאות, בוחרים באפשרות כמה, ואז בשדה מספרי יציאות מזינים 80,8008,8080 ו-8088.
    6. לוחצים על סיום.

  9. לוחצים על Add frontend IP and port.

  10. בקטע New Frontend IP and port:

    1. בשדה Name (שם), מזינים fr-ilb-https.
    2. בשדה Subnetwork, בוחרים באפשרות lb-subnet.
    3. בשדה Internal IP purpose (מטרת כתובת ה-IP הפנימית), בוחרים באפשרות Shared (משותפת).
    4. ברשימה IP address בוחרים באפשרות internal-10-1-2-99.
    5. בשדה יציאות, בוחרים באפשרות כמה, ואז בשדה מספרי יציאות מזינים 443 ו-8443.
    6. לוחצים על סיום.

  11. לוחצים על בדיקה וסיום ובודקים את הגדרות מאזן העומסים.

  12. לוחצים על עדכון.

gcloud

  1. מוחקים את כלל ההעברה הקיים, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. יוצרים כתובת IP פנימית סטטית (שמורה) בשביל 10.1.2.99 ומגדירים את הדגל --purpose שלה לערך SHARED_LOADBALANCER_VIP. הדגל --purpose נדרש כדי ששני כללי העברה פנימיים יוכלו להשתמש באותה כתובת IP פנימית.

    gcloud compute addresses create internal-10-1-2-99 \
    --region=us-west1 \
    --subnet=lb-subnet \
    --addresses=10.1.2.99 \
    --purpose=SHARED_LOADBALANCER_VIP
    1. יוצרים שני כללי העברה חלופיים עם הפרמטרים הבאים:
    gcloud compute forwarding-rules create fr-ilb-http \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

    gcloud compute forwarding-rules create fr-ilb-https \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=443,8443 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

כדי למחוק את כלל ההעברה, שולחים בקשת DELETE ל-method‏ forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

כדי ליצור כתובת IP פנימית סטטית (שמורה) בשביל 10.1.2.99 ולהגדיר את הייעוד שלה ל-SHARED_LOADBALANCER_VIP, שולחים בקשת POST אל ה-method‏ addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

כדי ליצור שני כללי העברה, שולחים שתי בקשות POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

בדיקת התנועה בהגדרת כמה יציאות

מתחברים למופע של מכונת הלקוח הווירטואלית ובודקים חיבורי HTTP ו-HTTPS.

  • מתחברים למכונה הווירטואלית של הלקוח:

    gcloud compute ssh vm-client --zone=us-west1-a

  • בודקים את הקישוריות ל-HTTP בכל ארבע היציאות:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • בודקים את הקישוריות של HTTPS ביציאות 443 ו-8443. הדגל --insecure נדרש כי כל שרת Apache בהגדרת הדוגמה משתמש באישור בחתימה עצמית.

    curl https://10.1.2.99 --insecure
curl https://10.1.2.99:8443 --insecure

  • שימו לב שבקשות HTTP (בכל ארבע היציאות) ובקשות HTTPS (בשתי היציאות) מפוזרות בין כל מכונות ה-VM של העורף.

שימוש בזיקה לסשן

ההגדרה לדוגמה יוצרת שירות backend ללא זיקה לסשן.

הליך זה מראה לך איך לעדכן את שירות הקצה העורפי עבור מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שמופיע בדוגמה, כך שישתמש בזיקה לסשן (session affinity) על סמך hash שנוצר מכתובות ה-IP של הלקוח ומכתובת ה-IP של כלל ההעברה הפנימי של מאזן העומסים.

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

.

המסוף

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף איזון עומסים

  2. לוחצים על be-ilb (השם של שירות ה-Backend שיצרתם בדוגמה הזו) ואז על עריכה.

  3. בדף Edit internal passthrough Network Load Balancer (עריכת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי), לוחצים על Backend configuration (הגדרת קצה עורפי).

  4. ברשימה Session affinity (העדפה של סשן), בוחרים באפשרות Client IP (כתובת IP של לקוח).

  5. לוחצים על עדכון.

gcloud

משתמשים בפקודה gcloud הבאה כדי לעדכן את שירות לקצה העורפי be-ilb, ומציינים את הזיקה לסשן (session affinity) לכתובת IP של לקוח:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

שולחים בקשת PATCH אל ה-method‏ regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

הגדרת מדיניות מעקב אחר חיבורים

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

מדיניות מעקב אחר חיבורים כוללת את ההגדרות הבאות:

gcloud

כדי לעדכן את מדיניות מעקב החיבורים בשירות לקצה העורפי, משתמשים בפקודה gcloud compute backend-services הבאה:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

מחליפים את ה-placeholders בערכים תקינים:

  • ‫BACKEND_SERVICE: השירות לקצה העורפי שאתם מעדכנים
  • ‫REGION: האזור של שירות ה-Backend שאתם מעדכנים
  • ‫TRACKING_MODE: מצב מעקב החיבור שבו יש להשתמש עבור מנות נכנסות. לרשימת הערכים הנתמכים, ראו מצב מעקב.
  • ‫CONNECTION_PERSISTENCE_BEHAVIOR: התנהגות של חיבור מתמשך כששרתי קצה עורפיים לא תקינים. רשימת הערכים הנתמכים מופיעה במאמר חיבור מתמשך בשרתי קצה עורפיים לא תקינים.
  • ‫IDLE_TIMEOUT_VALUE: מספר השניות שבהן צריך לשמור רשומה בטבלת מעקב החיבורים אחרי שמאזן העומסים מעבד את המנה האחרונה שתואמת לרשומה

שימוש בהעדפה אזורית

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

  • משתמשים בפקודה הבאה כדי להגדיר את האפשרות ZONAL_AFFINITY_STAY_WITHIN_ZONE: מידע נוסף על האפשרות הזוZONAL_AFFINITY_STAY_WITHIN_ZONE

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_STAY_WITHIN_ZONE \
    --region=us-west1

  • משתמשים בפקודה הבאה כדי להגדיר את ZONAL_AFFINITY_SPILL_CROSS_ZONEהזיקה לאזור עם יחס ברירת המחדל של 0.0העברה אוטומטית. מידע נוסף על האפשרות הזו מופיע בקטעים איך פועלים ZONAL_AFFINITY_SPILL_CROSS_ZONE ויחס ההעברה ויחס העברה אפסי.

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --region=us-west1

  • משתמשים בפקודה הבאה כדי להגדיר ZONAL_AFFINITY_SPILL_CROSS_ZONE העדפה אזורית עם יחס מעבר של 30%. מידע נוסף על האפשרות הזו זמין בקטעים איך פועלים ZONAL_AFFINITY_SPILL_CROSS_ZONE ויחס ההעברה ויחס העברה שאינו אפס.

    gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --zonal-affinity-spillover-ratio=0.3 \
    --region=us-west1

יצירת כלל העברה ברשת משנה אחרת

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

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

המסוף

הוספת תת-הרשת השנייה

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

    מעבר לרשתות VPC

  2. לוחצים על יצירת רשת VPC.

  3. לחץ על lb-network.

  4. בקטע Subnets (רשתות משנה), מבצעים את הפעולות הבאות:

    1. לוחצים על הוספת רשת משנה.
    2. בקטע New subnet (רשת משנה חדשה), מזינים את הפרטים הבאים:
      • Name (שם): second-subnet
      • אזור: us-west1
      • טווח כתובות IP: 10.5.6.0/24
    3. לוחצים על הוספה.

הוספת כלל ההעברה השני

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף איזון עומסים

  2. לוחצים על be-ilb מאזן העומסים ואז על עריכה.

  3. לוחצים על Frontend configuration.

  4. לוחצים על Add frontend IP and port.

  5. בקטע New Frontend IP and port, מגדירים את השדות הבאים ולוחצים על Done:

    • Name (שם): fr-ilb-2
    • IP version: IPv4
    • Subnetwork: second-subnet
    • כתובת IP פנימית: ip-ilb
    • יציאות: 80 ו-443

  6. לפני שממשיכים, מוודאים שלצד Frontend configuration מופיע סימן וי כחול.

  7. לוחצים על בדיקה וסיום ובודקים את הגדרות מאזן העומסים.

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

gcloud

  1. יוצרים תת-רשת שנייה ברשת lb-network באזור us-west1:

     gcloud compute networks subnets create second-subnet \
     --network=lb-network \
     --range=10.5.6.0/24 \
     --region=us-west1

  2. יוצרים כלל העברה שני ליציאות 80 ו-443. הפרמטרים האחרים של הכלל הזה, כולל כתובת ה-IP ושירות לקצה העורפי, זהים לאלה של כלל ההעברה הראשי, fr-ilb.

     gcloud compute forwarding-rules create fr-ilb-2 \
     --region=us-west1 \
     --load-balancing-scheme=internal \
     --network=lb-network \
     --subnet=second-subnet \
     --address=10.5.6.99 \
     --ip-protocol=TCP \
     --ports=80,443 \
     --backend-service=be-ilb \
     --backend-service-region=us-west1

API

שולחים בקשת POST אל ה-method‏ subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

כדי ליצור את כלל ההעברה, שולחים בקשת POST אל ה-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

בדיקת כלל ההעברה החדש

מתחברים למופע של מכונת הלקוח הווירטואלית ובודקים חיבורי HTTP ו-HTTPS לכתובות ה-IP.

  1. מתחברים למכונה הווירטואלית של הלקוח:

    gcloud compute ssh vm-client --zone=us-west1-a

  2. בודקים את הקישוריות של HTTP לכתובות ה-IP:

    curl http://10.1.2.99
curl http://10.5.6.99

  3. בודקים את הקישוריות ב-HTTPS. חובה להשתמש ב---insecure כי הגדרת שרת Apache בהגדרה לדוגמה משתמשת באישורים בחתימה עצמית.

    curl https://10.1.2.99 --insecure
curl https://10.5.6.99 --insecure

  4. שימו לב שהבקשות מטופלות על ידי כל המכונות הווירטואליות בעורף, בלי קשר לפרוטוקול (HTTP או HTTPS) או לכתובת ה-IP שבה נעשה שימוש.

שימוש בחלוקת משנה של נתונים בעורף המערכת

ההגדרה לדוגמה יוצרת שירות backend ללא חלוקה לקבוצות משנה.

בקטע הזה מוסבר איך להפעיל חלוקה לקבוצות משנה בשירות לקצה העורפי של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שמוצג בדוגמה, כדי שהפריסה תוכל להתרחב למספר גדול יותר של שרתים עורפיים (backend instances).

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

מידע נוסף על תרחיש השימוש הזה זמין במאמר בנושא חלוקת משנה של קצה העורפי.

gcloud

משתמשים בפקודה gcloud הבאה כדי לעדכן את שירות לקצה העורפי be-ilb, ומציינים מדיניות של חלוקה לקבוצות משנה:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

שולחים בקשת PATCH אל ה-method‏ regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

יצירת מאזן עומסים ל-Packet Mirroring

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

רפליקציה של חבילות נתונים דורשת מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי כדי לאזן את התנועה לקבוצת מופעים של יעדי איסוף. כדי ליצור מאזן עומסי רשת פנימי מסוג Network Load Balancer לרפליקציה של חבילות נתונים, פועלים לפי השלבים הבאים.

המסוף

התחלת ההגדרה

  1. נכנסים לדף Load balancing במסוף Google Cloud .

    כניסה לדף Load balancing

  2. לוחצים על Create load balancer (יצירת מאזן עומסים).
  3. בקטע Type of load balancer (סוג מאזן העומסים), בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL) (מאזן עומסים ברשת (TCP/UDP/SSL)) ולוחצים על Next (הבא).
  4. בקטע Proxy or passthrough (פרוקסי או העברה), בוחרים באפשרות Passthrough load balancer (מאזן עומסים להעברה) ולוחצים על Next (הבא).
  5. בקטע גלוי לכולם או פנימי, בוחרים באפשרות פנימי ולוחצים על הבא.
  6. לוחצים על Configure (הגדרה).

הגדרה בסיסית

  1. בשדה Load balancer name, מזינים שם.
  2. בשדה Region, בוחרים את האזור של מכונות ה-VM שבהן רוצים לשכפל מנות.
  3. בקטע רשת, בוחרים את הרשת שבה רוצים לשכפל מנות.
  4. לוחצים על Backend configuration.
  5. בקטע New Backend (קצה עורפי חדש), בשדה Instance group (קבוצת מכונות), בוחרים את קבוצת המכונות שאליה רוצים להעביר את החבילות.
  6. ברשימה בדיקת תקינות, לוחצים על יצירת בדיקת תקינות ומזינים את הפרטים הבאים:
    • בשדה Name, מזינים שם לבדיקת תקינות.
    • ברשימה Protocol, בוחרים באפשרות HTTP.
    • בשדה יציאה, מזינים 80.
  7. לוחצים על יצירה.
  8. לוחצים על Frontend configuration.
  9. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
    1. בשדה Name (שם), מזינים שם.
    2. בשדה Subnetwork, בוחרים רשת משנה באותו אזור של המכונות לרפליקציה.
    3. בקטע Ports (יציאות), בוחרים באפשרות All (הכול).
    4. לוחצים על הגדרות מתקדמות ומסמנים את התיבה הפעלת מאזן העומסים הזה לשיקוף מנות.
    5. לוחצים על סיום.
  10. לוחצים על יצירה.

gcloud

  1. יוצרים בדיקת תקינות חדשה של HTTP אזורי כדי לבדוק את הקישוריות של HTTP לקבוצת מופעים ביציאה 80:

    gcloud compute health-checks create http HEALTH_CHECK_NAME \
    --region=REGION \
    --port=80

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

    • ‫HEALTH_CHECK_NAME: השם של בדיקת תקינות.
    • ‫REGION: האזור של המופעים של מכונות וירטואליות שאתם רוצים לשכפל את חבילות הנתונים שלהם.

  2. יוצרים שירות קצה עורפי לתנועת HTTP:

    gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --health-checks-region=REGION \
    --health-checks=HEALTH_CHECK_NAME \
    --load-balancing-scheme=internal \
    --protocol=tcp

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

    • ‫COLLECTOR_BACKEND_SERVICE: השם של שירות הקצה העורפי.
    • ‫REGION: האזור של המופעים של מכונות וירטואליות שרוצים לשכפל את חבילות הנתונים שלהם.
    • ‫HEALTH_CHECK_NAME: השם של בדיקת תקינות.

  3. מוסיפים קבוצת מופעים לשירות הקצה העורפי:

    gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --instance-group=INSTANCE_GROUP \
    --instance-group-zone=ZONE

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

    • ‫COLLECTOR_BACKEND_SERVICE: השם של שירות הקצה העורפי.
    • ‫REGION: האזור של קבוצת המכונות.
    • ‫INSTANCE_GROUP: השם של קבוצת המכונות.
    • ‫ZONE: האזור של קבוצת המכונות.

  4. יוצרים כלל העברה לשירות הקצה העורפי:

    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
    --region=REGION \
    --network=NETWORK \
    --subnet=SUBNET \
    --backend-service=COLLECTOR_BACKEND_SERVICE \
    --load-balancing-scheme=internal \
    --ip-protocol=TCP \
    --ports=all \
    --is-mirroring-collector

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

    • ‫FORWARDING_RULE_NAME: השם של כלל ההעברה.
    • ‫REGION: האזור של כלל ההעברה.
    • ‫NETWORK: הרשת של כלל ההעברה.
    • ‫SUBNET: רשת משנה באזור של המכונות הווירטואליות שאתם רוצים לשכפל את חבילות הנתונים שלהן.
    • ‫COLLECTOR_BACKEND_SERVICE: השירות לקצה העורפי של מאזן העומסים הזה.

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

נספח: מבוא לסקריפט Bash של IPv6

בקטע הזה מופיע תיאור קצר של פקודות הרישות השונות שקשורות לסקריפט לטעינה בזמן ההפעלה של Bash שמשמש להתקנת שרת IPv6 TCP במכונות הווירטואליות של ה-בק-אנד. אין צורך לחזור על השלבים האלה. הן מפורטות כאן רק כדי לספק הקשר ולעזור להבין.

  1. הצגת כל מסלולי IPv6.

    ip -6 route show table all

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

    fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

    מהפלט של השלב הקודם, מזהים את הפרטים הבאים:

    • כתובת IPv6 מקומית (מתחילה ב-fe80::‎/10): בפלט לדוגמה, הכתובת המקומית היא fe80::57:2ff:fe36:ffbe. כתובת ה-IP המקומית הזו משמשת בנתיב ברירת המחדל שמוגדר בטבלת הניתוב 1. מסלול ברירת המחדל הזה נוצר בשלב 2.
    • תת-רשת /64: תת-הרשת הזו מוזכרת בכלל הניתוב של המדיניות שמבוססת על מקור בשלב 3

  2. מוסיפים נתיב ברירת מחדל מותאם אישית בטבלת הניתוב 1.

    הפקודה הבאה שולחת חבילות נתונים לשער באמצעות ממשק הרשת שנקרא ens4.

    sudo ip route add default via GATEWAY_ADDRESS dev ens4 table 1

    אחרי שמריצים את הפקודה הזו, מתווסף נתיב ברירת מחדל לטבלת ניתוב בהתאמה אישית (טבלה 1), שמצביע על השער fe80::57:2ff:fe36:ffbe דרך הממשק ens4.

    אם מריצים שוב את הפקודה ip -6 route show table all, הפלט שמתקבל הוא:

    default via fe80::57:2ff:fe36:ffbe dev ens4 table 1 metric 1024 pref medium
fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:1::/96 dev ens4 table local proto 66 metric 1024 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

  3. מוסיפים כלל ניתוב על סמך מדיניות שמבוסס על מקור.

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

    sudo ip -6 rule add from SUBNET_RANGE table 1

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

    ip -6 rule show

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

    0:      from all lookup local
32765:  from fd20:307:120c:2000::/64 lookup 1
32766:  from all lookup main

    השורה עם from fd20:... lookup 1 היא הכלל שהוספתם – הכלל שמורה לליבה להשתמש בטבלת הניתוב 1 לתנועה שמגיעה מרשת המשנה הזו.

  5. מאפשרים לשרת לבצע binding לכתובת IPv6 לא מקומית – כתובת ה-VIP של מאזן העומסים.

    sudo sysctl -w net.ipv6.ip_nonlocal_bind=1