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

אפשר להשתמש במאזני עומסים חיצוניים של אפליקציות (ALB) עם שרת proxy לאימות זהויות (IAP) בסוגים הבאים של קצוות עורפיים:

• קבוצות של מכונות
• קבוצות של נקודות קצה ברשת (NEG) לפי אזור
• ‫Serverless NEGs: שירות אחד או יותר של Cloud Run
• קבוצות של נקודות קצה ברשת האינטרנט, לנקודות קצה שנמצאות מחוץ ל- Google Cloud (נקראות גם מקורות מותאמים אישית)
• ‫Hybrid Connectivity NEGs, לנקודות קצה שחורגות מ- Google Cloud, כמו מרכזי נתונים מקומיים ועננים ציבוריים אחרים שאפשר להגיע אליהם באמצעות קישוריות היברידית.
• Private Service Connect NEG, נקודת קצה שמפנה לאחת מהאפשרויות הבאות:
  • נקודת קצה אזורית ל-API בניהול Google
  • שירות מנוהל שפורסם באמצעות Private Service Connect

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

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

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

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

טופולוגיות של מאזני עומסים

כדי ליצור מאזן עומסים ב-HTTPS, צריך ליצור את ההגדרות שמוצגות בתרשים הבא.

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

במאזן עומסים מסוג HTTP, יוצרים את ההגדרות שמוצגות בדיאגרמה הבאה.

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

רצף האירועים בתרשימים הוא:

1. הלקוח שולח בקשת תוכן לכתובת ה-IPv4 החיצונית שמוגדרת בכלל ההעברה.

2. במאזן עומסים מסוג HTTPS, כלל ההעברה מפנה את הבקשה אל שרת ה-proxy ל-HTTPS לטירגוט.

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

3. שרת ה-Proxy לחלוקת העומס משתמש בכלל במפת כתובות ה-URL כדי לקבוע ששירות הקצה העורפי היחיד יקבל את כל הבקשות.

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

5. המכונה הווירטואלית מציגה את התוכן שהמשתמש ביקש.

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

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

הגדרת משאב של אישור SSL

כדי ליצור את מאזן העומסים, צריך שיהיה לכם משאב של אישור SSL שאפשר לצרף לשרת ה-proxy לחלוקת העומס. משאב אישור ה-SSL יכול להיות מפת אישורים או אישור SSL של Compute Engine (אישור קלאסי).

מפת אישורים

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

• פריסת אישור גלובלי בניהול Google עם הרשאה של מאזן עומסים
• פריסת אישור גלובלי בניהול Google עם הרשאת DNS
• פריסת אישור גלובלי בניהול Google באמצעות Certificate Authority Service
• פריסת אישור גלובלי בניהול עצמי

אישור SSL של Compute Engine

למאזן עומסים מסוג HTTPS, יוצרים משאב של אישור SSL ב-Compute Engine, כמו שמתואר באחד מהמסמכים הבאים:

• שימוש באישורי SSL בניהול עצמי
• שימוש באישורי SSL בניהול Google

מומלץ להשתמש באישור בניהול Google.

אזהרה: אל תשתמשו בתעודות חתימה עצמית למטרות ייצור.

הגדרת ההרשאות

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

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

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

• בקרת גישה
• תנאי IAM

אופציונלי: שימוש בכתובות BYOIP

באמצעות "העברת כתובות IP משלכם" (BYOIP), אתם יכולים לייבא כתובות ציבוריות משלכם אלGoogle Cloud כדי להשתמש בהן עם משאבי Google Cloud . לדוגמה, אם אתם מייבאים כתובות IPv4 משלכם, אתם יכולים להקצות אחת מהן לכלל ההעברה כשאתם מגדירים את מאזן העומסים. כשפועלים לפי ההוראות במסמך הזה כדי להגדיר את מאזן העומסים, צריך לספק את כתובת ה-BYOIP בתור כתובת ה-IP.

למידע נוסף על השימוש ב-BYOIP, קראו את המאמר העברת כתובות IP משלכם.

הגדרת הרשת ורשתות המשנה

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

המסוף

1. במסוף Google Cloud , נכנסים לדף רשתות VPC.

   כניסה לרשתות VPC

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

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

