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

המסוף

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

   מעבר לרשתות VPC

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

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

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

   • מגדירים את מצב יצירת רשתות משנה למותאם אישית.
   • בקטע New subnet (רשת משנה חדשה), מזינים את הפרטים הבאים:
     • Name (שם): backend-subnet
     • אזור: us-west1
     • טווח כתובות IP: 10.1.2.0/24
   • לוחצים על סיום.

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:

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

Terraform

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

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

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

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

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

   POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/global/networks
   {
    "routingConfig": {
      "routingMode": "REGIONAL"
    },
    "name": "lb-network",
    "autoCreateSubnetworks": false
   }
   

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

   POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
   {
    "name": "backend-subnet",
    "network": "projects/PROJECT_ID/global/networks/lb-network",
    "ipCidrRange": "10.1.2.0/24",
    "region": "projects/PROJECT_ID/regions/us-west1",
   }
   

המסוף

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

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

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 address range (טווח כתובות 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

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

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

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

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

המסוף

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

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

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

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

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

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

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

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

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=130.211.0.0/22,35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
   

2. יוצרים את כלל fw-allow-proxies כדי לאפשר לשרתי ה-proxy של מאזן העומסים החיצוני האזורי של האפליקציות להתחבר לקצה העורפי. מגדירים את source-ranges לטווחים שהוקצו לתת-הרשת של שרת ה-proxy בלבד, לדוגמה, 10.129.0.0/23.

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

Terraform

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

resource "google_compute_firewall" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}

resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

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

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-network",
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    }
  ],
  "direction": "INGRESS"
}

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

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

המסוף

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

   כניסה לדף Instance templates

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

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

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

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

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

   כניסה לדף Instance groups

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

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

      מגדירים את המספר המינימלי של מופעים ל-2, ואת המספר המקסימלי של מופעים ל-2 או יותר.

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

gcloud

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

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

   gcloud compute instance-templates create l7-xlb-backend-template \
   --region=us-west1 \
   --network=lb-network \
   --subnet=backend-subnet \
   --tags=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'
   

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

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

