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

המסוף

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

   מעבר לרשתות VPC

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

3. מזינים שם לרשת.

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

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

   • מזינים שם לרשת המשנה.
   • בוחרים אזור: REGION_A
   • מזינים טווח כתובות IP: 10.1.2.0/24

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

7. לוחצים על הוספת רשת משנה.

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

   • מזינים שם לרשת המשנה.
   • בוחרים אזור: REGION_B
   • מזינים טווח כתובות IP: 10.1.3.0/24

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

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

gcloud

1. יוצרים את רשת ה-VPC המותאמת אישית באמצעות הפקודה gcloud compute networks create:

   gcloud compute networks create NETWORK \
       --subnet-mode=custom
   

2. יוצרים תת-רשת ברשת NETWORK באזור REGION_A באמצעות הפקודה gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_A \
       --network=NETWORK \
       --range=10.1.2.0/24 \
       --region=REGION_A
   

3. יוצרים תת-רשת ברשת NETWORK באזור REGION_B באמצעות הפקודה gcloud compute networks subnets create:

   gcloud compute networks subnets create SUBNET_B \
       --network=NETWORK \
       --range=10.1.3.0/24 \
       --region=REGION_B
   

Terraform

כדי ליצור את רשת ה-VPC, משתמשים במשאב google_compute_network.

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

כדי ליצור את תת-הרשתות של ה-VPC ברשת lb-network-crs-reg, משתמשים במשאב google_compute_subnetwork.

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}

resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

שולחים בקשת POST אל ה-method‏ networks.insert. מחליפים את PROJECT_ID במזהה הפרויקט.

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

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

שולחים בקשת POST אל ה-method‏ subnetworks.insert. מחליפים את PROJECT_ID במזהה הפרויקט.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

שולחים בקשת POST אל ה-method‏ subnetworks.insert. מחליפים את PROJECT_ID במזהה הפרויקט.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "10.1.3.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

המסוף

אם אתם משתמשים ב Google Cloud מסוף, אתם יכולים לחכות וליצור את רשת המשנה של ה-proxy בלבד מאוחר יותר בדף איזון עומסים.

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

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

   מעבר לרשתות VPC

2. לוחצים על השם של רשת ה-VPC.
3. בכרטיסייה Subnet, לוחצים על Add subnet.
4. מזינים שם לרשת המשנה של ה-proxy בלבד.
5. בוחרים אזור: REGION_A
6. ברשימה Purpose בוחרים באפשרות Cross-region Managed Proxy.
7. בשדה טווח כתובות IP, מזינים 10.129.0.0/23.
8. לוחצים על הוספה.

יצירת תת-רשת של שרת proxy בלבד ב-REGION_B

1. בכרטיסייה Subnet, לוחצים על Add subnet.
2. מזינים שם לרשת המשנה של ה-proxy בלבד.
3. בוחרים אזור: REGION_B
4. ברשימה Purpose בוחרים באפשרות Cross-region Managed Proxy.
5. בשדה טווח כתובות IP, מזינים 10.130.0.0/23.
6. לוחצים על הוספה.

gcloud

יוצרים את רשתות המשנה של ה-proxy בלבד באמצעות הפקודה gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=10.129.0.0/23
    

    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=10.130.0.0/23
    

Terraform

כדי ליצור את תת-הרשת של ה-proxy בלבד ב-VPC ברשת lb-network-crs-reg, משתמשים במשאב google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.129.0.0/23"
  name          = "proxy-only-subnet1"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

resource "google_compute_subnetwork" "proxy_subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.130.0.0/23"
  name          = "proxy-only-subnet2"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-east1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

API

יוצרים את רשתות המשנה של ה-proxy בלבד באמצעות השיטה subnetworks.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": " PROXY_SN_A",
      "ipCidrRange": "10.129.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": "PROXY_SN_B",
      "ipCidrRange": "10.130.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   

המסוף

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

   למדיניות חומת האש

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

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

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

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

   • Name (שם): fw-healthcheck
   • רשת: NETWORK
   • כיוון התנועה: כניסה
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: load-balanced-backend
   • מסנן מקור: טווחים של כתובות IPv4
   • טווחי IPv4 של המקור: 35.191.0.0/16

   • פרוטוקולים ויציאות:

     • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
     • מסמנים את תיבת הסימון TCP ומזינים 80 כמספר היציאה.

     מומלץ להגביל את הכלל הזה רק לפרוטוקולים ולפורטים שתואמים לאלה שמשמשים בבדיקת תקינות. אם משתמשים ב-tcp:80 לפרוטוקול וליציאה, Google Cloud יכול להשתמש ב-HTTP ביציאה 80 כדי ליצור קשר עם המכונות הווירטואליות, אבל הוא לא יכול להשתמש ב-HTTPS ביציאה 443 כדי ליצור איתן קשר.

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