4. ב-Subnet creation mode, בוחרים באפשרות Custom.

5. בקטע New subnet, מגדירים את השדות הבאים:

   1. מזינים Name לרשת המשנה.
   2. בוחרים Region.
   3. בשביל IP stack type, בוחרים IPv4 (single-stack).
   4. מזינים טווח כתובות IP. זהו טווח ה-IPv4 הראשי של רשת המשנה.

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

7. כדי להוסיף רשת משנה באזור אחר, לוחצים על Add subnet וחוזרים על השלבים הקודמים.

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

gcloud

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

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

2. בתוך הרשת, יוצרים רשת משנה לקצוות עורפיים:

   gcloud compute networks subnets create SUBNET \
       --network=NETWORK \
       --stack-type=IPV4_ONLY \
       --range=10.1.2.0/24 \
       --region=REGION
   

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

   • ‫NETWORK: שם לרשת ה-VPC.

   • ‫SUBNET: שם לתת-הרשת.

   • ‫REGION: שם האזור.

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

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

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

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

המסוף

כדי לתמוך בתנועת IPv4, פועלים לפי השלבים הבאים:

1. במסוף Google Cloud , נכנסים לדף תבניות של הגדרות מכונה.

   כניסה לדף Instance templates

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

3. בשדה Name, מזינים lb-backend-template.

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

5. מרחיבים את הקטע אפשרויות מתקדמות.

6. מרחיבים את האפשרות Networking ומגדירים את השדות הבאים:

   1. בשדה Network tags, מזינים את הערך allow-health-check.
   2. בקטע Network interfaces, לוחצים על Edit ומבצעים את השינויים הבאים:
      • רשת: NETWORK
      • רשת משנה: SUBNET
      • תנועת IPv4: IPv4 (מקבץ יחיד)
   3. לוחצים על סיום.

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

   #! /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
   

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

gcloud

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

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPV4_ONLY \
  --tags=allow-health-check \
  --image-family=debian-10 \
  --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'

Terraform

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

resource "google_compute_instance_template" "default" {
  name = "lb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-13"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = "#! /bin/bash\n     sudo apt-get update\n     sudo apt-get install apache2 -y\n     sudo a2ensite default-ssl\n     sudo a2enmod ssl\n     vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\n   http://169.254.169.254/computeMetadata/v1/instance/name)\"\n   sudo echo \"Page served from: $vm_hostname\" | \\\n   tee /var/www/html/index.html\n   sudo systemctl restart apache2"
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = "global/networks/default"
    subnetwork = "regions/us-east1/subnetworks/default"
  }
  region = "us-east1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["allow-health-check"]
}

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

המסוף

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

   כניסה לדף Instance groups

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

3. בצד שמאל, בוחרים באפשרות New managed instance group (stateless).

4. בשדה Name, מזינים lb-backend-example.

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

6. בקטע Region, בוחרים את האזור הרצוי.

7. בשדה Zone, בוחרים אזור.

8. בקטע Instance template, בוחרים את תבנית המכונה lb-backend-template.

9. בקטע Autoscaling mode, בוחרים באפשרות On: add and remove instances to the group.

   מגדירים את Minimum number of instances לערך 2, ואת Maximum number of instances לערך 2 או יותר.

10. כדי ליצור את קבוצת המכונות החדשה, לוחצים על Create.

gcloud

1. יוצרים את קבוצת מופעי המכונה המנוהלים על סמך התבנית.

   gcloud compute instance-groups managed create lb-backend-example \
      --template=TEMPLATE_NAME --size=2 --zone=ZONE_A
   

Terraform

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

