הגדרת מאזן עומסים פנימי של אפליקציות (ALB) עם VPC משותף

המסוף

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

   מעבר לרשתות VPC

2. לוחצים על יצירת רשת VPC.
3. בשדה Name (שם), מזינים lb-network.

4. בקטע Subnets (רשתות משנה):

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

   2. בקטע New subnet, מזינים את הפרטים הבאים:

      • Name (שם): lb-frontend-and-backend-subnet

      • אזור: us-west1

      • טווח כתובות IP: 10.1.2.0/24

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

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

gcloud

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

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

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

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

Terraform

1. יוצרים רשת VPC:

   # Shared VPC network
   resource "google_compute_network" "lb_network" {
     name                    = "lb-network"
     provider                = google-beta
     project                 = "my-host-project-id"
     auto_create_subnetworks = false
   }

2. יוצרים תת-רשת באזור us-west1:

   # Shared VPC network - backend subnet
   resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
     name          = "lb-frontend-and-backend-subnet"
     provider      = google-beta
     project       = "my-host-project-id"
     region        = "us-west1"
     ip_cidr_range = "10.1.2.0/24"
     role          = "ACTIVE"
     network       = google_compute_network.lb_network.id
   }

המסוף

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

   מעבר לרשתות VPC

2. לוחצים על השם של רשת ה-VPC המשותפת: lb-network.
3. לוחצים על הוספת רשת משנה.
4. בשדה Name (שם), מזינים proxy-only-subnet.
5. בשדה אזור, בוחרים באפשרות us-west1.
6. מגדירים את Purpose (מטרה) לערך Regional Managed Proxy (שרת proxy מנוהל אזורי).
7. בשדה טווח כתובות IP, מזינים 10.129.0.0/23.
8. לוחצים על הוספה.

gcloud

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

gcloud compute networks subnets create proxy-only-subnet \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-west1 \
    --network=lb-network \
    --range=10.129.0.0/23

Terraform

יוצרים את תת-הרשת של ה-proxy בלבד:

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

המסוף

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

   לדף Firewall policies

2. לוחצים על יצירת כלל לחומת האש כדי ליצור את הכלל שיאפשר בדיקות תקינות של Cloud de Confiance :
• Name (שם): fw-allow-health-check
• רשת: lb-network
• כיוון התנועה: נכנסת
• פעולה בהתאמה: אישור
• יעדים: תגי יעד שצוינו
• תגי טירגוט: load-balanced-backend
• מסנן מקור: טווחי IPv4
• טווחים של כתובות IPv4 של המקור: 177.222.80.0/23
• פרוטוקולים ויציאות:
  • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
  • מסמנים את התיבה TCP ומזינים 80 כמספר היציאה.

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

3. לוחצים על יצירה.
4. לוחצים על יצירת כלל לחומת האש כדי ליצור את הכלל שיאפשר בדיקות תקינות של Cloud de Confiance :
• Name (שם): fw-allow-proxies
• רשת: lb-network
• כיוון התנועה: נכנסת
• פעולה בהתאמה: אישור
• יעדים: תגי יעד שצוינו
• תגי טירגוט: load-balanced-backend
• מסנן מקור: טווחי IPv4
• טווחי IPv4 של המקור: 10.129.0.0/23
• פרוטוקולים ויציאות:
  • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
  • מסמנים את התיבה TCP ומזינים את הערך 80, 443, 8080 בשדה של מספרי היציאות.
5. לוחצים על יצירה.
6. לוחצים על יצירת כלל לחומת האש כדי ליצור את הכלל שיאפשר בדיקות תקינות של Cloud de Confiance :
• Name (שם): fw-allow-ssh
• רשת: lb-network
• כיוון התנועה: נכנסת
• פעולה בהתאמה: אישור
• יעדים: תגי יעד שצוינו
• תגי טירגוט: allow-ssh
• מסנן מקור: טווחי IPv4
• טווחי IPv4 של המקור: 0.0.0.0/0
• פרוטוקולים ויציאות:
  • בוחרים באפשרות פרוטוקולים ויציאות שצוינו.
  • מסמנים את התיבה TCP ומזינים 22 כמספר היציאה.
7. לוחצים על יצירה.

gcloud