6. לוחצים על Create firewall rule (יצירת כלל חומת אש) בפעם השלישית כדי ליצור את הכלל שיאפשר לשרתי ה-Proxy של מאזן העומסים להתחבר לשרתי הקצה:

   • Name (שם): fw-backends
   • רשת: NETWORK
   • כיוון התנועה: כניסה
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: load-balanced-backend
   • מסנן מקור: טווחים של כתובות IPv4
   • טווחי IPv4 של המקור: 10.129.0.0/23 ו-10.130.0.0/23
   • פרוטוקולים ויציאות:
     • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
     • מסמנים את תיבת הסימון TCP ומזינים את הערך 80, 443, 8080 עבור מספרי היציאות.

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

gcloud

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

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

2. יוצרים את הכלל fw-healthcheck כדי לאפשר Google Cloudבדיקות תקינות. בדוגמה הזו, כל תנועת ה-TCP מבודקי בדיקת תקינות מותרת, אבל אפשר להגדיר קבוצה מצומצמת יותר של יציאות בהתאם לצרכים שלכם.

   gcloud compute firewall-rules create fw-healthcheck \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --source-ranges=35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
   

3. יוצרים את כלל fw-backends כדי לאפשר לשרתי ה-proxy של מאזן העומסים של האפליקציה הפנימית להתחבר לשרתים העורפיים (backend) שלכם. מגדירים את source-ranges לטווחים המוקצים של תת-הרשת של שרת ה-proxy בלבד, לדוגמה, 10.129.0.0/23 ו-10.130.0.0/23.

   gcloud compute firewall-rules create fw-backends \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --source-ranges=source-range \
       --target-tags=load-balanced-backend \
       --rules=tcp:80,tcp:443,tcp:8080
   

Terraform

כדי ליצור את הכללים בחומת האש, משתמשים במשאב google_compute_firewall.

resource "google_compute_firewall" "fw_healthcheck" {
  name          = "gl7-ilb-fw-allow-hc"
  provider      = google-beta
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16", "35.235.240.0/20"]
  allow {
    protocol = "tcp"
  }
}

resource "google_compute_firewall" "fw_ilb_to_backends" {
  name          = "fw-ilb-to-fw"
  provider      = google-beta
  network       = google_compute_network.default.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22", "80", "443", "8080"]
  }
}