resource "google_compute_instance_group_manager" "default" {
  name = "lb-backend-example"
  zone = "us-east1-b"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

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

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

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

המסוף

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

   כניסה לדף Instance groups

2. לוחצים על lb-backend-example.

3. בדף Overview של קבוצת המכונות, לוחצים על Edit.

4. בקטע מיפוי יציאות, לוחצים על הוספת יציאה.

   1. בשם היציאה, מזינים http. בשדה של מספר היציאה, מזינים 80.

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

gcloud

משתמשים בפקודה gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports lb-backend-example \
    --named-ports http:80 \
    --zone ZONE_A

Terraform

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

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

בדוגמה הזו, יוצרים את הכלל fw-allow-health-check בחומת האש. זהו כלל תעבורת נתונים נכנסת (ingress) שמאפשר תעבורת נתונים מGoogle Cloud מערכות לבדיקת תקינות. בדוגמה הזו, תג היעד allow-health-check משמש לזיהוי המכונות הווירטואליות.

המסוף

1. במסוף Google Cloud , עוברים לדף מדיניות חומת אש.

   כניסה לדף Firewall policies

2. לוחצים על Create firewall rule כדי ליצור את הכלל בחומת האש.

3. בשדה Name, מזינים fw-allow-health-check.

4. בוחרים רשת.

5. בקטע יעדים, בוחרים באפשרות תגי יעד שצוינו.

6. בשדה Target tags מזינים את הערך allow-health-check.

7. מגדירים את Source filter בתור IPv4 ranges.

8. מגדירים את Source IPv4 ranges לערך 35.191.0.0/16.

9. בקטע Protocols and ports, בוחרים באפשרות Specified protocols and ports.

10. מסמנים את התיבה TCP ומקלידים 80 בשדה של מספרי היציאות.

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

gcloud

gcloud compute firewall-rules create fw-allow-health-check \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=35.191.0.0/16 \
    --target-tags=allow-health-check \
    --rules=tcp:80

Terraform

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

resource "google_compute_firewall" "default" {
  name          = "fw-allow-health-check"
  direction     = "INGRESS"
  network       = "global/networks/default"
  priority      = 1000
  source_ranges = ["35.191.0.0/16"]
  target_tags   = ["allow-health-check"]
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
}

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

שמירת כתובת IP חיצונית

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

המסוף

1. נכנסים לדף כתובות IP במסוף Google Cloud .

   לדף IP addresses

2. כדי לשמור כתובת IPv4, לוחצים על Reserve external.

3. בדף Reserve external static IP address, בשדה Name מזינים את הערך lb-ipv4-1.

4. מגדירים את Network Service Tier ל-Premium.

5. מגדירים את IP version ל-IPv4.

6. מגדירים את Type לערך Global.

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

gcloud

gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --network-tier=PREMIUM \
    --global

שימו לב לכתובת ה-IPv4 שנשמרה:

gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

Terraform

כדי לשמור את כתובת ה-IP, משתמשים במשאב google_compute_global_address.

resource "google_compute_global_address" "default" {
  name       = "lb-ipv4-1"
  ip_version = "IPV4"
}

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

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

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

גם אם אתם משתמשים ב-HTTPS בקצה הקדמי, אתם יכולים להשתמש ב-HTTP בקצה העורפי. Google מצפינה באופן אוטומטי את התנועה בין ממשקי הקצה של Google ‏ (GFE) לבין הקצוות העורפיים שנמצאים ברשתות VPC של Google Cloud .

המסוף

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

1. במסוף Google Cloud , עוברים לדף איזון עומסים.

   כניסה לדף Load balancing

2. לוחצים על יצירת מאזן עומסים.
3. בשדה Type of load balancer, בוחרים באפשרות Application Load Balancer (HTTP/HTTPS) ולוחצים על Next.
4. בקטע Public facing or internal, בוחרים באפשרות Public facing (external)‎ ולוחצים על Next.
5. בקטע Global or single region deployment, בוחרים באפשרות Best for global workloads ולוחצים על Next.
6. בשדה Load balancer generation, בוחרים באפשרות מאזן עומסים של אפליקציות קלאסי ולוחצים על Next.
7. לוחצים על הגדרה.

הגדרה בסיסית

בשדה Name של מאזן העומסים, מזינים שם כמו web-map-https או web-map-http.

Frontend configuration

1. לוחצים על Frontend configuration.
2. מגדירים את הפרוטוקול ל-HTTPS.
3. בוחרים באפשרות IPv4 לתנועת IPv4. מגדירים את כתובת IP ל-lb-ipv4-1, שיצרתם קודם.
4. מגדירים את Port לערך 443.
5. בשדה Choose certificate repository, בוחרים באפשרות Use certificate map או באפשרות Use classic certificates.
6. בהתאם לבחירה, בוחרים מפת אישורים או אישור קלאסי.
7. אופציונלי: יוצרים מדיניות SSL:
   1. ברשימה SSL policy, בוחרים באפשרות Create a policy.
   2. מגדירים את השם של מדיניות ה-SSL ל-my-ssl-policy.
   3. ב-Minimum TLS Version, בוחרים באפשרות TLS 1.0.
   4. בשדה פרופיל, בוחרים באפשרות מודרני. מוצגות התכונות המופעלות והתכונות המושבתות.
   5. לוחצים על Save.
   אם לא יצרתם כללי מדיניות SSL, חלה מדיניות SSL שמוגדרת כברירת מחדל.
8. אופציונלי: מסמנים את התיבה Enable HTTP to HTTPS Redirect כדי להפעיל הפניות אוטומטיות.

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

   אפשר לסמן את התיבה הזו רק כשבוחרים בפרוטוקול HTTPS ומשתמשים בכתובת IP שמורה.

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

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

1. לוחצים על Backend configuration.
2. בקטע שירותי קצה עורפי וקטגוריות קצה עורפי, בוחרים באפשרות יצירת שירות קצה עורפי.
3. נותנים שם לשירות לקצה העורפי, למשל web-backend-service.
4. עוברים לקטע Security ובוחרים באפשרות Enable IAP to secure access to your applications.

   ‫Cloud CDN ו-IAP לא תואמים. אם Cloud CDN מופעל ואתם בוחרים להפעיל את IAP,‏ Cloud CDN מושבת באופן אוטומטי.

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

   1. כדי לבטל את ההצטרפות למדיניות האבטחה שמוגדרת כברירת מחדל ב-Cloud Armor, בוחרים באפשרות None ברשימה Cloud Armor backend security policy.
   2. כדי להגדיר את מדיניות האבטחה שמוגדרת כברירת מחדל ב-Cloud Armor, בוחרים באפשרות Default security policy ברשימה Cloud Armor backend security policy.
   3. בשדה Policy name, מאשרים את השם שנוצר באופן אוטומטי או מזינים שם למדיניות האבטחה.
   4. בשדה Request count, מאשרים את מספר הבקשות שמוגדר כברירת מחדל או מזינים מספר שלם בין 1 ל-10,000.
   5. בשדה מרווח, בוחרים מרווח.
   6. בשדה Enforce on key, בוחרים אחד מהערכים הבאים: All,‏ כתובת IP או כתובת IP של X-Forwarded-For. מידע נוסף על האפשרויות האלה זמין במאמר זיהוי לקוחות להגבלת קצב של יצירת בקשות.
6. שומרים את שאר הגדרות ברירת המחדל.
7. לוחצים על יצירה.

כללי מארח ונתיב

בשביל Host and path rules, משאירים את הגדרות ברירת המחדל.

בדיקה וסיום

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

מחכים שמאזן העומסים ייווצר.

אם יצרתם מאזן עומסים ב-HTTPS ובחרתם באפשרות Enable HTTP to HTTPS Redirect, תראו גם מאזן עומסים ב-HTTP שנוצר עם הסיומת ‎-redirect.

1. לוחצים על השם של מאזן העומסים.
2. במסך Load balancer details, שימו לב לערך של IP:Port של מאזן העומסים.

gcloud

1. יוצרים בדיקת תקינות.

    gcloud compute health-checks create http http-basic-check \
        --port 80
    

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

   gcloud compute backend-services create web-backend-service \
       --load-balancing-scheme=EXTERNAL \
       --protocol=HTTP \
       --port-name=http \
       --health-checks=http-basic-check \
       --global
   

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

   gcloud beta compute backend-services add-backend web-backend-service \
     --instance-group=lb-backend-example \
     --instance-group-zone=ZONE_A \
     --global
   

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

   gcloud beta compute url-maps create web-map-http \
     --default-service web-backend-service
   

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

   gcloud beta compute url-maps create web-map-https \
     --default-service web-backend-service
   

הגדרת ממשק קצה (frontend) של HTTPS

אם אתם משתמשים במאזני עומסים מסוג HTTP, דלגו על הקטע הזה.

1. אם אתם משתמשים ב-HTTPS, אתם צריכים ליצור את משאב אישור ה-SSL הגלובלי, כמו שמוסבר בקטעים הבאים. בדוגמה הזו, השם של משאב אישור ה-SSL הוא www-ssl-cert.
• יצירת משאב של אישור SSL בניהול Google
• יצירת משאב של אישור SSL בניהול עצמי

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

   gcloud compute target-https-proxies create https-lb-proxy \
     --url-map=web-map-https \
     --ssl-certificates=www-ssl-cert
   

3. ב-HTTPS, יוצרים כלל העברה גלובלי כדי לנתב בקשות נכנסות לשרת ה-proxy.

   gcloud compute forwarding-rules create https-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --network-tier=PREMIUM \
     --address=lb-ipv4-1 \
     --global \
     --target-https-proxy=https-lb-proxy \
     --ports=443
   

4. אופציונלי: ל-HTTPS, יוצרים מדיניות SSL גלובלית ומצרפים אותה ל-Proxy ל-HTTPS.
   כדי ליצור מדיניות SSL גלובלית:

   gcloud compute ssl-policies create my-ssl-policy \
     --profile MODERN \
     --min-tls-version 1.0
   

   כדי לצרף את מדיניות ה-SSL לשרת ה-proxy הגלובלי של HTTPS:

   gcloud compute target-https-proxies update https-lb-proxy \
     --ssl-policy my-ssl-policy
   

הגדרת קצה קדמי של HTTP

דלגו על הקטע הזה אם אתם משתמשים במאזני עומסים מסוג HTTPS.

1. ל-HTTP, יוצרים שרת proxy ל-HTTP לניתוב בקשות למפת URL.

   gcloud compute target-http-proxies create http-lb-proxy \
     --url-map=web-map-http
   

2. ב-HTTP, יוצרים כלל העברה גלובלי כדי לנתב בקשות נכנסות לשרת ה-proxy.

   gcloud compute forwarding-rules create http-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --address=lb-ipv4-1 \
     --global \
     --target-http-proxy=http-lb-proxy \
     --ports=80
   

Terraform

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

   resource "google_compute_health_check" "default" {
     name               = "http-basic-check"
     check_interval_sec = 5
     healthy_threshold  = 2
     http_health_check {
       port               = 80
       port_specification = "USE_FIXED_PORT"
       proxy_header       = "NONE"
       request_path       = "/"
     }
     timeout_sec         = 5
     unhealthy_threshold = 2
   }

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

   בדוגמה הזו משתמשים ב-load_balancing_scheme="EXTERNAL_MANAGED", שמגדיר מאזן עומסים גלובלי חיצוני של אפליקציות (ALB) עם יכולת מתקדמת לניהול תעבורת נתונים. כדי ליצור מאזן עומסים קלאסי של אפליקציות (ALB), צריך לשנות את load_balancing_scheme ל-EXTERNAL לפני שמריצים את הסקריפט.

   resource "google_compute_backend_service" "default" {
     name                            = "web-backend-service"
     connection_draining_timeout_sec = 0
     health_checks                   = [google_compute_health_check.default.id]
     load_balancing_scheme           = "EXTERNAL_MANAGED"
     port_name                       = "http"
     protocol                        = "HTTP"
     session_affinity                = "NONE"
     timeout_sec                     = 30
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

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

   resource "google_compute_url_map" "default" {
     name            = "web-map-http"
     default_service = google_compute_backend_service.default.id
   }

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

   resource "google_compute_target_http_proxy" "default" {
     name    = "http-lb-proxy"
     url_map = google_compute_url_map.default.id
   }

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

   בדוגמה הזו משתמשים ב-load_balancing_scheme="EXTERNAL_MANAGED", שמגדיר מאזן עומסים גלובלי חיצוני של אפליקציות (ALB) עם יכולת מתקדמת לניהול תעבורת נתונים. כדי ליצור מאזן עומסים קלאסי של אפליקציות (ALB), צריך לשנות את load_balancing_scheme ל-EXTERNAL לפני שמריצים את הסקריפט.

   resource "google_compute_global_forwarding_rule" "default" {
     name                  = "http-content-rule"
     ip_protocol           = "TCP"
     load_balancing_scheme = "EXTERNAL_MANAGED"
     port_range            = "80-80"
     target                = google_compute_target_http_proxy.default.id
     ip_address            = google_compute_global_address.default.id
   }

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

הפעלת IAP במאזן העומסים החיצוני של האפליקציות (ALB)

הערה: IAP לא תואם ל-Cloud CDN.

אפשר להגדיר את IAP כך שיהיה מופעל או מושבת (ברירת המחדל). אם המדיניות מופעלת, צריך לספק ערכים למדיניות oauth2-client-id ולמדיניות oauth2-client-secret.

כדי להפעיל את IAP, מעדכנים את שירות הקצה העורפי כך שיכלול את הדגל --iap=enabled עם oauth2-client-id ו-oauth2-client-secret.

gcloud compute backend-services update BACKEND_SERVICE_NAME \
    --iap=enabled,oauth2-client-id=ID,oauth2-client-secret=SECRET \
    --global

אפשר גם להפעיל את IAP במשאב של Compute Engine באמצעות מסוף Google Cloud , ה-CLI של gcloud או ה-API.

חיבור הדומיין למאזן העומסים

אחרי שיוצרים את מאזן העומסים, שימו לב לכתובת ה-IP שמשויכת אליו, לדוגמה 30.90.80.100. כדי להפנות את הדומיין למאזן העומסים, צריך ליצור רשומת A באמצעות שירות הרישום של הדומיין. אם הוספתם מספר דומיינים לאישור ה-SSL, צריך להוסיף רשומת A לכל אחד מהם, כשכולם מפנים לכתובת ה-IP של מאזן העומסים. לדוגמה, כדי ליצור רשומות A בשביל www.example.com ובשביל example.com, משתמשים בפקודה הבאה:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

אם אתם משתמשים ב-Cloud DNS כספק ה-DNS, קראו את המאמר הוספה, שינוי ומחיקה של רשומות.

תנועת בדיקה שנשלחת למכונות שלכם

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

המסוף

1. במסוף Google Cloud , עוברים לדף איזון עומסים.

   כניסה לדף Load balancing

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

3. בקטע Backend, מוודאים שהמכונות הווירטואליות תקינות. העמודה Healthy אמורה להיות מאוכלסת, מה שמציין ששתי המכונות הווירטואליות תקינות (2/2). אם זה לא המצב, נסו קודם לטעון מחדש את הדף. יכול להיות שיעברו כמה רגעים עד שבמסוף Google Cloud יצוין שהמכונות הווירטואליות תקינות. אם אחרי כמה דקות נראה שה-backends לא תקינים, צריך לבדוק את הגדרות חומת האש ואת תג הרשת שהוקצה למכונות הווירטואליות של ה-backend.

4. ב-HTTPS, אם אתם משתמשים באישור בניהול Google, ודאו שהסטטוס של משאב האישור הוא ACTIVE. למידע נוסף, ראו סטטוס המשאבים של אישורי SSL בניהול Google.
5. אחרי שבמסוף Google Cloud מופיע שהמכונות העורפיות תקינות, אפשר לבדוק את מאזן העומסים באמצעות דפדפן אינטרנט, על ידי מעבר אל https://IP_ADDRESS (או http://IP_ADDRESS). מחליפים את IP_ADDRESS בכתובת ה-IP של מאזן העומסים.
6. אם השתמשתם באישור בחתימה עצמית כדי לבדוק את HTTPS, תוצג אזהרה בדפדפן. צריך להורות לדפדפן באופן מפורש לקבל אישור בחתימה עצמית.
7. בדפדפן אמור להופיע דף עם תוכן שמציג את שם המכונה ששירתה את הדף, יחד עם האזור שלה (לדוגמה, Page served from: lb-backend-example-xxxx). אם הדפדפן לא מציג את הדף הזה, צריך לבדוק את הגדרות התצורה במדריך הזה.

gcloud

gcloud compute addresses describe lb-ipv4-1 \
   --format="get(address)" \
   --global

אחרי כמה דקות, אפשר לבדוק את ההגדרה על ידי הפעלת הפקודה הבאה של curl.

curl http://IP_ADDRESS

-או-

curl https://HOSTNAME

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

• איך מפעילים את Cloud Load Balancing ב-GKE
• מידע נוסף על קבוצות של מכונות
• מידע נוסף על איזון עומסים ושינוי קנה מידה