Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

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

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

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

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

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

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

מומלץ לקרוא את המאמר סקירה כללית על VPC משותף.
קוראים את הסקירה הכללית על מאזן עומסים פנימי של אפליקציות, כולל הקטע ארכיטקטורות של VPC משותף.

ההרשאות הנדרשות

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

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

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

הגדרת VPC משותף

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

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

צריך לבצע את המשימות האלה בפרויקט המארח של ה-VPC המשותף. מומלץ שאדמין ה-VPC המשותף יהיה גם הבעלים של הפרויקט המארח של ה-VPC המשותף. התפקידים 'אדמין רשת' ו'אדמין לענייני אבטחה' מוקצים אוטומטית.

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

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

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

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

פריסת מאזן עומסים וקצה עורפי

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

תפקידים שמוענקים בפרויקט השירות

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

דרישות מוקדמות

בקטע הזה, צריך לבצע את השלבים הבאים:

מגדירים את הרשת ואת רשתות המשנה בפרויקט המארח.
הגדרת VPC משותף בפרויקט המארח.

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

הגדרת הרשתות ורשתות המשנה בפרויקט המארח

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

בדוגמה הזו נעשה שימוש ברשת, באזור וברשתות המשנה הבאים:

רשת. שם הרשת הוא lb-network.
רשת משנה לקצה הקדמי ולשרתי הבק-אנד של מאזן העומסים. רשת משנה בשם lb-frontend-and-backend-subnet באזור us-west1 משתמשת ב-10.1.2.0/24 כטווח כתובות ה-IP הראשי שלה.
רשת משנה עבור שרתי proxy. רשת משנה בשם proxy-only-subnet באזור us-west1 משתמשת ב-10.129.0.0/23 כטווח ה-IP הראשי שלה.

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

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

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

המסוף

נכנסים לדף VPC networks במסוף Google Cloud .
מעבר לרשתות VPC
לוחצים על יצירת רשת VPC.
בשדה Name (שם), מזינים lb-network.
בקטע Subnets (רשתות משנה):
1. מגדירים את מצב יצירת רשתות משנה לבהתאמה אישית.
2. בקטע New subnet (רשת משנה חדשה), מזינים את הפרטים הבאים:
  - Name (שם): lb-frontend-and-backend-subnet
  - אזור: us-west1
  - טווח כתובות IP: 10.1.2.0/24
3. לוחצים על סיום.
לוחצים על יצירה.

gcloud

יוצרים רשת VPC באמצעות הפקודה gcloud compute networks create:
```
gcloud compute networks create lb-network --subnet-mode=custom
```

יוצרים רשת משנה ברשת 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

יוצרים רשת 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
}

יוצרים תת-רשת באזור 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
}

הגדרת רשת המשנה ל-proxy בלבד

כל מאזני העומסים האזוריים שמבוססים על Envoy באזור us-west1 ברשת ה-VPC‏ lb-network משתמשים ברשת המשנה של שרתי ה-proxy בלבד. יכולה להיות רק רשת משנה אחת פעילה מסוג proxy-only לכל אזור ולכל רשת.

אל תבצעו את השלב הזה אם כבר יש תת-רשת של שרת proxy בלבד ששמורה באזור us-west1 ברשת הזו.

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

המסוף

נכנסים לדף VPC networks במסוף Google Cloud .
מעבר לרשתות VPC
לוחצים על השם של רשת ה-VPC המשותפת: lb-network.
לוחצים על הוספת רשת משנה.
בשדה Name (שם), מזינים proxy-only-subnet.
בשדה אזור, בוחרים באפשרות us-west1.
מגדירים את Purpose (מטרה) לערך Regional Managed Proxy (שרת proxy מנוהל אזורי).
בשדה IP address range (טווח כתובות IP), מזינים 10.129.0.0/23.
לוחצים על הוספה.

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
}

מתן גישה לאדמינים של פרויקטים של שירותים לרשת המשנה של ה-Backend