1. יוצרים את כלל חומת האש fw-allow-health-check כדי לאפשרCloud de Confiance בדיקות תקינות. בדוגמה הזו, כל תנועת ה-TCP מבודקי בדיקת תקינות מורשית. עם זאת, אפשר להגדיר קבוצה מצומצמת יותר של יציאות בהתאם לצרכים שלכם.

   gcloud compute firewall-rules create fw-allow-health-check \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=177.222.80.0/23 \
      --target-tags=load-balanced-backend \
      --rules=tcp
   

2. יוצרים את fw-allow-proxies כלל חומת האש כדי לאפשר לתעבורת נתונים מתת-הרשת של שרת proxy בלבד של Envoy להגיע לשרתים העורפיים.

   gcloud compute firewall-rules create fw-allow-proxies \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=10.129.0.0/23 \
      --target-tags=load-balanced-backend \
      --rules=tcp:80,tcp:443,tcp:8080
   

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

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

Terraform

1. יוצרים כלל חומת אש שמאפשר בדיקות תקינות Cloud de Confiance .

   מידע נוסף על טווחי בדיקות תקינות זמין במאמר בנושא Cloud de Confiance כללים של חומת אש וטווחי כתובות IP של בדיקות.

   resource "google_compute_firewall" "fw_allow_health_check" {
     name          = "fw-allow-health-check"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
     allow {
       protocol = "tcp"
     }
     target_tags = ["load-balanced-backend"]
   }

2. יוצרים כלל חומת אש שמאפשר תעבורת נתונים מתת-רשת של שרת proxy בלבד של Envoy לשרתים העורפיים.

   resource "google_compute_firewall" "fw_allow_proxies" {
     name          = "fw-allow-proxies"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["10.129.0.0/23"]
     allow {
       protocol = "tcp"
       ports    = ["80", "443", "8080"]
     }
     target_tags = ["load-balanced-backend"]
   }

3. יוצרים כלל חומת אש שמאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh.

   resource "google_compute_firewall" "fw_allow_ssh" {
     name          = "fw-allow-ssh"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["0.0.0.0/0"]
     allow {
       protocol = "tcp"
       ports    = ["22"]
     }
     target_tags = ["allow-ssh"]
   }

המסוף

1. יוצרים תבנית של הגדרות מכונה. נכנסים לדף Instance templates במסוף Cloud de Confiance .

   כניסה לדף Instance templates

   1. לוחצים על Create instance template.
   2. בשדה Name (שם), מזינים l7-ilb-backend-template.
   3. מוודאים שדיסק האתחול מוגדר לקובץ אימג' של Debian, כמו Debian GNU/Linux 12 (bookworm)‎. בהוראות האלה נעשה שימוש בפקודות שזמינות רק ב-Debian, כמו apt-get. אם צריך לשנות את דיסק האתחול, לוחצים על שינוי.
      1. בקטע Operating System (מערכת הפעלה), בוחרים באפשרות Debian.
      2. בקטע Version, בוחרים אחד מקובצי האימג' הזמינים של Debian, כמו Debian GNU/Linux 12 (bookworm)‎.
      3. לוחצים על בחירה.
   4. לוחצים על אפשרויות מתקדמות ואז על רשת.
   5. מזינים את תגי הרשת הבאים: allow-ssh,load-balanced-backend.
   6. בקטע Network interfaces, בוחרים באפשרות Networks shared with me (from host project: HOST_PROJECT_ID).
   7. בוחרים את רשת המשנה lb-frontend-and-backend-subnet מהרשת lb-network.
   8. לוחצים על ניהול. בקטע ניהול, מזינים את הסקריפט הבא בשדה סקריפט לטעינה בזמן ההפעלה.

       #! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       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
       systemctl restart apache2
       

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

2. יוצרים קבוצה של מופעי מכונה מנוהלים. נכנסים לדף Instance groups במסוף Cloud de Confiance .

   כניסה לדף Instance groups

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

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

      בדוגמה הזו, מציינים את האפשרויות הבאות עבור התאמה אוטומטית לעומס (automatic scaling):

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

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

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

gcloud

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

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

   gcloud compute instance-templates create l7-ilb-backend-template \
   --region=us-west1 \
   --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
   --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
   --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://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   systemctl restart apache2' \
   --project=SERVICE_PROJECT_ID
   

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

   gcloud compute instance-groups managed create l7-ilb-backend-example \
       --zone=us-west1-a \
       --size=2 \
       --template=l7-ilb-backend-template \
       --project=SERVICE_PROJECT_ID
   