resource "google_compute_firewall" "fw_backends" {
  name          = "gl7-ilb-fw-allow-ilb-to-backends"
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["10.129.0.0/23", "10.130.0.0/23"]
  target_tags   = ["http-server"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
}

API

יוצרים את כלל חומת האש fw-ilb-to-backends על ידי שליחת בקשת POST ל-method‏ firewalls.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

יוצרים את כלל חומת האש fw-healthcheck על ידי שליחת בקשת POST ל-method‏ firewalls.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [35.191.0.0/16],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

יוצרים את כלל חומת האש fw-backends כדי לאפשר תעבורת TCP בתת-הרשת של ה-proxy עבור השיטה firewalls.insert. מחליפים את PROJECT_ID במזהה הפרויקט.

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

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

המסוף

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

   כניסה לדף Instance templates

   1. לוחצים על Create instance template.
   2. בשדה Name (שם), מזינים gil7-backendeast1-template.
   3. מוודאים שדיסק האתחול מוגדר לתמונת Debian, כמו Debian GNU/Linux 12 (bookworm)‎. בהוראות האלה נעשה שימוש בפקודות שזמינות רק ב-Debian, כמו apt-get.
   4. לוחצים על אפשרויות מתקדמות.
   5. לוחצים על Networking ומגדירים את השדות הבאים:
      1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-load-balanced-backend.
      2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
         • רשת: NETWORK
         • Subnet: SUBNET_B

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

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

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

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

   9. בשדה Name (שם), מזינים gil7-backendwest1-template.

   10. מוודאים שדיסק האתחול מוגדר לתמונת Debian, כמו Debian GNU/Linux 12 (bookworm)‎. בהוראות האלה נעשה שימוש בפקודות שזמינות רק ב-Debian, כמו apt-get.

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

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

       1. בשדה Network tags (תגי רשת), מזינים את הערכים allow-ssh ו-load-balanced-backend.
       2. בקטע Network interfaces (ממשקי רשת), בוחרים באפשרויות הבאות:
          • רשת: NETWORK
          • Subnet: SUBNET_A

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

       #! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2
       

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

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

   כניסה לדף Instance groups

   1. לוחצים על יצירת קבוצת מופעים.
   2. בוחרים באפשרות New managed instance group (stateless) (קבוצת מופעי מכונה מנוהלים חדשה (בלי שמירת מצב)). מידע נוסף מופיע במאמר קבוצות של מכונות וירטואליות בלי שמירת מצב או עם שמירת מצב.
   3. בשדה Name (שם), מזינים gl7-ilb-mig-a.
   4. בקטע מיקום, בוחרים באפשרות אזור יחיד.
   5. בשדה אזור, בוחרים באפשרות REGION_A.
   6. בשדה Zone, בוחרים באפשרות ZONE_A.
   7. בשדה תבנית של הגדרות מכונה, בוחרים באפשרות gil7-backendwest1-template.

   8. מציינים את מספר המופעים שרוצים ליצור בקבוצה.

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

      • בקטע מצב שינוי גודל אוטומטי, בוחרים באפשרות Off:do not autoscale.
      • בשדה מספר מופעים מקסימלי, מזינים 2.

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

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

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

   11. בוחרים באפשרות New managed instance group (stateless) (קבוצת מופעי מכונה מנוהלים חדשה (בלי שמירת מצב)). מידע נוסף מופיע במאמר קבוצות של מכונות וירטואליות בלי שמירת מצב או עם שמירת מצב.

   12. בשדה Name (שם), מזינים gl7-ilb-mig-b.

   13. בקטע מיקום, בוחרים באפשרות אזור יחיד.

   14. בשדה אזור, בוחרים באפשרות REGION_B.

   15. בשדה Zone, בוחרים באפשרות ZONE_B.

   16. בשדה תבנית של הגדרות מכונה, בוחרים באפשרות gil7-backendeast1-template.

   17. מציינים את מספר המופעים שרוצים ליצור בקבוצה.

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

       • בקטע מצב שינוי גודל אוטומטי, בוחרים באפשרות Off:do not autoscale.
       • בשדה מספר מופעים מקסימלי, מזינים 2.

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

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

gcloud

ההוראות ל-gcloud CLI במדריך הזה מבוססות על ההנחה שאתם משתמשים ב-Cloud Shell או בסביבה אחרת שבה מותקן bash.

1. יוצרים תבנית של הגדרות מכונה עם שרת HTTP באמצעות הפקודה gcloud compute instance-templates create.

   gcloud compute instance-templates create gil7-backendwest1-template \
     --region=REGION_A \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --tags=allow-ssh,load-balanced-backend \
     --image-family=debian-12 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2'
   

   gcloud compute instance-templates create gil7-backendeast1-template \
       --region=REGION_B \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --tags=allow-ssh,load-balanced-backend \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://169.254.169.254/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         systemctl restart apache2'
   

2. יוצרים קבוצת מופעי מכונה מנוהלים באזור באמצעות הפקודה gcloud compute instance-groups managed create.

   gcloud compute instance-groups managed create gl7-ilb-mig-a \
       --zone=ZONE_A \
       --size=2 \
       --template=gil7-backendwest1-template
   

   gcloud compute instance-groups managed create gl7-ilb-mig-b \
       --zone=ZONE_B \
       --size=2 \
       --template=gil7-backendeast1-template
   

Terraform

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

resource "google_compute_instance_template" "instance_template_a" {
  name         = "gil7-backendwest1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-west1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_a.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-13"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat < /var/www/html/index.html
      
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

resource "google_compute_instance_template" "instance_template_b" {
  name         = "gil7-backendeast1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-east1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_b.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-13"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat < /var/www/html/index.html
      
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

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

resource "google_compute_region_instance_group_manager" "mig_a" {
  name     = "gl7-ilb-miga"
  provider = google-beta
  region   = "us-west1"
  version {
    instance_template = google_compute_instance_template.instance_template_a.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

resource "google_compute_region_instance_group_manager" "mig_b" {
  name     = "gl7-ilb-migb"
  provider = google-beta
  region   = "us-east1"
  version {
    instance_template = google_compute_instance_template.instance_template_b.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

יוצרים את תבנית המכונה באמצעות השיטה instanceTemplates.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
  "name":"gil7-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

יוצרים קבוצת מופעי מכונה מנוהלים בכל אזור באמצעות השיטה instanceGroupManagers.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-a",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

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

{
  "name":"gil7-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

יוצרים קבוצת מופעי מכונה מנוהלים בכל אזור באמצעות השיטה instanceGroupManagers.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-b",
  "zone": "projects/PROJECT_ID/zones/ZONE_B",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

המסוף

בחירת סוג מאזן העומסים

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

   כניסה לדף Load balancing

2. לוחצים על Create load balancer (יצירת מאזן עומסים).
3. בקטע Type of load balancer, בוחרים באפשרות Application Load Balancer (HTTP/HTTPS) ולוחצים על Next.
4. בקטע Public facing or internal (פנימי או גלוי לכולם), בוחרים באפשרות Internal (פנימי) ולוחצים על Next (הבא).
5. בקטע פריסה חוצת-אזורים או פריסה באזור יחיד, בוחרים באפשרות הכי מתאים לעומסי עבודה חוצי-אזורים ולוחצים על הבא.
6. לוחצים על Configure (הגדרה).

הגדרה בסיסית

1. מזינים שם למאזן העומסים.
2. בשדה רשת, בוחרים באפשרות NETWORK.

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

ל-HTTP:

1. לוחצים על Frontend configuration.
1. מזינים שם לכלל ההעברה.
2. ברשימה Subnetwork region, בוחרים באפשרות REGION_A.
   

   הזמנת תת-רשת לשימוש בשרת proxy בלבד

3. ברשימה Subnetwork בוחרים באפשרות SUBNET_A.
4. ברשימה IP address, לוחצים על Create IP address. ייפתח הדף שמירת כתובת IP פנימית סטטית.
• מזינים שם לכתובת ה-IP הסטטית.
• ברשימה Static IP address (כתובת IP סטטית), בוחרים באפשרות Let me choose (אני רוצה לבחור).
• בשדה כתובת IP מותאמת אישית, מזינים 10.1.2.99.
• לוחצים על הזמנה.
2. לוחצים על סיום.
3. כדי להוסיף את כלל ההעברה השני, לוחצים על הוספת כתובת IP ופורט של קצה קדמי.
1. מזינים שם לכלל ההעברה.
2. ברשימה Subnetwork region, בוחרים באפשרות REGION_B.
   

   הזמנת תת-רשת לשימוש בשרת proxy בלבד

3. ברשימה Subnetwork בוחרים באפשרות SUBNET_B.
4. ברשימה IP address, לוחצים על Create IP address. ייפתח הדף שמירת כתובת IP פנימית סטטית.
• מזינים שם לכתובת ה-IP הסטטית.
• ברשימה Static IP address (כתובת IP סטטית), בוחרים באפשרות Let me choose (אני רוצה לבחור).
• בשדה כתובת IP מותאמת אישית, מזינים 10.1.3.99.
• לוחצים על הזמנה.
4. לוחצים על סיום.

ל-HTTPS:

כדי להקצות אישור SSL לשרת ה-proxy של HTTPS של מאזן העומסים, צריך להשתמש באישור של Certificate Manager.

1. לוחצים על Frontend configuration.
1. מזינים שם לכלל ההעברה.
2. בשדה Protocol, בוחרים באפשרות HTTPS (includes HTTP/2).
3. מוודאים שהיציאה Port מוגדרת ל-443.
4. ברשימה Subnetwork region, בוחרים באפשרות REGION_A.
   

   הזמנת תת-רשת לשימוש בשרת proxy בלבד

5. ברשימה Subnetwork בוחרים באפשרות SUBNET_A.
6. ברשימה IP address, לוחצים על Create IP address. ייפתח הדף שמירת כתובת IP פנימית סטטית.
• מזינים שם לכתובת ה-IP הסטטית.
• ברשימה Static IP address (כתובת IP סטטית), בוחרים באפשרות Let me choose (אני רוצה לבחור).
• בשדה כתובת IP מותאמת אישית, מזינים 10.1.3.99.
• לוחצים על הזמנה.
7. לוחצים על הוספת אישור כדי לבחור אישור קיים או ליצור אישור חדש.

   אם כבר יש לכם אישור ב-Certificate Manager שאתם רוצים לבחור, אתם יכולים לפעול לפי השלבים הבאים:

   1. לוחצים על הוספת אישור.
   2. לוחצים על Select an existing certificate (בחירת אישור קיים) ובוחרים את האישור מתוך רשימת האישורים.
   3. לוחצים על בחירה.

   אחרי שבוחרים את האישור החדש של Certificate Manager, הוא מופיע ברשימת האישורים.

   כדי ליצור אישור חדש ב-Certificate Manager:

   1. לוחצים על הוספת אישור.
   2. לוחצים על יצירת אישור חדש.
   3. כדי ליצור אישור חדש, פועלים לפי השלבים שמתחילים משלב 3, כפי שמתואר באחת משיטות ההגדרה הבאות במסמכי התיעוד של Certificate Manager:
      • יצירת אישור בניהול Google עם הפניה לאישור DNS
      • יצירת אישור בניהול Google שהונפק על ידי מופע CA Service
      • העלאת אישור בניהול עצמי אל Certificate Manager
8. בוחרים מדיניות SSL מהרשימה מדיניות SSL. אם לא יצרתם מדיניות SSL, תחול מדיניות SSL שמוגדרת כברירת מחדל Google Cloud .
9. לוחצים על סיום.

מוסיפים את ההגדרה השנייה של הקצה הקדמי:

1. נותנים שם לתצורת הקצה הקדמי.
2. בשדה Protocol, בוחרים באפשרות HTTPS (includes HTTP/2).
3. מוודאים שהיציאה Port מוגדרת ל-443.
4. ברשימה Subnetwork region, בוחרים באפשרות REGION_B.
   

   הזמנת תת-רשת לשימוש בשרת proxy בלבד

5. ברשימה Subnetwork בוחרים באפשרות SUBNET_B.
6. ברשימה IP address, לוחצים על Create IP address. ייפתח הדף שמירת כתובת IP פנימית סטטית.
• מזינים שם לכתובת ה-IP הסטטית.
• ברשימה Static IP address (כתובת IP סטטית), בוחרים באפשרות Let me choose (אני רוצה לבחור).
• בשדה כתובת IP מותאמת אישית, מזינים 10.1.3.99.
• לוחצים על הזמנה.
7. לוחצים על Add certificate ובוחרים אישור קיים או יוצרים אישור חדש.
8. בוחרים מדיניות SSL מהרשימה מדיניות SSL. אם לא יצרתם מדיניות SSL, תחול מדיניות SSL שמוגדרת כברירת מחדל Google Cloud .
9. לוחצים על סיום.
הגדרת שירות הקצה העורפי
1. לוחצים על Backend configuration.
2. ברשימה Create or select backend services לוחצים על Create a backend service.
3. מזינים שם לשירות הקצה העורפי.
4. בשדה Protocol, בוחרים באפשרות HTTP.
5. בשדה Named Port (יציאה עם שם), מזינים http.
6. ברשימה Backend type (סוג ה-Backend), בוחרים באפשרות Instance group (קבוצת מופעים).
7. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:
• בשדה שם מזינים global-http-health-check.
• ברשימה Protocol, בוחרים באפשרות HTTP.
• בשדה יציאה, מזינים 80.
• לוחצים על יצירה.
8. בקטע New backend:
1. ברשימה Instance group בוחרים באפשרות gl4-ilb-miga in REGION_A.
2. מגדירים את Port numbers (ניוד מספרים) לערך 80.
3. בקטע מצב איזון, בוחרים באפשרות Utilization.
4. לוחצים על סיום.
5. כדי להוסיף עוד קצה עורפי, לוחצים על הוספת קצה עורפי.
6. ברשימה Instance group בוחרים באפשרות gl4-ilb-migb in REGION_B.
7. מגדירים את Port numbers (ניוד מספרים) לערך 80.
8. לוחצים על סיום.

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

1. לוחצים על כללי ניתוב.
2. בקטע Mode (מצב), בוחרים באפשרות Simple host and path rule (כלל פשוט של מארח ונתיב).
3. מוודאים שיש רק שירות קצה עורפי אחד לכל מארח שלא תואם ולכל נתיב שלא תואם.

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

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

gcloud

1. מגדירים את בדיקת תקינות ה-HTTP באמצעות הפקודה gcloud compute health-checks create http.

   gcloud compute health-checks create http global-http-health-check \
      --use-serving-port \
      --global
   

2. מגדירים את שירות הקצה העורפי באמצעות הפקודה gcloud compute backend-services create.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=global-http-health-check \
     --global-health-checks \
     --global
   

3. מוסיפים קצה עורפי לשירות הקצה העורפי באמצעות הפקודה gcloud compute backend-services add-backend.

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-a \
     --instance-group-zone=ZONE_A \
     --global
   

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-b \
     --instance-group-zone=ZONE_B \
     --global
   

4. יוצרים את מפת ה-URL באמצעות הפקודה gcloud compute url-maps create.

   gcloud compute url-maps create gl7-gilb-url-map \
     --default-service=BACKEND_SERVICE_NAME \
     --global
   

5. יוצרים את שרת ה-proxy של היעד.

   ל-HTTP:

   יוצרים את שרת ה-proxy של היעד באמצעות הפקודה gcloud compute target-http-proxies create.

   gcloud compute target-http-proxies create gil7-http-proxy \
     --url-map=gl7-gilb-url-map \
     --global
   

   ל-HTTPS:

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

   • יצירת אישור בניהול Google שהונפק על ידי מופע Certificate Authority Service.
   • יצירת אישור בניהול Google עם הרשאת DNS

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

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

   • יצירת מפתח פרטי ואישור.

   מקצים את נתיבי הקבצים לשמות משתנים.

   export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
   

   export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE
   

   יוצרים אישור SSL לכל האזורים באמצעות הפקודה gcloud beta certificate-manager certificates create.

   gcloud certificate-manager certificates create gilb-certificate \
     --private-key-file=$LB_PRIVATE_KEY \
     --certificate-file=$LB_CERT \
     --scope=all-regions
   

   משתמשים באישור ה-SSL כדי ליצור שרת proxy ליעד באמצעות הפקודה gcloud compute target-https-proxies create

   gcloud compute target-https-proxies create gil7-https-proxy \
     --url-map=gl7-gilb-url-map \
     --certificate-manager-certificates=gilb-certificate \
     --global
   

6. יוצרים שני כללי העברה, אחד עם כתובת VIP‏ (10.1.2.99) באזור REGION_B ואחד עם כתובת VIP‏ (10.1.3.99) באזור REGION_A. מידע נוסף זמין במאמר בנושא שמירת כתובת IPv4 פנימית סטטית.

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

   ל-HTTP:

   משתמשים בפקודה gcloud compute forwarding-rules create עם הדגלים המתאימים.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   ל-HTTPS:

   משתמשים בפקודה gcloud compute forwarding-rules create עם הדגלים המתאימים.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

Terraform

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

resource "google_compute_health_check" "default" {
  provider = google-beta
  name     = "global-http-health-check"
  http_health_check {
    port_specification = "USE_SERVING_PORT"
  }
}

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

resource "google_compute_backend_service" "default" {
  name                  = "gl7-gilb-backend-service"
  provider              = google-beta
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_region_instance_group_manager.mig_a.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
  backend {
    group           = google_compute_region_instance_group_manager.mig_b.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

כדי ליצור את מפת ה-URL, משתמשים במשאב google_compute_url_map.

resource "google_compute_url_map" "default" {
  name            = "gl7-gilb-url-map"
  provider        = google-beta
  default_service = google_compute_backend_service.default.id
}

כדי ליצור את ה-proxy של יעד HTTP, משתמשים במשאב google_compute_target_http_proxy.

resource "google_compute_target_http_proxy" "default" {
  name     = "gil7target-http-proxy"
  provider = google-beta
  url_map  = google_compute_url_map.default.id
}

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

resource "google_compute_global_forwarding_rule" "fwd_rule_a" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_a]
  ip_address            = "10.1.2.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-a"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_a.id
}

resource "google_compute_global_forwarding_rule" "fwd_rule_b" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_b]
  ip_address            = "10.1.3.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-b"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_b.id
}

כדי ללמוד איך להחיל הגדרות ב-Terraform או להסיר אותן, ראו פקודות בסיסיות ב-Terraform.

API

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

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

{
"name": "global-http-health-check",
"type": "HTTP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

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

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

{
"name": "BACKEND_SERVICE_NAME",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a",
    "balancingMode": "UTILIZATION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

כדי ליצור את מפת ה-URL, שולחים בקשת POST ל-method‏ urlMaps.insert ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME"
}

ל-HTTP:

יוצרים את שרת ה-proxy של HTTP ביעד על ידי שליחת בקשת POST אל השיטה targetHttpProxies.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map"
}

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

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

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil7forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

ל-HTTPS:

קוראים את קובצי האישור והמפתח הפרטי, ואז יוצרים את אישור ה-SSL. בדוגמה הבאה אפשר לראות איך עושים את זה באמצעות Python.

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

יוצרים את ה-HTTPS proxy של היעד על ידי שליחת בקשת POST ל-method‏ targetHttpsProxies.insert, ומחליפים את PROJECT_ID במזהה הפרויקט.

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME
}

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

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

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "FWRULE_B",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

המסוף

כדי להפעיל או לשנות את הזיקה לסשן (session affinity) לשירות לקצה העורפי:

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

   כניסה לדף Load balancing

2. לוחצים על Backends.
3. לוחצים על gil7-backend-service (השם של שירות לקצה העורפי שיצרתם בדוגמה הזו), ואז לוחצים על Edit.
4. בדף Backend service details (פרטי שירות לקצה העורפי), לוחצים על Advanced configuration (הגדרה מתקדמת).
5. בקטע Session affinity (העדפה לסשן), בוחרים את סוג ההעדפה לסשן שרוצים.
6. לוחצים על עדכון.

gcloud

משתמשים בפקודות הבאות של Google Cloud CLI כדי לעדכן את שירות לקצה העורפי לסוגים שונים של זיקה לסשן (session affinity):

    gcloud compute backend-services update gil7-backend-service \
        --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \
        --global
    

API

כדי להגדיר את הזיקה לסשן (session affinity), שולחים בקשת `PATCH` אל ה-method‏ backendServices/patch.

    PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service
    {
    "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
    }
    

המסוף

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

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

כלל חומת אש יחיד לתעבורת נתונים יוצאת

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

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

   מעבר לכללי חומת האש

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

   • Name (שם): fr-deny-access
   • רשת: lb-network
   • עדיפות: 100
   • כיוון התנועה: תעבורת נתונים יוצאת (egress)
   • פעולה לגבי התאמה: דחייה
   • יעדים: תגי יעד שצוינו
   • תגי יעד: TARGET_TAG
   • מסנן יעד: טווחי כתובות IP
   • טווחי כתובות IP של היעד: 10.1.2.99
   • פרוטוקולים ויציאות:
     • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
     • מסמנים את התיבה tcp ומזינים את מספר היציאה 80.

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

מספר כללים של חומת אש לתעבורת נתונים יוצאת

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

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

   מעבר לכללי חומת האש

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

   • Name (שם): fr-deny-all-access-low-priority
   • רשת: lb-network
   • עדיפות: 200
   • כיוון התנועה: תעבורת נתונים יוצאת (egress)
   • פעולה לגבי התאמה: דחייה
   • יעדים: תגי יעד שצוינו
   • תגי יעד: TARGET_TAG
   • מסנן יעד: טווחי כתובות IP
   • טווחי כתובות IP של היעד: 10.1.2.99
   • פרוטוקולים ויציאות:
     • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
     • מסמנים את תיבת הסימון TCP ומזינים 80 כמספר היציאה.

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

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

   • Name (שם): fr-allow-some-access-high-priority
   • רשת: lb-network
   • עדיפות: 100
   • כיוון התנועה: תעבורת נתונים יוצאת (egress)
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: TARGET_TAG
   • מסנן יעד: טווחי כתובות IP
   • טווחי כתובות IP של היעד: 10.1.2.99
   • פרוטוקולים ויציאות:
     • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
     • מסמנים את תיבת הסימון TCP ומזינים 80 כמספר היציאה.

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

gcloud

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

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

כלל חומת אש יחיד לתעבורת נתונים יוצאת

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

gcloud compute firewall-rules create fr-deny-access \
    --network=lb-network \
    --action=deny \
    --direction=egress \
    --rules=tcp \
    --priority=100 \
    --destination-ranges=10.1.2.99 \
    --target-tags=TARGET_TAG

מספר כללים של חומת אש לתעבורת נתונים יוצאת

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

1. יוצרים את הכלל עם העדיפות הנמוכה יותר:

   gcloud compute firewall-rules create fr-deny-all-access-low-priority \
       --network=lb-network \
       --action=deny \
       --direction=egress \
       --rules=tcp \
       --priority=200 \
       --destination-ranges=10.1.2.99
   

2. יוצרים את הכלל עם העדיפות הגבוהה יותר:

   gcloud compute firewall-rules create fr-allow-some-access-high-priority \
       --network=lb-network \
       --action=allow \
       --direction=egress \
       --rules=tcp \
       --priority=100 \
       --destination-ranges=10.1.2.99 \
       --target-tags=TARGET_TAG
   

כדי להשתמש בחשבונות שירות במקום בתגים כדי לשלוט בגישה, משתמשים באפשרות --target-service-accounts במקום בדגל --target-tags כשיוצרים כללי חומת אש.

gcloud

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

   gcloud compute networks subnets create l7-ilb-restricted-subnet \
       --network=lb-network \
       --region=us-west1 \
       --range=10.127.0.0/24
   

2. יוצרים כלל העברה שבוחר כתובת מרשת המשנה. בדוגמה הבאה השתמשנו בכתובת 10.127.0.1 מרשת המשנה שנוצרה בשלב הקודם.

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
       --load-balancing-scheme=INTERNAL_MANAGED \
       --network=lb-network \
       --subnet=l7-ilb-restricted-subnet \
       --address=10.127.0.1 \
       --ports=80 \
       --global \
       --target-http-proxy=gil7-http-proxy
   

3. יוצרים כלל חומת אש שמגביל את תעבורת הנתונים שמיועדת לטווח כתובות ה-IP ברשת המשנה של כלל ההעברה (l7-ilb-restricted-subnet):

   gcloud compute firewall-rules create restrict-traffic-to-subnet \
       --network=lb-network \
       --action=deny \
       --direction=egress \
       --rules=tcp:80 \
       --priority=100 \
       --destination-ranges=10.127.0.0/24 \
       --target-tags=TARGET_TAG
   

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

gcloud

כדי ליצור רשומת DNS עם TTL של 30 שניות, משתמשים בפקודה gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

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

• ‫DNS_ENTRY: DNS או שם הדומיין של קבוצת הרשומות

  לדוגמה, service.example.com

• ‫REGION_A ו-REGION_B: האזורים שבהם הגדרתם את מאזן העומסים

API

כדי ליצור את רשומת ה-DNS, שולחים בקשת POST אל ה-method‏ ResourceRecordSets.create. מחליפים את PROJECT_ID במזהה הפרויקט.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

המסוף

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

   כניסה לדף Load balancing

2. לוחצים על השם של מאזן העומסים שרוצים לשנות.
3. לוחצים על editעריכה.
4. לוחצים על Frontend configuration.
5. מרחיבים את הקטע תכונות מתקדמות. בשדה HTTP keepalive timeout, מזינים ערך של זמן קצוב לתפוגה.
6. לוחצים על עדכון.
7. כדי לבדוק את השינויים, לוחצים על בדיקה וסיום ואז על עדכון.

gcloud

במאזן עומסים מסוג HTTP, מעדכנים את שרת ה-proxy של HTTP באמצעות הפקודה gcloud compute target-http-proxies update:

      gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
          --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
          --global
    

במאזן עומסים מסוג HTTPS, מעדכנים את שרת ה-proxy של HTTPS באמצעות הפקודה gcloud compute target-https-proxies update:

      gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
          --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
          --global
    

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

• ‫TARGET_HTTP_PROXY_NAME: השם של ה-proxy ל-HTTP של היעד.
• ‫TARGET_HTTPS_PROXY_NAME: השם של ה-proxy ל-HTTPS עם יעד.
• ‫HTTP_KEEP_ALIVE_TIMEOUT_SEC: ערך הזמן הקצוב לתפוגה של HTTP keepalive, מ-5 עד 600 שניות.

המסוף

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

   כניסה לדף Load balancing

2. לוחצים על השם של מאזן העומסים שרוצים לערוך את שירות לקצה העורפי שלו.

3. בדף Load balancer details (פרטי איזון העומסים), לוחצים על editEdit (עריכה).

4. בדף Edit cross-region internal Application Load Balancer, לוחצים על Backend configuration.

5. בדף Backend configuration (הגדרות ה-Backend), לוחצים על editEdit (עריכה) בשירות לקצה העורפי שרוצים לשנות.

6. גוללים למטה ומרחיבים את הקטע הגדרות מתקדמות.

7. בקטע Outlier detection (זיהוי חריגות), מסמנים את תיבת הסימון Enable (הפעלה).

8. לוחצים על editעריכה כדי להגדיר זיהוי של חריגים.

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

   מאפיין (property)	ערך
   שגיאות עוקבות	5
   Interval	1000
   זמן בסיסי להוצאת כרטיס	30000
   אחוז ההסרה המקסימלי	50
   אכיפה של רצף שגיאות	100

   בדוגמה הזו, ניתוח זיהוי החריגים מופעל כל שנייה. אם מספר קודי הסטטוס 5xx‏ HTTP הרצופים שמתקבלים על ידי שרת proxy של Envoy הוא חמישה או יותר, נקודת הקצה של ה-backend מוצאת ממאגר איזון העומסים של אותו שרת proxy של Envoy למשך 30 שניות. כשמגדירים את אחוז האכיפה ל-100%, שירות ה-Backend אוכף את ההוצאה של נקודות קצה לא תקינות ממאגרי איזון העומסים של אותם שרתי proxy ספציפיים של Envoy בכל פעם שהניתוח של זיהוי החריגים מופעל. אם התנאים להוצאה מתקיימים, אפשר להוציא עד 50% מנקודות הקצה בעורף מרשימת נקודות הקצה של מאגר איזון העומסים.

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

10. כדי לעדכן את שירות לקצה העורפי, לוחצים על עדכון.

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

gcloud

1. מייצאים את שירות ה-Backend לקובץ YAML.

   gcloud compute backend-services export BACKEND_SERVICE_NAME \
     --destination=BACKEND_SERVICE_NAME.yaml --global
   

   מחליפים את BACKEND_SERVICE_NAME בשם של שירות לקצה העורפי.

2. עורכים את הגדרת ה-YAML של שירות ה-Backend כדי להוסיף את השדות של זיהוי חריגות, כפי שמודגש בהגדרת ה-YAML הבאה, בקטע outlierDetection:

   בדוגמה הזו, ניתוח זיהוי החריגים מופעל כל שנייה. אם מספר קודי הסטטוס 5xx‏ HTTP הרצופים שמתקבלים על ידי שרת proxy של Envoy הוא חמישה או יותר, נקודת הקצה של ה-backend מוצאת ממאגר איזון העומסים של אותו שרת proxy של Envoy למשך 30 שניות. כשמגדירים את אחוז האכיפה ל-100%, שירות ה-Backend אוכף את ההוצאה של נקודות קצה לא תקינות ממאגרי איזון העומסים של אותם שרתי proxy ספציפיים של Envoy בכל פעם שהניתוח של זיהוי החריגים מופעל. אם התנאים להוצאה מתקיימים, אפשר להוציא עד 50% מנקודות הקצה בעורף מרשימת נקודות הקצה של מאגר איזון העומסים.

   name: BACKEND_SERVICE_NAME
   backends:
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
   outlierDetection:
     baseEjectionTime:
       nanos: 0
       seconds: 30
     consecutiveErrors: 5
     enforcingConsecutiveErrors: 100
     interval:
       nanos: 0
       seconds: 1
     maxEjectionPercent: 50
   port: 80
   selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
   sessionAffinity: NONE
   timeoutSec: 30
   ...
   

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

   • ‫BACKEND_SERVICE_NAME: השם של שירות ה-Backend
   • ‫PROJECT_ID: מזהה הפרויקט
   • ‫REGION_A ו-REGION_B: האזורים שבהם הוגדר מאזן העומסים.
   • ‫SERVERLESS_NEG_NAME: השם של ה-NEG הראשון ללא שרת
   • ‫SERVERLESS_NEG_NAME_2: השם של ה-NEG השני ללא שרת

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

   gcloud compute backend-services import BACKEND_SERVICE_NAME \
     --source=BACKEND_SERVICE_NAME.yaml --global
   

   התכונה 'זיהוי חריגות' מופעלת עכשיו בשירות הקצה העורפי.