אדמינים של פרויקט שירות צריכים גישה לlb-frontend-and-backend-subnet רשת המשנה כדי שהם יוכלו להקצות את העורפים של איזון העומסים.

אדמין של VPC משותף צריך להעניק גישה לתת-הרשת של ה-Backend לאדמינים של פרויקט השירות (או למפתחים שמפריסים משאבים ו-Backends שמשתמשים בתת-הרשת). הוראות מפורטות מופיעות במאמר אדמינים של פרויקטים של שירותים בחלק מרשתות המשנה.

הגדרת כללים לחומת האש בפרויקט המארח

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

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

fw-allow-proxies. כלל תעבורת נתונים נכנסת (ingress) שרלוונטי למופעים שעוברים איזון עומסים, שמאפשר תעבורת TCP ביציאות 80,‏ 443 ו-8080 משרתי ה-proxy המנוהלים של מאזן העומסים. בדוגמה הזו נעשה שימוש בתג היעד load-balanced-backend כדי לזהות את המקרים שבהם צריך להחיל את התג.

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

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

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

המסוף

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

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

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

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

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

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

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

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

gcloud

יוצרים את כלל חומת האש fw-allow-health-check כדי לאפשרGoogle Cloud בדיקות תקינות. בדוגמה הזו, כל תנועת ה-TCP מבודקי בדיקת תקינות מורשית. עם זאת, אפשר להגדיר קבוצה מצומצמת יותר של יציאות בהתאם לצרכים שלכם.
```
gcloud compute firewall-rules create fw-allow-health-check \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --source-ranges=130.211.0.0/22,35.191.0.0/16 \
   --target-tags=load-balanced-backend \
   --rules=tcp
```

יוצרים את 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

יוצרים את כלל חומת האש fw-allow-ssh כדי לאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh. אם לא מציינים את source-ranges,‏Google Cloud מפרש את הכלל כאילו הוא מתייחס לכל מקור.
```
gcloud compute firewall-rules create fw-allow-ssh \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-ssh \
   --rules=tcp:22
```

Terraform

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

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"]
}

יוצרים כלל חומת אש שמאפשר תעבורת נתונים מתת-רשת של שרת 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"]
}

יוצרים כלל חומת אש שמאפשר קישוריות 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"]
}

הגדרת VPC משותף בפרויקט המארח

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

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

אל תמשיכו עד שתגדירו VPC משותף ותפעילו את הפרויקטים המארח והשירות.

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

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

הגדרת מאזן עומסים בפרויקט השירות

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

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

Figure 1. מאזן עומסים פנימי של אפליקציות (ALB) ב-VPC משותף — **איור 1.** מאזן עומסים פנימי של אפליקציות (ALB) ב-VPC משותף

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

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

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

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

המסוף

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

כניסה לדף 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. לוחצים על יצירה.
יוצרים קבוצה של מופעי מכונה מנוהלים. נכנסים לדף Instance groups במסוף Google Cloud .

כניסה לדף 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. מציינים את מספר המופעים שרוצים ליצור בקבוצה.
  
  בדוגמה הזו, מציינים את האפשרויות הבאות להתאמה אוטומטית לעומס:
  - בקטע מצב שינוי גודל אוטומטי, בוחרים באפשרות Off:do not autoscale.
  - בשדה מספר מופעים מקסימלי, מזינים 2.
  אופציונלי: בקטע Autoscaling (שינוי גודל אוטומטי) בממשק המשתמש, אפשר להגדיר את קבוצת המופעים כך שמופעים יתווספו או יוסרו באופן אוטומטי בהתבסס על השימוש במעבד של המופע.
9. לוחצים על יצירה.

gcloud

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

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

יוצרים קבוצת מופעי מכונה מנוהלים באזור באמצעות הפקודה 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

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

# 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
  }
}

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

ל-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
  }
}

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

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