Terraform

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

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-12"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     metadata = {
       startup-script = <<EOF
       #! /bin/bash
       sudo apt-get update
       sudo apt-get install apache2 -y
       sudo a2ensite default-ssl
       sudo a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

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

   ל-HTTP:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   ל-HTTPS:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

המסוף

החלפת ההקשר לפרויקט השירות

1. נכנסים לדף Dashboard במסוף Cloud de Confiance .

   כניסה ללוח הבקרה

2. לוחצים על הרשימה Select from (בחירה מתוך) בחלק העליון של הדף. בחלון Select from שמופיע, בוחרים את פרויקט השירות שבו רוצים ליצור את מאזן העומסים.

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

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

   כניסה לדף 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. בשדה Name של מאזן העומסים, מזינים l7-ilb-shared-vpc.
2. בקטע אזור, בוחרים באפשרות us-west1.

3. בקטע Network, בוחרים באפשרות lb-network (מתוך Project: HOST_PROJECT_ID).

   אם מופיעה האזהרה נדרשת תת-רשת של Proxy ברשת VPC משותפת, צריך לוודא שהאדמין של הפרויקט המארח יצר את proxy-only-subnet באזור us-west1 ברשת ה-VPC המשותפת lb-network. יצירת איזון העומסים מצליחה גם אם אין לכם הרשאה לצפות ברשת המשנה של ה-proxy בלבד בדף הזה.

4. כדי להמשיך, צריך להשאיר את החלון פתוח.

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

1. לוחצים על Backend configuration.
2. בתפריט Create or select backend services (יצירה או בחירה של שירותי קצה עורפי), בוחרים באפשרות Create a backend service (יצירה של שירות קצה עורפי).
3. מגדירים את Name של שירות הקצה העורפי לערך l7-ilb-backend-service.
4. מגדירים את סוג הבק-אנד בתור קבוצות של מכונות.
5. ברשימה בדיקת תקינות, בוחרים באפשרות יצירת בדיקת תקינות ומזינים את הפרטים הבאים:
   1. Name (שם): l7-ilb-basic-check
   2. ‫Protocol: HTTP
   3. יציאה: 80
6. לוחצים על יצירה.

7. בקטע New backend:

   1. מגדירים את Instance group ל-l7-ilb-backend-example.
   2. מגדירים את Port numbers (מספרי יציאה) ל-80.
   3. מגדירים את Balancing mode (מצב איזון) בתור Utilization (ניצול).
   4. לוחצים על סיום.

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

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

• לוחצים על כללי ניתוב. מוודאים ש-l7-ilb-backend-service הוא שירות הקצה העורפי היחיד לכל מארח שלא תואם ולכל נתיב שלא תואם.

מידע על ניהול תנועה מופיע במאמר הגדרת ניהול תנועה.

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

ל-HTTP:

1. לוחצים על Frontend configuration.
2. מגדירים את Name לערך l7-ilb-forwarding-rule.
3. מגדירים את Protocol ל-HTTP.
4. מגדירים את Subnetwork ל-lb-frontend-and-backend-subnet. אל תבחרו ברשת המשנה של ה-frontend רק לשרתי proxy, גם אם היא מופיעה ברשימה.
5. מגדירים את Port ל-80.
6. לוחצים על התפריט IP address ואז על Create IP address.
7. בחלונית Reserve a static internal IP address, מציינים את הפרטים הבאים:
   1. בשדה Name (שם), מזינים ip-address-shared-vpc.
   2. בקטע כתובת IP סטטית, לוחצים על אני רוצה לבחור. בשדה כתובת IP מותאמת אישית, מזינים 10.1.2.99.
   3. (אופציונלי) אם רוצים לשתף את כתובת ה-IP הזו עם חזיתות קצה שונות, צריך להגדיר את הייעוד כמשותף.
8. לוחצים על סיום.

ל-HTTPS:

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