Terraform

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

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-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-12"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  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://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  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 = ["load-balanced-backend"]
}

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

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

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

   POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/global/instanceTemplates
   {
    "name":"l7-xlb-backend-template",
    "properties": {
      "machineType":"e2-standard-2",
      "tags": {
        "items":[
          "load-balanced-backend"
        ]
      },
      "metadata": {
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
      },
      "networkInterfaces":[
        {
          "network":"projects/PROJECT_ID/global/networks/lb-network",
          "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
          "accessConfigs":[
            {
              "type":"ONE_TO_ONE_NAT"
            }
          ]
        }
      ],
      "disks": [
        {
          "index":0,
          "boot":true,
          "initializeParams": {
            "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

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

   POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
   {
    "name": "l7-xlb-backend-example",
    "zone": "projects/PROJECT_ID/zones/us-west1-a",
    "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
    "baseInstanceName": "l7-xlb-backend-example",
    "targetSize": 2
   }
   

המסוף

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

   כניסה לדף Instance groups

2. לוחצים על השם של קבוצת המכונות (בדוגמה הזו l7-xlb-backend-example).

3. בדף סקירה כללית של קבוצת המופעים, לוחצים על עריכה edit.

4. לוחצים על ציון מיפוי של שמות יציאות.

5. לוחצים על Add item.

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

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

gcloud

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

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

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

המסוף

1. נכנסים לדף Reserve a static address במסוף Cloud de Confiance .

   מעבר אל 'שמירת כתובת סטטית'

2. בוחרים שם לכתובת החדשה.

3. בקטע Network Service Tier, בוחרים באפשרות Standard.

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

5. בשדה Type, בוחרים באפשרות Regional.

6. בשדה Region, בוחרים us-west1.

7. משאירים את האפשרות מצורף אל במצב ללא. אחרי שיוצרים את מאזן העומסים, כתובת ה-IP הזו מצורפת לכלל ההעברה של מאזן העומסים.

8. לוחצים על שמירה כדי לשמור את כתובת ה-IP.

gcloud

1. כדי לשמור כתובת IP חיצונית סטטית באמצעות gcloud compute, משתמשים בפקודה compute addresses create.

   gcloud compute addresses create ADDRESS_NAME  \
      --region=us-west1 \
      --network-tier=STANDARD
   

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

   • ‫ADDRESS_NAME: השם שרוצים לתת לכתובת הזו.
   • ‫REGION: האזור שבו רוצים לשריין את הכתובת הזו. האזור הזה צריך להיות זהה לאזור של מאזן העומסים. כל כתובות ה-IP האזוריות הן IPv4.

2. משתמשים בפקודה compute addresses describe כדי לראות את התוצאה:

   gcloud compute addresses describe ADDRESS_NAME
   

Terraform

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

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

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

API

כדי ליצור כתובת IPv4 אזורית, קוראים לשיטה האזורית addresses.insert:

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/regions/REGION/addresses

גוף הבקשה צריך לכלול את הפרטים הבאים:

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

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

• ADDRESS_NAME: השם של הכתובת
• ‫REGION: שם האזור של הבקשה
• ‫PROJECT_ID: מזהה הפרויקט של הבקשה הזו

המסוף

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

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

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

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

הגדרה בסיסית

1. בשדה של שם מאזן העומסים, מזינים regional-l7-xlb.
2. בשדה אזור, בוחרים באפשרות us-west1.
3. בקטע רשת, בוחרים באפשרות lb-network.

שמירת תת-רשת של שרת proxy בלבד

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

1. לוחצים על שמירת רשת משנה.
2. בשדה Name (שם), מזינים proxy-only-subnet.
3. בשדה IP address range (טווח כתובות IP), מזינים 10.129.0.0/23.
4. לוחצים על הוספה.

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

ל-HTTP:

1. לוחצים על Frontend configuration.
2. מגדירים את Name לערך l7-xlb-forwarding-rule.
3. מגדירים את Protocol לערך HTTP.
4. מגדירים את מסלול שירות הרשת בתור Standard.
5. מגדירים את Port לערך 80.
6. בוחרים את כתובת ה-IP שיצרתם בקטע שמירת כתובת ה-IP של מאזן העומסים.
7. לוחצים על סיום.

ל-HTTPS:

1. לוחצים על Frontend configuration.
2. בשדה שם מזינים l7-xlb-forwarding-rule.
3. בשדה Protocol, בוחרים באפשרות HTTPS (includes HTTP/2).
4. מגדירים את מסלול שירות הרשת בתור Standard.
5. מוודאים שהיציאה Port מוגדרת ל-443.
6. בוחרים את כתובת ה-IP שיצרתם בקטע שמירת כתובת ה-IP של מאזן העומסים.

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

   1. כדי לצרף אישור של Certificate Manager ל-Proxy היעד של HTTPS במאזן העומסים, בקטע Choose certificate repository בוחרים באפשרות Certificates.

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

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

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

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

      1. לוחצים על הוספת אישור.
      2. לוחצים על יצירת אישור חדש.

      3. כדי ליצור אישור חדש, פועלים לפי השלבים שמתחילים משלב 3, כפי שמתואר באחת משיטות ההגדרה הבאות במסמכי התיעוד של Certificate Manager:

         • יצירת אישור בניהול Google עם הפניה להרשאת ה-DNS

         • יצירת אישור בניהול Google שהונפק על ידי מופע של שירות CA

         • העלאת אישור בניהול עצמי אל Certificate Manager

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

   2. כדי לצרף אישור SSL של Compute Engine לשרת ה-proxy של HTTPS של מאזן העומסים, בקטע Choose certificate repository בוחרים באפשרות Classic Certificates.

      1. ברשימה Certificate (אישור), מבצעים את הפעולות הבאות:
         1. אם כבר יש לכם משאב של אישור SSL בניהול עצמי ב-Compute Engine, בוחרים את אישור ה-SSL הראשי.
         2. לוחצים על יצירת אישור חדש.
            1. בשדה שם מזינים l7-xlb-cert.
            2. בשדות המתאימים, מעלים את הקבצים בפורמט PEM:
               • אישור
               • מפתח פרטי
            3. לוחצים על יצירה.
         3. אופציונלי: כדי להוסיף אישורים בנוסף לאישור ה-SSL הראשי:
            1. לוחצים על הוספת אישור.
            2. אם כבר יש לכם אישור, בוחרים אותו מהרשימה אישורים.
            3. אופציונלי: לוחצים על יצירת אישור חדש ופועלים לפי ההוראות שצוינו בשלב הקודם.

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

   1. ברשימה SSL policy (מדיניות SSL), בוחרים באפשרות Create a policy (יצירת מדיניות).
   2. מזינים שם למדיניות ה-SSL.
   3. בוחרים גרסת TLS מינימלית. ערך ברירת המחדל הוא TLS 1.0.
   4. בוחרים אחד מהפרופילים המנוהלים על ידי Google שהוגדרו מראש, או בוחרים פרופיל בהתאמה אישית שמאפשר לבחור תכונות SSL בנפרד. מוצגות האפשרויות תכונות מופעלות ותכונות מושבתות.
   5. לוחצים על Save.

   אם לא יצרתם מדיניות SSL, תחול מדיניות SSL שמוגדרת כברירת מחדל Cloud de Confiance .

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

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

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

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

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

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

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

gcloud

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

   gcloud compute health-checks create http l7-xlb-basic-check \
      --region=us-west1 \
      --request-path='/' \
      --use-serving-port
   

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

   gcloud compute backend-services create l7-xlb-backend-service \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --protocol=HTTP \
     --port-name=http \
     --health-checks=l7-xlb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1
   

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

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

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

   gcloud compute url-maps create regional-l7-xlb-map \
     --default-service=l7-xlb-backend-service \
     --region=us-west1
   

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

   ל-HTTP:

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

   gcloud compute target-http-proxies create l7-xlb-proxy \
     --url-map=regional-l7-xlb-map \
     --url-map-region=us-west1 \
     --region=us-west1
   

   ל-HTTPS:

   אתם יכולים ליצור אישורים של Compute Engine או של Certificate Manager. אפשר להשתמש בכל אחת מהשיטות הבאות כדי ליצור אישורים באמצעות Certificate Manager:

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

   • אישורים אזוריים שמנוהלים על ידי Google. אין תמיכה במיפוי אישורים.

     ב-Certificate Manager יש תמיכה בסוגים הבאים של אישורים אזוריים בניהול Google:

     • אישורים אזוריים שמנוהלים על ידי Google עם הרשאת DNS לכל פרויקט. מידע נוסף זמין במאמר בנושא פריסת אישור אזורי שמנוהל על ידי Google עם הרשאת DNS.
     • אישורים אזוריים שמנוהלים על ידי Google (פרטיים) באמצעות Certificate Authority Service. מידע נוסף זמין במאמר בנושא פריסת אישור אזורי שמנוהל על ידי Google באמצעות Certificate Authority Service.

   אחרי שיוצרים אישורים, מצרפים אותם ישירות לשרת ה-proxy של היעד.

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

      export LB_CERT=path to PEM-formatted file
      

      export LB_PRIVATE_KEY=path to PEM-formatted file
      

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

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

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

      gcloud compute target-https-proxies create l7-xlb-proxy \
       --url-map=regional-l7-xlb-map \
       --region=us-west1 \
       --ssl-certificates=l7-xlb-cert
      

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

   ל-HTTP:

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

   gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --network-tier=STANDARD \
     --network=lb-network \
     --address=ADDRESS_NAME \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-xlb-proxy \
     --target-http-proxy-region=us-west1
   

   ל-HTTPS:

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

   gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --network-tier=STANDARD \
     --network=lb-network \
     --address=ADDRESS_NAME \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=l7-xlb-proxy \
     --target-https-proxy-region=us-west1
   

Terraform

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

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

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

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  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
  }
}

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

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

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

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

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

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

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

API

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

POST https://compute.s3nsapis.fr/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

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

POST https://compute.s3nsapis.fr/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

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

POST https://compute.s3nsapis.fr/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

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

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

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

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

המסוף

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

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

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

gcloud

שימו לב לכתובת ה-IPv4 שהוקצתה:

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

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

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

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

המסוף

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

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

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

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

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

4. לוחצים על l7-xlb-backend-service (השם של שירות הקצה העורפי שיצרתם בדוגמה הזו) ואז על Edit.

5. בדף פרטי שירות לקצה העורפי, לוחצים על הגדרות מתקדמות.

6. בקטע Session affinity (העדפה לסשן), בוחרים את סוג ההעדפה לסשן הרצוי מהתפריט.

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

gcloud

כדי לעדכן את שירות לקצה העורפי לסוגים שונים של זיקה לסשן (session affinity), משתמשים בפקודות הבאות:l7-xlb-backend-service

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP
    --region=us-west1

API

כדי להגדיר זיקה לסשן, שולחים בקשת PATCH אל ה-method‏ regionBackendServices/patch.

PATCH https://compute.s3nsapis.fr/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": <var>"GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP"</var>
}