בדיקת תקינות של HTTP
שירות קצה עורפי עם קבוצת מופעי מכונה מנוהלים כקצה עורפי
מפת URL
אישור SSL (נדרש רק ל-HTTPS)
שרת proxy יעד
כלל העברה

זמינות ה-Proxy

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

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

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

המסוף

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

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

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

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

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

הגדרה בסיסית

בשדה Name של מאזן העומסים, מזינים l7-ilb-shared-vpc.
בקטע אזור, בוחרים באפשרות us-west1.
בקטע Network (רשת), בוחרים באפשרות lb-network (מתוך Project: HOST_PROJECT_ID).

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

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

לוחצים על Backend configuration.
בתפריט Create or select backend services בוחרים באפשרות Create a backend service.
מגדירים את Name של שירות לקצה העורפי לערך l7-ilb-backend-service.
מגדירים את סוג הבק-אנד בתור קבוצות של מכונות.
ברשימה בדיקת תקינות, בוחרים באפשרות יצירת בדיקת תקינות ומזינים את הפרטים הבאים:
1. Name (שם): l7-ilb-basic-check
2. Protocol: HTTP
3. יציאה: 80
לוחצים על יצירה.
בקטע New backend:
1. מגדירים את Instance group ל-l7-ilb-backend-example.
2. מגדירים את Port numbers ל-80.
3. מגדירים את Balancing mode (מצב איזון) בתור Utilization (ניצול).
4. לוחצים על סיום.
לוחצים על יצירה.

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

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

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

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

ל-HTTP:

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

ל-HTTPS:

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

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

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

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

gcloud

מגדירים את בדיקת תקינות ה-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

מגדירים את שירות ה-Backend באמצעות הפקודה 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

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

יוצרים את מפת ה-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

יוצרים את שרת ה-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
```

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

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

לכתובת ה-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

הגדרת בדיקת תקינות 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"
  }
}

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

# 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
  }
}

יוצרים את מפת ה-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
}

יוצרים את שרת ה-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]
}

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

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

ל-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]
}

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

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

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

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

המסוף

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

כניסה לדף VM instances
לוחצים על Create instance.
מגדירים את Name לערך client-vm.
מגדירים את Zone לערך us-west1-a.
לוחצים על אפשרויות מתקדמות ואז על רשת.
מזינים את תגי הרשת הבאים: allow-ssh,load-balanced-backend.
בקטע Network interfaces, בוחרים באפשרות Networks shared with me (from host project: HOST_PROJECT_ID).
בוחרים את רשת המשנה lb-frontend-and-backend-subnet מהרשת lb-network.
לוחצים על יצירה.

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"]
    ]
  }
}

הפניית תנועה למאזן העומסים

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

מתחברים למכונת הלקוח באמצעות SSH.
```
gcloud compute ssh client-vm \
   --zone=us-west1-a