1. לוחצים על Frontend configuration.
2. בשדה שם מזינים l7-ilb-forwarding-rule.
3. בשדה Protocol, בוחרים באפשרות HTTPS (includes HTTP/2).
4. מגדירים את Subnetwork ל-lb-frontend-and-backend-subnet. אל תבחרו ברשת המשנה של ה-frontend רק לשרתי proxy, גם אם היא מופיעה ברשימה.
5. מוודאים שהיציאה מוגדרת ל-443 כדי לאפשר תנועת HTTPS.
6. לוחצים על התפריט IP address ואז על Create IP address.
7. בחלונית Reserve a static internal IP address, מציינים את הפרטים הבאים:
   1. בשדה Name (שם), מזינים ip-address-shared-vpc.
   2. בקטע כתובת IP סטטית, לוחצים על אני רוצה לבחור. בשדה כתובת IP מותאמת אישית, מזינים 10.1.2.99.
   3. (אופציונלי) אם רוצים לשתף את כתובת ה-IP הזו עם חזיתות קצה שונות, צריך להגדיר את הייעוד כמשותף.
8. לוחצים על הרשימה אישור.
   1. אם כבר יש לכם משאב של אישור SSL בניהול עצמי שבו אתם רוצים להשתמש כאישור ה-SSL הראשי, בוחרים אותו מהתפריט.
   2. אחרת, בוחרים באפשרות Create a new certificate (יצירת אישור חדש).
      1. מזינים שם של l7-ilb-cert.
      2. בשדות המתאימים, מעלים את הקבצים בפורמט PEM:
         • אישור של מפתח ציבורי
         • שרשרת אישורים
         • מפתח פרטי
      3. לוחצים על יצירה.
9. כדי להוסיף משאבי אישורים בנוסף למשאב אישור ה-SSL הראשי:
   1. לוחצים על הוספת אישור.
   2. בוחרים אישור מהרשימה Certificates או לוחצים על Create a new certificate ופועלים לפי ההוראות הקודמות.
10. לוחצים על סיום.

בדיקה וסיום של ההגדרה

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

gcloud

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

   gcloud compute health-checks create http l7-ilb-basic-check \
      --region=us-west1 \
      --use-serving-port \
      --project=SERVICE_PROJECT_ID
   

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

   gcloud compute backend-services create l7-ilb-backend-service \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=l7-ilb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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

   gcloud compute backend-services add-backend l7-ilb-backend-service \
     --balancing-mode=UTILIZATION \
     --instance-group=l7-ilb-backend-example \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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

   gcloud compute url-maps create l7-ilb-map \
     --default-service=l7-ilb-backend-service \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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

   ל-HTTP:

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

   gcloud compute target-http-proxies create l7-ilb-proxy \
     --url-map=l7-ilb-map \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   ל-HTTPS:

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

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

   export LB_CERT=path to PEM-formatted file
   

   export LB_PRIVATE_KEY=path to PEM-formatted file
   

   יוצרים אישור SSL אזורי באמצעות הפקודה gcloud compute ssl-certificates create.

   gcloud compute ssl-certificates create l7-ilb-cert \
     --certificate=$LB_CERT \
     --private-key=$LB_PRIVATE_KEY \
     --region=us-west1
   

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

   gcloud compute target-https-proxies create l7-ilb-proxy \
     --url-map=l7-ilb-map \
     --region=us-west1 \
     --ssl-certificates=l7-ilb-cert \
     --project=SERVICE_PROJECT_ID
   

6. יוצרים את כלל ההעברה.

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

   לכתובת ה-IP של כלל ההעברה, משתמשים ב-lb-frontend-and-backend-subnet. אם מנסים להשתמש ברשת משנה ל-Proxy בלבד, יצירת כלל ההעברה נכשלת.

   ל-HTTP:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-ilb-proxy \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   ל-HTTPS:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=l7-ilb-proxy \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

Terraform

1. הגדרת בדיקת תקינות HTTP.

   ל-HTTP:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   ל-HTTPS:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

2. מגדירים את שירות הקצה העורפי.

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. יוצרים את מפת ה-URL.

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

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

   ל-HTTP:

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   ל-HTTPS: יוצרים אישור SSL אזורי

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

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   שימוש באישור SSL אזורי ליצירת שרת proxy ליעד

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

5. יוצרים את כלל ההעברה.

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

   ל-HTTP:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   ל-HTTPS:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

המסוף

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

   כניסה לדף VM instances

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

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

4. מגדירים את Zone לערך us-west1-a.

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

6. מזינים את תגי הרשת הבאים: allow-ssh,load-balanced-backend.

7. בקטע Network interfaces, בוחרים באפשרות Networks shared with me (from host project: HOST_PROJECT_ID).

8. בוחרים את רשת המשנה lb-frontend-and-backend-subnet מהרשת lb-network.

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

gcloud

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

gcloud compute instances create client-vm \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

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

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

המסוף

1. יוצרים תבנית של הגדרות מכונה. נכנסים לדף Instance templates במסוף Cloud de Confiance .

   כניסה לדף Instance templates

   1. לוחצים על Create instance template.
   2. מזינים שם לתבנית של הגדרות מכונה: cross-ref-backend-template.
   3. מוודאים שדיסק האתחול מוגדר לקובץ אימג' של Debian, כמו Debian GNU/Linux 12 (bookworm)‎. בהוראות האלה נעשה שימוש בפקודות שזמינות רק ב-Debian, כמו apt-get. אם צריך לשנות את דיסק האתחול, לוחצים על שינוי.
      1. בקטע Operating System (מערכת הפעלה), בוחרים באפשרות Debian.
      2. בקטע Version, בוחרים אחד מקובצי האימג' הזמינים של Debian, כמו Debian GNU/Linux 12 (bookworm)‎.
      3. לוחצים על בחירה.
   4. לוחצים על אפשרויות מתקדמות ואז על רשת.
   5. מזינים את תגי הרשת הבאים: allow-ssh,load-balanced-backend.
   6. בקטע Network interfaces, בוחרים באפשרות Networks shared with me (from host project: HOST_PROJECT_ID).
   7. בוחרים את רשת המשנה lb-frontend-and-backend-subnet מהרשת lb-network.
   8. לוחצים על ניהול. בקטע ניהול, מזינים את הסקריפט הבא בשדה סקריפט לטעינה בזמן ההפעלה.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      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
      systemctl restart apache2
      

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

2. יוצרים קבוצה של מופעי מכונה מנוהלים. נכנסים לדף Instance groups במסוף Cloud de Confiance .

   כניסה לדף Instance groups

   1. לוחצים על יצירת קבוצת מופעים.
   2. בוחרים באפשרות New managed instance group (stateless) (קבוצת מופעי מכונה מנוהלים חדשה (בלי שמירת מצב)). מידע נוסף מופיע במאמר קבוצות של מכונות וירטואליות בלי שמירת מצב או עם שמירת מצב.
   3. מזינים שם לקבוצת המופעים: cross-ref-ig-backend.
   4. בקטע מיקום, בוחרים באפשרות אזור יחיד.
   5. בשדה אזור, בוחרים באפשרות us-west1.
   6. בשדה Zone, בוחרים באפשרות us-west1-a.
   7. בשדה תבנית של הגדרות מכונה, בוחרים באפשרות cross-ref-backend-template.

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

      בדוגמה הזו, מציינים את האפשרויות הבאות עבור התאמה אוטומטית לעומס (automatic scaling):

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

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

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

3. יוצרים שירות לקצה עורפי אזורי. במסגרת השלב הזה, ניצור גם את בדיקת תקינות ונוסיף את ה-backends לשירות לקצה העורפי. נכנסים לדף Backends במסוף Cloud de Confiance .

   כניסה לדף Backends

   1. לוחצים על Create regional backend service.
   2. מזינים שם לשירות הקצה העורפי: cross-ref-backend-service.
   3. בשדה Region, בוחרים us-west1.
   4. בשדה Load balancer type, בוחרים באפשרות Regional internal Application Load Balancer (INTERNAL_MANAGED).
   5. מגדירים את Backend type (סוג הבק-אנד) בתור Instance groups (קבוצות של מכונות).
   6. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:
      1. Name (שם): cross-ref-http-health-check
      2. ‫Protocol: HTTP
      3. יציאה: 80
   7. לוחצים על יצירה.
   8. בקטע Backends, מגדירים את Network לערך lb-network.
   9. לוחצים על הוספת קצה עורפי ומגדירים את השדות הבאים:
      1. מגדירים את Instance group (קבוצת מופעים) ל-cross-ref-ig-backend.
      2. מזינים את מספרי היציאה: 80.
      3. מגדירים את Balancing mode (מצב איזון) לערך Utilization (ניצול).
      4. לוחצים על סיום.
   10. לוחצים על Continue.

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

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

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