```
מוודאים שכתובת ה-IP משרתת את שם המארח שלה. מחליפים את LB_IP_ADDRESS בכתובת ה-IP של מאזן העומסים.
```
curl LB_IP_ADDRESS
```
כדי לבדוק HTTPS, מחליפים את curl בערך הבא:
```
curl -k -s 'https://LB_IP_ADDRESS:443'
```
הדגל -k גורם ל-curl לדלג על אימות האישור.

הגדרת מאזן עומסים עם שירות קצה עורפי חוצה-פרויקטים

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

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

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

כלל העברה, שרת proxy ליעד ומפת URL בפרויקט המארח, ושירות קצה עורפי בפרויקט שירות
כלל העברה, שרת proxy ביעד ומפת URL בפרויקט שירות אחד, ושירות לקצה העורפי בפרויקט שירות אחר

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

דרישות להגדרה

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

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

הרשאות
דרישות מוקדמות

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

יצירת שירותי הקצה העורפיים בפרויקט השירות ב'

צריך לבצע את כל השלבים בקטע הזה בפרויקט השירות B.

המסוף

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

כניסה לדף 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. לוחצים על יצירה.
יוצרים קבוצה של מופעי מכונה מנוהלים. נכנסים לדף Instance groups במסוף Google Cloud .

כניסה לדף 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. מציינים את מספר המופעים שרוצים ליצור בקבוצה.
  
  בדוגמה הזו, מציינים את האפשרויות הבאות להתאמה אוטומטית לעומס:
  - בקטע מצב שינוי גודל אוטומטי, בוחרים באפשרות Off:do not autoscale.
  - בשדה מספר מופעים מקסימלי, מזינים 2.
  אופציונלי: בקטע Autoscaling (שינוי גודל אוטומטי) בממשק המשתמש, אפשר להגדיר את קבוצת המופעים כך שמופעים יתווספו או יוסרו באופן אוטומטי בהתבסס על השימוש במעבד של המופע.
9. לוחצים על יצירה.
יוצרים שירות לקצה עורפי אזורי. במסגרת השלב הזה, ניצור גם את בדיקת תקינות ונוסיף backends לשירות לקצה העורפי. נכנסים לדף Backends במסוף Google Cloud .

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

יוצרים תבנית של הגדרות מכונה עם שרת 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 המשותף.

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

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

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

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

# 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
  }
}

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

ל-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
  }
}

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

ל-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"
  }
}

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

# 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
  }
}

יצירת חזית מאזן העומסים ומפת URL בפרויקט השירות A

צריך לבצע את כל השלבים בקטע הזה בפרויקט שירות א'.

המסוף

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

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

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

הגדרה בסיסית

מזינים שם למאזן העומסים.
בקטע אזור, בוחרים באפשרות us-west1.
בקטע Network (רשת), בוחרים באפשרות lb-network (מתוך Project: HOST_PROJECT_NAME).

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

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

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

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

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

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

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

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

ל-HTTP:

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

ל-HTTPS:

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

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

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

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

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

gcloud

אופציונלי: לפני שיוצרים מאזן עומסים עם שירותי קצה עורפיים שמתייחסים זה לזה, כדאי לבדוק אם אפשר להתייחס לשירותי הקצה העורפיים שרוצים להפנות אליהם באמצעות מיפוי URL:
```
gcloud compute backend-services list-usable \
    --region=us-west1 \
    --project=SERVICE_PROJECT_B_ID
```
יוצרים את מפת URL ומגדירים את שירות ברירת המחדל לשירות לקצה העורפי שנוצר בפרויקט השירות B.
```
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: השם של שירות ה-Backend שנוצר בפרויקט השירות B.
- ‫SERVICE_PROJECT_B_ID: מזהה הפרויקט של פרויקט שירות B, שבו נוצרו קצה העורפי של מאזן העומסים ושירות הקצה העורפי.
- SERVICE_PROJECT_A_ID: מזהה הפרויקט של פרויקט השירות א', שבו נוצר קצה קדמי של מאזן העומסים.
יצירת מפת URL תיכשל אם אין לכם את ההרשאה compute.backendServices.use לשירות לקצה העורפי בפרויקט השירות ב.
יוצרים את שרת ה-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 של היעד.

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

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

Terraform

יוצרים את מפת ה-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
}

יוצרים את שרת ה-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]
}

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

ל-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]
}

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

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

אם רוצים שמאזני עומסים יפנו לשירותי קצה עורפיים בפרויקטים אחרים של שירותים, למנהל מאזן העומסים צריכה להיות ההרשאה compute.backendServices.use. כדי להעניק את ההרשאה הזו, אפשר להשתמש בתפקיד המוגדר מראש ב-IAM שנקרא Compute Load Balancer Services User (משתמש בשירותי איזון עומסים ב-Compute) ‏(roles/compute.loadBalancerServiceUser). התפקיד הזה צריך להיות מוענק על ידי אדמין בפרויקט השירות, ואפשר להחיל אותו ברמת הפרויקט או ברמת שירות לקצה העורפי הספציפי.

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