gcloud

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

   gcloud compute instance-templates create BACKEND_IG_TEMPLATE \
       --region=us-west1 \
       --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
       --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
       --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://metadata.google.internal/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2' \
       --project=SERVICE_PROJECT_B_ID
   

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

   • ‫BACKEND_IG_TEMPLATE: השם של תבנית קבוצת המכונות.
   • ‫SERVICE_PROJECT_B_ID: מזהה הפרויקט של פרויקט שירות ב', שבו נוצרים קצוות העורף של מאזן העומסים ושירות קצה העורף.
   • ‫HOST_PROJECT_ID: מזהה הפרויקט של פרויקט המארח של ה-VPC המשותף.

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

   gcloud compute instance-groups managed create BACKEND_MIG \
       --zone=us-west1-a \
       --size=2 \
       --template=BACKEND_IG_TEMPLATE \
       --project=SERVICE_PROJECT_B_ID
   

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

   • ‫BACKEND_MIG: השם של קבוצת שרתי העורף.

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

   gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
     --region=us-west1 \
     --use-serving-port \
     --project=SERVICE_PROJECT_B_ID
   

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

   • ‫HTTP_HEALTH_CHECK_NAME: השם של בדיקת תקינות ה-HTTP.

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

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=HTTP_HEALTH_CHECK_NAME \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

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

   • ‫BACKEND_SERVICE_NAME: השם של שירות לקצה העורפי שנוצר בפרויקט השירות B.

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

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=BACKEND_MIG \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

Terraform

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

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-b-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-12"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     metadata = {
       startup-script = <<EOF
       #! /bin/bash
       sudo apt-get update
       sudo apt-get install apache2 -y
       sudo a2ensite default-ssl
       sudo a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

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

   ל-HTTP

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   ל-HTTPS

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

3. יצירת בדיקת תקינות לשרת העורפי.

   ל-HTTP

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   ל-HTTPS

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

4. יוצרים שירות לקצה עורפי אזורי.

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-b-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

המסוף

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

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

   כניסה לדף 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. בקטע אזור, בוחרים באפשרות us-west1.

3. בקטע Network, בוחרים באפשרות lb-network (מתוך Project: HOST_PROJECT_NAME).

   אם מופיעה האזהרה נדרשת תת-רשת של Proxy ברשת VPC משותפת, צריך לוודא שהאדמין של הפרויקט המארח יצר את proxy-only-subnet באזור us-west1 ברשת ה-VPC המשותפת lb-network. יצירת איזון העומסים מצליחה גם אם אין לכם הרשאה לצפות ברשת המשנה של ה-proxy בלבד בדף הזה.

4. כדי להמשיך, צריך להשאיר את החלון פתוח.

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

1. לוחצים על Backend configuration.
2. לוחצים על Cross-project backend services (שירותי קצה עורפיים בין פרויקטים).
3. בשדה מזהה הפרויקט, מזינים את מזהה הפרויקט של פרויקט שירות ב'.
4. ברשימה Select backend services, בוחרים את שירותי ה-Backend מפרויקט השירות B שרוצים להשתמש בהם. בדוגמה הזו, מזינים את הערך cross-ref-backend-service.
5. לוחצים על OK.

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

• לוחצים על כללי ניתוב. מוודאים ש-cross-ref-backend-service הוא שירות הקצה העורפי היחיד עבור כל מארח שלא נמצאה לו התאמה ועבור כל נתיב שלא נמצאה לו התאמה.

מידע על ניהול תנועה מופיע במאמר הגדרת ניהול תנועה.

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

כדי שהפניה לשירותים בין פרויקטים תפעל, חובה להשתמש בקצה הקדמי באותה רשת (lb-network) מפרויקט המארח של ה-VPC המשותף ששימשה ליצירת שירות לקצה העורפי.

ל-HTTP:

1. לוחצים על Frontend configuration.
2. מזינים שם לכלל ההעברה: cross-ref-http-forwarding-rule.
3. מגדירים את Protocol ל-HTTP.
4. מגדירים את Subnetwork ל-lb-frontend-and-backend-subnet. אל תבחרו ברשת המשנה של ה-frontend רק לשרתי proxy, גם אם היא מופיעה ברשימה.
5. מגדירים את Port ל-80.
6. לוחצים על התפריט IP address ואז על Create IP address.
7. בחלונית Reserve a static internal IP address, מציינים את הפרטים הבאים:
   1. בשדה Name (שם), מזינים cross-ref-ip-address.
   2. בקטע כתובת IP סטטית, לוחצים על אני רוצה לבחור. בשדה כתובת IP מותאמת אישית, מזינים 10.1.2.98.
   3. (אופציונלי) אם רוצים לשתף את כתובת ה-IP הזו עם חזיתות קצה שונות, צריך להגדיר את הייעוד כמשותף.
8. לוחצים על סיום.

ל-HTTPS:

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

1. לוחצים על Frontend configuration.
2. מזינים שם לכלל ההעברה: cross-ref-https-forwarding-rule.
3. בשדה Protocol, בוחרים באפשרות HTTPS (includes HTTP/2).
4. מגדירים את Subnetwork ל-lb-frontend-and-backend-subnet. אל תבחרו ברשת המשנה של ה-frontend רק לשרתי proxy, גם אם היא מופיעה ברשימה.
5. מוודאים שהיציאה מוגדרת ל-443 כדי לאפשר תנועת HTTPS.
6. לוחצים על התפריט IP address ואז על Create IP address.
7. בחלונית Reserve a static internal IP address, מציינים את הפרטים הבאים:
   1. בשדה Name (שם), מזינים cross-ref-ip-address.
   2. בקטע כתובת IP סטטית, לוחצים על אני רוצה לבחור. בשדה כתובת IP מותאמת אישית, מזינים 10.1.2.98.
   3. (אופציונלי) אם רוצים לשתף את כתובת ה-IP הזו עם חזיתות קצה שונות, צריך להגדיר את הייעוד כמשותף.
8. לוחצים על הרשימה אישור.
   1. אם כבר יש לכם משאב של אישור SSL בניהול עצמי שבו אתם רוצים להשתמש כאישור ה-SSL הראשי, בוחרים אותו מהתפריט.
   2. אחרת, בוחרים באפשרות Create a new certificate (יצירת אישור חדש).
      1. מזינים שם לאישור ה-SSL.
      2. בשדות המתאימים, מעלים את הקבצים בפורמט PEM:
         • אישור של מפתח ציבורי
         • שרשרת אישורים
         • מפתח פרטי
      3. לוחצים על יצירה.
9. כדי להוסיף משאבי אישורים בנוסף למשאב אישור ה-SSL הראשי:
   1. לוחצים על הוספת אישור.
   2. בוחרים אישור מהרשימה Certificates או לוחצים על Create a new certificate ופועלים לפי ההוראות הקודמות.
10. לוחצים על סיום.

בדיקה וסיום של ההגדרה

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

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

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

gcloud

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

   gcloud compute backend-services list-usable \
       --region=us-west1 \
       --project=SERVICE_PROJECT_B_ID
   

2. יוצרים את מפת ה-URL ומגדירים את שירות ברירת המחדל לשירות לקצה העורפי שנוצר בפרויקט השירות ב'.

   gcloud compute url-maps create URL_MAP_NAME \
       --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
       --region=us-west1 \
       --project=SERVICE_PROJECT_A_ID
   

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

   • URL_MAP_NAME: השם של מפת ה-URL.
   • ‫BACKEND_SERVICE_NAME: השם של שירות לקצה העורפי שנוצר בפרויקט השירות B.
   • ‫SERVICE_PROJECT_B_ID: מזהה הפרויקט של פרויקט שירות ב', שבו נוצרו העורפים של מאזן העומסים ושירות העורף.
   • ‫SERVICE_PROJECT_A_ID: מזהה הפרויקט של פרויקט השירות א', שבו נוצר קצה קדמי של מאזן העומסים.

   יצירת מפת URL תיכשל אם אין לכם את ההרשאה compute.backendServices.use לשירות לקצה העורפי בפרויקט השירות ב.

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

   ל-HTTP:

   gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

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

   • ‫HTTP_TARGET_PROXY_NAME: השם של ה-proxy ל-HTTP של היעד.

   ל-HTTPS:

   יוצרים אישור SSL אזורי באמצעות הפקודה gcloud compute ssl-certificates create.

   gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
     --certificate=PATH_TO_CERTIFICATE \
     --private-key=PATH_TO_PRIVATE_KEY \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

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

   • ‫SSL_CERTIFICATE_NAME: השם של משאב אישור ה-SSL.
   • ‫PATH_TO_CERTIFICATE: הנתיב לקובץ אישור ה-SSL המקומי בפורמט PEM.
   • ‫PATH_TO_PRIVATE_KEY: הנתיב למפתח הפרטי של אישור ה-SSL המקומי בפורמט PEM.

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

   gcloud compute target-https-proxies create HTTPS_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --region=us-west1 \
     --ssl-certificates=SSL_CERTIFICATE_NAME \
     --project=SERVICE_PROJECT_A_ID
   

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

   • ‫HTTPS_TARGET_PROXY_NAME: השם של שרת ה-proxy ל-HTTPS של היעד.