בדוגמה הזו, אדמין בפרויקט שירות ב' צריך להריץ אחת מהפקודות הבאות כדי להעניק את ההרשאה compute.backendServices.use לאדמין של מאזן עומסים מפרויקט שירות א'. אפשר לעשות את זה ברמת הפרויקט (לכל שירותי הקצה העורפי בפרויקט) או לכל שירות קצה עורפי בנפרד.

המסוף

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

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

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

נכנסים לדף IAM במסוף Google Cloud .

כניסה לדף IAM
בוחרים את הפרויקט הרצוי.
לוחצים על Grant access.
בשדה New principals, מזינים את כתובת האימייל או מזהה אחר של החשבון הראשי.
ברשימה Select a role בוחרים באפשרות Compute Load Balancer Services User.
אם רוצים, מוסיפים תנאי לתפקיד.
לוחצים על Save.

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

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

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

נכנסים לדף Backends במסוף Google Cloud .

כניסה לדף Backends
ברשימת שירותי הקצה העורפי, בוחרים את שירות הקצה העורפי שרוצים להעניק לו גישה ולוחצים על הרשאות.
לוחצים על Add principal.
בשדה New principals, מזינים את כתובת האימייל או מזהה אחר של החשבון הראשי.
ברשימה Select a role בוחרים באפשרות Compute Load Balancer Services User.
לוחצים על 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 כך שהן יחולו רק על קבוצת משנה של שירותי קצה עורפיים אזוריים באמצעות תנאים וציון מאפייני תנאים.

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

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

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

אתם יכולים להגביל את השימוש בתכונות של VPC משותף, כמו הפניה לשירותים בין פרויקטים, בפרויקט שלכם באמצעות אילוצים על מדיניות הארגון. מידע נוסף מופיע במאמר אילוצים של מדיניות הארגון לגבי Cloud Load Balancing.
כדי לנהל את המשאב של תת-הרשת לשרת proxy בלבד שנדרש למאזני עומסים פנימיים של אפליקציות, אפשר לעיין במאמר תת-רשת לשרת proxy בלבד למאזני עומסים פנימיים של אפליקציות.
כדי לראות איך לפתור בעיות במאזן עומסים פנימי של אפליקציות, אפשר לעיין במאמר פתרון בעיות במאזני עומסים פנימיים של אפליקציות.
ניקוי ההגדרות של מאזן העומסים

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

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

ההרשאות הנדרשות

הגדרת VPC משותף

פריסת מאזן עומסים וקצה עורפי

דרישות מוקדמות

הגדרת הרשתות ורשתות המשנה בפרויקט המארח

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

המסוף

gcloud

Terraform

הגדרת רשת המשנה ל-proxy בלבד

המסוף

gcloud

Terraform

מתן גישה לאדמינים של פרויקטים של שירותים לרשת המשנה של ה-Backend

הגדרת כללים לחומת האש בפרויקט המארח

המסוף

gcloud

Terraform

הגדרת VPC משותף בפרויקט המארח

הגדרת מאזן עומסים בפרויקט השירות

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

המסוף

gcloud

Terraform

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

זמינות ה-Proxy

המסוף

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

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

הגדרה בסיסית

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

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

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

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

gcloud

Terraform

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

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

המסוף

gcloud

Terraform

הפניית תנועה למאזן העומסים

הגדרת מאזן עומסים עם שירות קצה עורפי חוצה-פרויקטים

דרישות להגדרה

יצירת שירותי הקצה העורפיים בפרויקט השירות ב'

המסוף

gcloud

Terraform

יצירת חזית מאזן העומסים ומפת URL בפרויקט השירות A

המסוף

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

הגדרה בסיסית

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

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

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

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

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

gcloud

Terraform

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

המסוף

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

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

gcloud

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

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

gcloud

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

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