4. יוצרים את כלל ההעברה. כדי שהפניה לשירות בין פרויקטים תפעל, כלל ההעברה צריך להשתמש באותה רשת (lb-network) מפרויקט המארח של ה-VPC המשותף ששימש ליצירת שירות ה-Backend.

   ל-HTTP:

   gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=HTTP_TARGET_PROXY_NAME \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

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

   • ‫HTTP_FORWARDING_RULE_NAME: השם של כלל ההעברה שמשמש לטיפול בתעבורת HTTP.

   ל-HTTPS:

   gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

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

   • ‫HTTPS_FORWARDING_RULE_NAME: השם של כלל ההעברה שמשמש לטיפול בתנועה מסוג HTTPS.

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

Terraform

1. יוצרים את מפת ה-URL.

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-a-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

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

   ל-HTTP

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-a-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   ל-HTTPS

   יצירת אישור SSL אזורי

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-a-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   שימוש באישור SSL אזורי ליצירת שרת proxy ליעד

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-a-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

3. יוצרים את כלל ההעברה.

   ל-HTTP

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   ל-HTTPS

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

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

המסוף

הרשאות ברמת הפרויקט

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

כדי להשלים את השלב הזה, צריך את ההרשאות compute.regionBackendServices.setIamPolicy ו-resourcemanager.projects.setIamPolicy.

1. נכנסים לדף IAM במסוף Cloud de Confiance .

   כניסה לדף IAM

2. בוחרים את הפרויקט הרצוי.

3. לוחצים על person_addGrant access.

4. בשדה New principals, מזינים את כתובת האימייל או מזהה אחר של החשבון הראשי.

5. ברשימה Select a role בוחרים באפשרות Compute Load Balancer Services User.

6. אם רוצים, מוסיפים תנאי לתפקיד.

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

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

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

כדי להשלים את השלב הזה, נדרשת ההרשאה compute.regionBackendServices.setIamPolicy.

1. נכנסים לדף Backends במסוף Cloud de Confiance .

   כניסה לדף Backends

2. ברשימת שירותי ה-Backend, בוחרים את שירות ה-Backend שרוצים לתת לו גישה ולוחצים על person_addהרשאות.

3. לוחצים על person_addAdd principal.

4. בשדה New principals, מזינים את כתובת האימייל או מזהה אחר של החשבון הראשי.

5. ברשימה Select a role בוחרים באפשרות Compute Load Balancer Services User.

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

gcloud

הרשאות ברמת הפרויקט

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

כדי להשלים את השלב הזה, צריך את ההרשאות compute.regionBackendServices.setIamPolicy ו-resourcemanager.projects.setIamPolicy.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

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

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

כדי להשלים את השלב הזה, נדרשת ההרשאה compute.regionBackendServices.setIamPolicy.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

או

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

כדי להשתמש בפקודות האלה, מחליפים את LOAD_BALANCER_ADMIN בפרינציפל של המשתמש, למשל test-user@gmail.com.

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

gcloud

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

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
    --region REGION

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

• ‫BACKEND_SERVICE_NAME: השם של השירות לקצה העורפי של מאזן העומסים
• ‫REGION: האזור של מאזן העומסים

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

id: '123456789'
kind: compute#backendService
loadBalancingScheme: INTERNAL_MANAGED
...
usedBy:
-   reference: https://www.googleapis.com/compute/v1/projects/my-project/region/us-central1/urlMaps/my-url-map