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

המסוף

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

   כניסה לדף VPC networks

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

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

4. בקטע Subnets:

   1. מגדירים את Subnet creation mode ל-Custom.
   2. בקטע New subnet, מזינים את הפרטים הבאים:
      • שם: lb-subnet
      • אזור: us-west1
      • IP stack type:‏ IPv4 (single-stack)
      • טווח כתובות IP: 10.1.2.0/24
   3. לוחצים על סיום.
   4. לוחצים על Add subnet ומזינים את הפרטים הבאים:
      • שם: europe-subnet
      • אזור: europe-west1
      • IP stack type:‏ IPv4 (single-stack)
      • טווח כתובות IP: 10.3.4.0/24
   5. לוחצים על סיום.

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

gcloud

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

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

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

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

3. ברשת lb-network, יוצרים עוד רשת משנה לבדיקת הגישה הגלובלית באזור europe-west1:

   gcloud compute networks subnets create europe-subnet \
       --network=lb-network \
       --range=10.3.4.0/24 \
       --region=europe-west1
   

API

שולחים בקשת POST ל-method‏ networks.insert.

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

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

שולחים שתי בקשות POST ל-method‏ subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.0/24",
  "privateIpGoogleAccess": false
}

המסוף

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

   כניסה לדף Firewall policies

2. כדי לאפשר תעבורת נתונים ברשת המשנה, לוחצים על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-lb-access
   • רשת: lb-network
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: כל המכונות ברשת
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 10.1.2.0/24
   • Protocols and ports:‏ Allow all

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

4. כדי לאפשר חיבורי SSH נכנסים, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-ssh
   • רשת: lb-network
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-ssh
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 0.0.0.0/0
   • ‫Protocols and ports: בוחרים באפשרות Specified protocols and ports, מסמנים את התיבה TCP ומזינים 22 בשדה Ports.

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

6. כדי לאפשר בדיקות תקינות של Google Cloud , לוחצים על Create firewall rule בפעם השלישית ��מזינים את הפרטים הבאים:

   • שם: fw-allow-health-check
   • רשת: lb-network
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-health-check
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 35.191.0.0/16
   • Protocols and ports:‏ Allow all

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

gcloud

1. יוצרים את הכלל fw-allow-lb-access בחומת האש כדי לאפשר תקשורת מתוך תת-הרשת:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=tcp,udp,icmp
   

2. יוצרים את הכלל 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
   

3. יוצרים את הכלל fw-allow-health-check כדי לאפשר בדיקות תקינות של Google Cloud.

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check \
       --source-ranges=35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

API

כדי ליצור את הכלל fw-allow-lb-access בחומת האש, שולחים בקשת POST ל-method‏ firewalls.insert.

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

{
 "name": "fw-allow-lb-access",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

כדי ליצור את הכלל fw-allow-ssh בחומת האש, שולחים בקשת POST ל-method‏ firewalls.insert.

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

{
 "name": "fw-allow-ssh",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

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

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

{
 "name": "fw-allow-health-check",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [HEALTH_CHECK_RANGES],
 "targetTags": [
   "allow-health-check"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

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

• ‫PROJECT_ID: מזהה הפרויקט

• ‫HEALTH_CHECK_RANGES: רשימה מופרדת בפסיקים של Google Cloud טווחי בדיקות תקינות, בפורמט של מחרוזות במירכאות (לדוגמה, "192.0.2.0/24", "198.51.100.0/24")

המסוף

יצירת מכונות וירטואליות לקצה העורפי

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

   כניסה לדף VM instances

2. חוזרים על שלבים 3 עד 8 לכל VM, באמצעות השילובים הבאים של שם ואזור.

   • שם: vm-a1, אזור: us-west1-a
   • שם: vm-a2, אזור: us-west1-a
   • שם: vm-c1, אזור: us-west1-c
   • שם: vm-c2, אזור: us-west1-c

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

4. מגדירים את השם כפי שצוין בשלב 2.

5. בשדה Region, בוחרים את us-west1, ובוחרים Zone כמו שצוין בשלב 2.

6. בקטע Boot disk, מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ נבחרה כאפשרות לדיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

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

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

   1. בשדה Network tags, מזינים את הערכים allow-ssh ו-allow-health-check.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network
      • רשת משנה: lb-subnet
      • IP stack type:‏ IPv4 (single-stack)
      • כתובת IPv4 פנימית ראשית: זמנית (אוטומטית)
      • כתובת IPv4 חיצונית: זמנית

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

   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

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

יצירת קבוצות של מכונות

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

   כניסה לדף Instance groups

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

   • שם קבוצת המכונות: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
   • שם קבוצת המכונות: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

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

4. לוחצים על New unmanaged instance group.

5. מגדירים את השם כמו שצוין בשלב 2.

6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שצוין בשלב 2.

7. בשדה Network, בוחרים באפשרות lb-network.

8. בשדה Subnetwork, בוחרים באפשרות lb-subnet.

9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמתואר בשלב 2.

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

gcloud

1. כדי ליצור את ארבע המכונות הווירטואליות, מריצים את הפקודה הבאה ארבע פעמים, באמצעות ארבעת השילובים האלה של [VM-NAME] ו-[ZONE]. תוכן הסקריפט זהה בכל ארבע המכונות הווירטואליות.

   • ‫VM-NAME: vm-a1, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-a2, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-c1, ‏ ZONE: us-west1-c
   • ‫VM-NAME: vm-c2, ‏ ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
         --zone=ZONE \
         --image-family=debian-12 \
         --image-project=debian-cloud \
         --tags=allow-ssh,allow-health-check \
         --subnet=lb-subnet \
         --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

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

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

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

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

API

לארבע המכונות הווירטואליות, משתמשים בשמות ובאזורים הבאים:

• ‫VM-NAME: vm-a1, ‏ ZONE: us-west1-a
• ‫VM-NAME: vm-a2, ‏ ZONE: us-west1-a
• ‫VM-NAME: vm-c1, ‏ ZONE: us-west1-c
• ‫VM-NAME: vm-c2, ‏ ZONE: us-west1-c

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

gcloud compute images list \
 --filter="family=debian-12"

יוצרים ארבע מכונות וירטואליות לקצה העורפי על ידי שליחת ארבע בקשות POST ל-method‏ instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\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\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

כדי ליצור שתי קבוצות של מכונות, שולחים בקשת POST ל-method‏ instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

מוסיפים מכונות לכל קבוצת מכונות באמצעות שליחת בקשת POST ל-method‏ instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

המ��וף

התחלת ההגדרה

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

   כניסה לדף Load balancing

2. לוחצים על יצירת מאזן עומסים.
3. בקטע Type of load balancer, בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL)‎ ולוחצים על Next.
4. בקטע Proxy or passthrough, בוחרים באפשרות Passthrough load balancer ולוחצים על Next.
5. בקטע Public facing or internal, בוחרים באפשרות Internal ולוחצים על Next.
6. לוחצים על הגדרה.

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer, מזינים את הפרטים הבאים:

• שם של מאזן עומסים: be-ilb
• אזור: us-west1
• רשת: lb-network

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

1. לוחצים על Backend configuration.

2. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:

   • שם: hc-http-80
   • Protocol: HTTP
   • יציאה: 80
   • פרוטוקול שרת proxy: ללא
   • בקשה: /

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

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

4. כדי לטפל רק בתנועה של IPv4, בקטע New Backend, בוחרים באפשרות IPv4 (single-stack) בשביל IP stack type.

5. ברשימה Instance group, בוחרים את קבוצת המכונות ig-c ולוחצים על Done.

6. לוחצים על Add a backend וחוזרים על השלב כדי להוסיף את קבוצת המכונות ig-a.

7. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Backend configuration.

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

1. לוחצים על Frontend configuration.
2. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
   1. בשדה Name, מזינים fr-ilb.
   2. בשדה Subnetwork, בוחרים את lb-subnet.
   3. בקטע Internal IP purpose, ברשימה IP address בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve.
      • שם: ip-ilb
      • ‫IP version: IPv4
      • כתובת IP סטטית: אני ��וצה לבחור
      • כתובת IP בהתאמה אישית: 10.1.2.99
   4. בקטע Ports, בוחרים באפשרות Multiple ובקטע Port numbers מזינים את הערכים 80,‏ 8008,‏ 8080 ו-8088.
   5. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Frontend configuration.

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

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

gcloud

1. יוצרים בדיקת תקינות אזורית חדשה של HTTP כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. יוצרים את שירות הקצה העורפי לתעבורת נתונים ב-HTTP:

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

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

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. יוצרים כלל העברה לשירות לקצה העורפי. כשיוצרים את כלל ההעברה, מציינים את 10.1.2.99 לכתובת ה-IP הפנימית ברשת המשנה.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

ה��סוף

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

   כניסה לדף VM instances

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

3. בשדה Name, מזינים vm-client.

4. בשדה Region, בוחרים באפשרות us-west1.

5. בשדה Zone, בוחרים באפשרות us-west1-a.

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

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

   1. בשדה Network tags, מזינים את הערך allow-ssh.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network
      • רשת משנה: lb-subnet

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

gcloud

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

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

שולחים בקשת POST ל-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

המסוף

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

   כניסה לדף VPC networks

2. ‫add_boxיצירת רשת VPC.

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

4. כדי להגדיר טווחי כתובות IPv6 פנימיות ברשתות משנה ברשת הזו:

   1. בקטע Private IPv6 address settings, בוחרים באפשרות Configure a ULA internal IPv6 range for this רשת VPC.
   2. בשדה Allocate internal IPv6 range, בוחרים באפשרות Automatically או Manually. אם בוחרים באפשרות Manually, מזינים טווח של /48 מתוך הטווח של fd20::/20. אם הטווח נמצא בשימוש, תתבקשו לספק טווח אחר.

5. בקטע Subnet creation mode, בוחרים באפשרות Custom.

6. בקטע New subnet, מציינים את הפרמטרים הבאים להגדרת רשת משנה:

   • שם: lb-subnet
   • אזור: us-west1
   • סוג מחסנית IP‏: IPv4 ו-IPv6 (מחסנית כפולה)
   • טווח IPv4: 10.1.2.0/24.
   • סוג גישה ל-IPv6: פנימי

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

8. לוחצים על Add subnet ומזינים את הפרטים הבאים:

   • שם: europe-subnet
   • אזור: europe-west1
   • IP stack type:‏ IPv4 (single-stack)
   • טווח כתובות IP: 10.3.4.0/24

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

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

gcloud

1. כדי ליצור רשת VPC חדשה במצב מותאם אישית, מריצים את הפקודה gcloud compute networks create.

   כדי להגדיר טווחי IPv6 פנימיים בכל רשתות המשנה ברשת הזו, משתמשים בדגל --enable-ula-internal-ipv6. האפשרות הזו מקצה קידומת ULA של /48 מתוך הטווח fd20::/20 שמשמש את Google Cloud לטווחי רשתות משנה פנימיות של IPv6. אם רוצים לבחור את טווח ה-IPv6 של /48 שהוקצה, משתמשים בדגל --internal-ipv6-range כדי לציין טווח.

   gcloud compute networks create lb-network-dual-stack \
      --subnet-mode=custom \
      --enable-ula-internal-ipv6 \
      --internal-ipv6-range=ULA_IPV6_RANGE \
      --bgp-routing-mode=regional
   

   מחליפים את ULA_IPV6_RANGE בקידומת /48 מתוך הטווח fd20::/20 שמשמש את Google לטווחי רשתות משנה פנימיות של IPv6. אם לא משתמשים בדגל --internal-ipv6-range, ‏Google בוחרת קידומת /48 לרשת, למשל fd20:bc7:9a1c::/48.

2. ברשת NETWORK, יוצרים רשת משנה לקצוות עורפיים באזור us-west1 ורשת משנה נוספת לבדיקת הגישה הגלובלית באזור europe-west1.

   כדי ליצור את רשתות המשנה, מריצים את הפקודה gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet \
      --network=lb-network-dual-stack \
      --range=10.1.2.0/24 \
      --region=us-west1 \
      --stack-type=IPV4_IPV6 \
      --ipv6-access-type=INTERNAL
   

   gcloud compute networks subnets create europe-subnet \
      --network=lb-network-dual-stack \
      --range=10.3.4.0/24 \
      --region=europe-west1 \
      --stack-type=IPV4_IPV6 \
      --ipv6-access-type=INTERNAL
   

API

יוצרים רשת VPC חדשה במצב מותאם אישית.

כדי להגדיר טווחי IPv6 פנימיים בכל רשתות המשנה ברשת הזו, מגדירים את enableUlaInternalIpv6 כ-true. האפשרות הזו מקצה טווח /48 מתוך הטווח fd20::/20 שמשמש את Google לטווחי רשתות משנה פנימיות של IPv6. אם רוצים לבחור איזה טווח IPv6 של /48 יוקצה, צריך להשתמש גם בשדה internalIpv6Range כדי לציין טווח.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }
 

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

• ‫PROJECT_ID: מזהה הפרויקט שבו נוצרה רשת ה-VPC.
• ‫MTU: יחידת השידור המקסימלית של הרשת. הערך של MTU יכול להיות 1460 (ברירת המחדל) או 1500. לפני שמגדירים את ה-MTU ל-1500, כדאי לקרוא את הסקירה הכללית על יחידת שידור מקסימלית.
• ‫ULA_IPV6_RANGE: קידומת /48 מתוך הטווח fd20::/20 שמשמש את Google לטווחי רשתות משנה פנימיות של IPv6. אם לא תציינו ערך ל-internalIpv6Range, ‏Google תבחר קידומת /48 לרשת.

• DYNAMIC_ROUTING_MODE: הערך global או regional, כדי לשלוט בהתנהגות של פרסום הניתוב (route advertisement) של נתבי Cloud Router ברשת. מידע נוסף זמין במאמר מצב ניתוב דינמי.

  מידע נוסף זמין במאמר השיטה networks.insert.

שולחים שתי בקשות POST ל-method‏ subnetworks.insert.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.3.4.0/24",
   "network": "lb-network-dual-stack",
   "name": "europe-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

המסוף

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

   כניסה לדף Firewall policies

2. כדי ליצור את הכלל שמאפשר תנועה ברשת המשנה, לוחצים על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-lb-access
   • רשת: lb-network-dual-stack
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: כל המכונות ברשת
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 10.1.2.0/24 ו-10.3.4.0/24
   • Protocols and ports:‏ Allow all

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

4. כדי לאפשר תעבורת נתונים ברשת משנה של IPv6, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-lb-access-ipv6
   • רשת: lb-network-dual-stack
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • מטרות: כל המופעים ברשת
   • מסנן מקור: טווחי IPv6
   • טווחי IPv6 של המקור: IPV6_ADDRESS שהוקצו ב-lb-subnet
   • Protocols and ports:‏ Allow all

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

6. כדי לאפשר חיבורי SSH נכנסים, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-ssh
   • רשת: lb-network-dual-stack
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-ssh
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 0.0.0.0/0
   • ‫Protocols and ports: בוחרים באפשרות Specified protocols and ports, מסמנים את התיבה TCP ומזינים 22 בשדה Ports.

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

8. כדי לאפשר ��דיקות ת��ינות של Google Cloud IPv6, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-health-check-ipv6
   • רשת: lb-network-dual-stack
   • עדיפות: 1000
   • כיוון התנועה: ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-health-check-ipv6
   • מסנן מקור: טווחי IPv6
   • טווחי IPv6 של המקור: 2600:2d00:1:b029::/64
   • Protocols and ports:‏ Allow all

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

10. כדי לאפשר בדיקות תקינות של Google Cloud , לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

    • שם: fw-allow-health-check
    • רשת: lb-network-dual-stack
    • עדיפות: 1000
    • כיוון התנועה: ingress
    • פעולה במקרה של התאמה: אישור
    • יעדים: תגי יעד שצוינו
    • תגי יעד: allow-health-check
    • מסנן מקור: טווחי IPv4
    • טווחי IPv4 של המקור: 35.191.0.0/16
    • Protocols and ports:‏ Allow all

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

gcloud

1. יוצרים את כלל חומת האש fw-allow-lb-access כדי לאפשר תקשורת עם תת-הרשת:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=all
   

2. יוצרים את כלל חומת האש fw-allow-lb-access-ipv6 כדי לאפשר תקשורת עם תת-הרשת:

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=IPV6_ADDRESS \
       --rules=all
   

   מחליפים את IPV6_ADDRESS בכתובת ה-IPv6 שהוקצתה ב-lb-subnet.

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

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

4. יוצרים את הכלל fw-allow-health-check-ipv6 כדי לאפשר בדיקות תקינות שלGoogle Cloud IPv6.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check-ipv6 \
       --source-ranges=2600:2d00:1:b029::/64 \
       --rules=tcp,udp
   

5. יוצרים את הכלל fw-allow-health-check כדי לאפשר בדיקות תקינות של Google CloudIPv4.

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check \
       --source-ranges=35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

API

1. כדי ליצור את הכלל fw-allow-lb-access בחומת האש, שולחים בקשת POST ל-method‏ firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-lb-access",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24", "10.3.4.0/24"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

2. כדי ליצור את הכלל fw-allow-lb-access-ipv6 בחומת האש, שולחים בקשת POST ל-method‏ firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
    "name": "fw-allow-lb-access-ipv6",
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "icmp"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

   מחליפים את IPV6_ADDRESS בכתובת ה-IPv6 שהוקצתה ב-lb-subnet.

3. כדי ליצור את הכלל fw-allow-ssh בחומת האש, שולחים בקשת POST ל-method‏ firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-ssh",
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

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

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-health-check-ipv6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [HEALTH_CHECK_RANGES],
   "targetTags": [
     "allow-health-check-ipv6"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

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

   • ‫PROJECT_ID: מזהה הפרויקט

   • ‫HEALTH_CHECK_RANGES: רשימה מופרדת בפסיקים של Google Cloud טווחי בדיקות תקינות, בפורמט של מחרוזות במירכאות (לדוגמה, "‎2001:db8::/32")

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

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-health-check",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [HEALTH_CHECK_RANGES],
   "targetTags": [
     "allow-health-check"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

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

   • ‫PROJECT_ID: מזהה הפרויקט

   • ‫HEALTH_CHECK_RANGES: רשימה מופרדת בפסיקים של Google Cloud טווחי בדיקות תקינות, בפורמט של מחרוזות במירכאות (לדוגמה, "192.0.2.0/24", "198.51.100.0/24")

המסוף

יצירת מכונות וירטואליות לקצה העורפי

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

   כניסה לדף VM instances

2. חוזרים על שלבים 3 עד 8 לכל VM, באמצעות השילובים הבאים של שם ואזור.

   • שם: vm-a1, אזור: us-west1-a
   • שם: vm-a2, אזור: us-west1-a
   • שם: vm-c1, אזור: us-west1-c
   • שם: vm-c2, אזור: us-west1-c

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

4. מגדירים את השם כפי שצוין בשלב 2.

5. בשדה Region בוחרים את us-west1, ובוחרים Zone כמו שצוין בשלב 2.

6. בקטע Boot disk, מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ נבחרה כאפשרות לדיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

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

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

   1. בשדה Network tags, מזינים את הערכים allow-ssh ו-allow-health-check-ipv6.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network-dual-stack
      • רשת משנה: lb-subnet
      • IP stack type:‏ IPv4 and IPv6 (dual-stack)
      • כתובת IPv4 פנימית ראשית: זמנית (אוטומטית)
      • כתובת IPv4 חיצונית: זמנית

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

      #! /bin/bash
      if [ -f /etc/startup_script_completed ]; then
      exit 0
      fi
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      file_ports="/etc/apache2/ports.conf"
      file_http_site="/etc/apache2/sites-available/000-default.conf"
      file_https_site="/etc/apache2/sites-available/default-ssl.conf"
      http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
      http_vh_prts="*:80 *:8008 *:8080 *:8088"
      https_listen_prts="Listen 443\nListen 8443"
      https_vh_prts="*:443 *:8443"
      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
      prt_conf="$(cat "$file_ports")"
      prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
      prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
      echo "$prt_conf" | tee "$file_ports"
      http_site_conf="$(cat "$file_http_site")"
      http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
      echo "$http_site_conf_2" | tee "$file_http_site"
      https_site_conf="$(cat "$file_https_site")"
      https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
      echo "$https_site_conf_2" | tee "$file_https_site"
      systemctl restart apache2
      touch /etc/startup_script_completed
      

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

יצירת קבוצות של מכונות

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

   כניסה לדף Instance groups

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

   • שם קבוצת המכונות: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
   • שם קבוצת המכונות: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

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

4. לוחצים על New unmanaged instance group.

5. מגדירים את Name (שם) כמו שצוין בשלב 2.

6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שצוין בשלב 2.

7. בשדה Network, בוחרים באפשרות lb-network-dual-stack.

8. בשדה Subnetwork, בוחרים את lb-subnet.

9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמתואר בשלב 2.

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

gcloud

1. כדי ליצור את ארבע המכונות הווירטואליות, מריצים את הפקודה gcloud compute instances create ארבע פעמים, באמצעות ארבעת השילובים האלה של [VM-NAME] ו-[ZONE]. תוכן הסקריפט זהה בכל ארבע המכונות הווירטואליות.

   • ‫VM-NAME: vm-a1, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-a2, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-c1, ‏ ZONE: us-west1-c

   • ‫VM-NAME: vm-c2, ‏ ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet \
       --stack-type=IPV4_IPV6 \
       --metadata=startup-script='#! /bin/bash
     if [ -f /etc/startup_script_completed ]; then
     exit 0
     fi
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     file_ports="/etc/apache2/ports.conf"
     file_http_site="/etc/apache2/sites-available/000-default.conf"
     file_https_site="/etc/apache2/sites-available/default-ssl.conf"
     http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
     http_vh_prts="*:80 *:8008 *:8080 *:8088"
     https_listen_prts="Listen 443\nListen 8443"
     https_vh_prts="*:443 *:8443"
     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
     prt_conf="$(cat "$file_ports")"
     prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
     prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
     echo "$prt_conf" | tee "$file_ports"
     http_site_conf="$(cat "$file_http_site")"
     http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
     echo "$http_site_conf_2" | tee "$file_http_site"
     https_site_conf="$(cat "$file_https_site")"
     https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
     echo "$https_site_conf_2" | tee "$file_https_site"
     systemctl restart apache2
     touch /etc/startup_script_completed'
     

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

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

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

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

api

לארבע המכונות הווירטואליות, משתמשים בשמות ובאזורים הבאים:

• ‫VM-NAME: vm-a1, ‏ ZONE: us-west1-a
• ‫VM-NAME: vm-a2, ‏ ZONE: us-west1-a
• ‫VM-NAME: vm-c1, ‏ ZONE: us-west1-c
• ‫VM-NAME: vm-c2, ‏ ZONE: us-west1-c

כדי לקבל את הערך הנוכחי של DEBIAN_IMAGE_NAME, מריצים את הפקודה הבאה ב-gcloud:

gcloud compute images list \
 --filter="family=debian-12"

יוצרים ארבע מכונות וירטואליות לקצה העורפי על ידי שליחת ארבע בקשות POST ל-method‏ instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check-ipv6",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

כדי ליצור שתי קבוצות של מכונות, שולחים בקשת POST ל-method‏ instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

מוסיפים מכונות לכל קבוצת מכונות באמצעות שליחת בקשת POST ל-method‏ instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

המסוף

התחלת ההגדרה

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

   כניסה לדף Load balancing

2. לוחצים על יצירת מאזן עומסים.
3. בקטע Type of load balancer, בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL)‎ ולוחצים על Next.
4. בקטע Proxy or passthrough, בוחרים באפשרות Passthrough load balancer ולוחצים על Next.
5. בקטע Public facing or internal, בוחרים באפשרות Internal ולוחצים על Next.
6. לוחצים על הגדרה.

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer, מזינים את הפרטים הבאים:

• שם של מאזן עומסים: be-ilb
• אזור: us-west1
• רשת: lb-network-dual-stack

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

1. לוחצים על Backend configuration.
2. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:
   • שם: hc-http-80
   • היקף: אזורי
   • Protocol:‏ HTTP
   • יציאה: 80
   • פרוטוקול שרת proxy‏: NONE
   • בקשה: /
3. לוחצים על יצירה.
4. בקטע New Backend, בשביל IP stack type בוחרים באפשרות IPv4 and IPv6 (dual-stack).
5. ב-Instance group, בוחרים את קבוצת המכונות ig-a ולוחצים על Done.
6. לוחצים על Add a backend וחוזרים על השלב כדי להוסיף את קבוצת המכונות ig-c.
7. מוודאים שמופיע סימן וי כחול ליד Backend configuration.

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

1. לוחצים על Frontend configuration. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
   1. בשדה Name, מזינים fr-ilb-ipv6.
   2. כדי לטפל בתנועת IPv6, מבצעים את הפעולות הבאות:
      1. בשביל IP version, בוחרים IPv6.
      2. בשדה Subnetwork, בוחרים את lb-subnet. טווח כתובות ה-IPv6 בכלל ההעברה הוא תמיד זמני.
      3. בשדה Ports, בוחרים באפשרות Multiple, ואז בשדה Port number מזינים את הערכים 80,8008,8080,8088.
      4. ��וחצים על סיום.
   3. כדי לטפל בתנועת IPv4, מבצעים את הפעולות הבאות:
      1. לוחצים על Add frontend IP and port.
      2. בשדה Name, מזינים fr-ilb.
      3. בשדה Subnetwork, בוחרים את lb-subnet.
      4. בקטע Internal IP purpose, ברשימה IP address בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve.
         • שם: ip-ilb
         • ‫IP version: IPv4
         • כתובת IP סטטית: אני רוצה לבחור
         • כתובת IP בהתאמה אישית: 10.1.2.99
      5. בשדה Ports, בוחרים באפשרות Multiple, ובשדה Port numbers מזינים את הערכים 80,‏ 8008,‏ 8080 ו-8088.
      6. לוחצים על סיום.
      7. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Frontend configuration.

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

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

gcloud

1. יוצרים בדיקת תקינות אזורית חדשה של HTTP כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. יוצרים את שירות הקצה העורפי לתעבורת נתונים ב-HTTP:

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

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

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. יוצרים שני כללי העברה לשירות לקצה העורפי. כשיוצרים את כלל ההעברה של IPv4, מציינים את 10.1.2.99 לכתובת ה-IP הפנימית ברשת המשנה של כתובות IPv4.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

api

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-ipv6",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

המסוף

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

   כניסה לדף VM instances

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

3. בשדה Name, מזינים vm-client.

4. בשדה Region, בוחרים באפשרות us-west1.

5. בשדה Zone, בוחרים באפשרות us-west1-a.

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

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

   1. בשדה Network tags, מזינים את הערך allow-ssh.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network-dual-stack
      • רשת משנה: lb-subnet
      • IP stack type:‏ IPv4 and IPv6 (dual-stack)
      • כתובת IP פנימית ראשית:‏ ארעית (אוטומטית)
      • ‫כתובת IP חיצונית:‏ Ephemeral
   3. לוחצים על סיום.

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

gcloud

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

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

שולחים בקשת POST ל-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

ה��סוף

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

   כניסה לדף VPC networks

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

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

4. כדי להגדיר טווחי כתובות IPv6 פנימיות ברשתות משנה ברשת הזו:

   1. בקטע Private IPv6 address settings, בוחרים באפשרות Configure a ULA internal IPv6 range for this רשת VPC.
   2. בשדה Allocate internal IPv6 range, בוחרים באפשרות Automatically או Manually. אם בוחרים באפשרות Manually, מזינים טווח של /48 מתוך הטווח של fd20::/20. אם הטווח כבר בשימוש, תתבקשו לספק טווח אחר.

5. בקטע Subnet creation mode, בוחרים באפשרות Custom.

6. בקטע New subnet, מציינים את הפרמטרים הבאים להגדרת רשת משנה:

   • שם: lb-subnet-ipv6-only
   • אזור: us-west1
   • IP stack type:‏ IPv6 (single-stack)
   • סוג גישה ל-IPv6: פנימי

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

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

gcloud

1. כדי ליצור רשת VPC חדשה במצב מותאם אישית, מריצים את הפקודה gcloud compute networks create.

   כדי להגדיר טווחי IPv6 פנימיים בכל רשת משנה ברשת הזו, משתמשים בדגל --enable-ula-internal-ipv6.

   gcloud compute networks create lb-network-ipv6-only \
     --subnet-mode=custom \
     --enable-ula-internal-ipv6 \
     --bgp-routing-mode=regional
   

2. מגדירים רשת משנה עם ipv6-access-type שמוגדר ל-INTERNAL. המשמעות היא שלמכונות הווירטואליות ברשת המשנה הזו יכולות להיות רק כתובות IPv6 פנימיות.כדי ליצור את רשת המשנה, מריצים את הפקודה gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet-ipv6-only \
     --network=lb-network-ipv6-only \
     --region=us-west1 \
     --stack-type=IPV6_ONLY \
     --ipv6-access-type=INTERNAL
   

המסוף

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

   כניסה לדף Firewall policies

2. כדי לאפשר תעבורת נתונים של רשת משנה ב-IPv6, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-lb-access-ipv6-only
   • רשת: lb-network-ipv6-only
   • עדיפות: 1000
   • כיוון התנועה: Ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: כל המכונות ברשת
   • מסנן מקור: טווחי IPv6
   • טווחי IPv6 של המקור: ::/0
   • Protocols and ports:‏ Allow all

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

4. כדי לאפשר חיבורי SSH נכנסים, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-ssh
   • רשת: lb-network-ipv6-only
   • עדיפות: 1000
   • כיוון התנועה: Ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-ssh
   • מסנן מקור: טווחי IPv4
   • טווחי IPv4 של המקור: 0.0.0.0/0
   • ‫Protocols and ports: בוחרים באפשרות Specified protocols and ports, מסמנים את התיבה TCP ומזינים 22 בשדה Ports.

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

6. כדי לאפשר בדיקות תקינות של Google Cloud IPv6, לוחצים שוב על Create firewall rule ומזינים את הפרטים הבאים:

   • שם: fw-allow-health-check-ipv6-only
   • רשת: lb-network-ipv6-only
   • עדיפות: 1000
   • כיוון התנועה: Ingress
   • פעולה במקרה של התאמה: אישור
   • יעדים: תגי יעד שצוינו
   • תגי יעד: allow-health-check-ipv6
   • מסנן מקור: טווחי IPv6
   • טווחי IPv6 של המקור: 2600:2d00:1:b029::/64
   • Protocols and ports:‏ Allow all

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

gcloud

1. יוצרים את כלל חומת האש fw-allow-lb-access-ipv6-only כדי לאפשר תעבורת IPv6 לכל המכונות הווירטואליות ברשת ה-VPC.

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6-only \
       --network=lb-network-ipv6-only \
       --action=allow \
       --direction=ingress \
       --source-ranges=::/0 \
       --rules=all
   

2. יוצרים את הכלל fw-allow-ssh בחומת האש כדי לאפשר קישוריות SSH למכונות וירטואליות עם תג הרשת allow-ssh. אם משמיטים את source-ranges,Google Cloud מפרש את הכלל כך שהוא יחול על כל מקור.

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

3. יוצרים את הכלל fw-allow-health-check-ipv6 כדי לאפשר בדיקות תקינות שלGoogle Cloud IPv6.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6-only \
       --network=lb-network-ipv6-only \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check-ipv6 \
       --source-ranges=2600:2d00:1:b029::/64 \
       --rules=tcp,udp
   

המסוף

י��י��ת ��כונות וירטואליות לקצה העורפי

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

   כניסה לדף VM instances

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

   • שם: vm-a1, אזור: us-west1-a
   • שם: vm-a2, אזור: us-west1-a
   • שם: vm-c1, אזור: us-west1-c
   • שם: vm-c2, אזור: us-west1-c

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

4. מגדירים את השם כפי שצוין בשלב 2.

5. בשדה Region בוחרים את us-west1, ובוחרים Zone כמו שצוין בשלב 2.

6. בקטע Boot disk, מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ נבחרה כאפשרות לדיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

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

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

   1. בשדה Network tags, מזינים את הערכים allow-ssh ו-allow-health-check-ipv6.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network-ipv6-only
      • רשת משנה: lb-subnet-ipv6-only
      • IP stack type:‏ IPv6 (single-stack)
      • Primary internal IPv6 address:‏ Ephemeral (Automatic)

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

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

יצירת קבוצות של מכונות

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

   כניסה לדף Instance groups

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

   • שם קבוצת המכונות: ig-a, אזור: us-west1-a, מכונות וירטואליות: vm-a1 ו-vm-a2
   • שם קבוצת המכונות: ig-c, אזור: us-west1-c, מכונות וירטואליות: vm-c1 ו-vm-c2

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

4. לוחצים על New unmanaged instance group.

5. מגדירים את Name (שם) כמו שצוין בשלב 2.

6. בקטע Location, בוחרים באפשרות us-west1 בשדה Region, ואז בוחרים Zone כמו שצוין בשלב 2.

7. בשדה Network, בוחרים באפשרות lb-network-ipv6-only.

8. בשדה Subnetwork, בוחרים את lb-subnet-ipv6-only.

9. בקטע VM instances, מוסיפים את המכונות הווירטואליות כמו שמתואר בשלב 2.

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

gcloud

1. כדי ליצור את ארבע המכונות הווירטואליות, מריצים את הפקודה gcloud compute instances create ארבע פעמים, באמצעות ארבעת השילובים האלה של [VM-NAME] ו-[ZONE].

   • ‫VM-NAME: vm-a1, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-a2, ‏ ZONE: us-west1-a
   • ‫VM-NAME: vm-c1, ‏ ZONE: us-west1-c
   • ‫VM-NAME: vm-c2, ‏ ZONE: us-west1-c

   gcloud beta compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet-ipv6-only \
       --stack-type=IPV6_ONLY
   

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

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

   gcloud beta compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud beta compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

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

   gcloud beta compute instance-groups unmanaged add-instances ig-a \
     --zone=us-west1-a \
     --instances=vm-a1,vm-a2
   gcloud beta compute instance-groups unmanaged add-instances ig-c \
     --zone=us-west1-c \
     --instances=vm-c1,vm-c2
   

המסוף

התחלת ההגדרה

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

   כניסה לדף Load balancing

2. לוחצים על יצירת מאזן עומסים.
3. בקטע Type of load balancer, בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL)‎ ולוחצים על Next.
4. בקטע Proxy or passthrough, בוחרים באפשרות Passthrough load balancer ולוחצים על Next.
5. בקטע Public facing or internal, בוחרים באפשרות Internal ולוחצים על Next.
6. לוחצים על הגדרה.

הגדרה בסיסית

בדף Create internal passthrough Network Load Balancer, מזינים את הפרטים הבאים:

• שם של מאזן עומסים: ilb-ipv6-only
• אזור: us-west1
• רשת: lb-network-ipv6-only

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

1. לוחצים על Backend configuration.
2. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:
   • שם: hc-http-80
   • היקף: אזורי
   • Protocol:‏ HTTP
   • יציאה: 80
   • פרוטוקול שרת proxy: ללא
   • בקשה: /
3. לוחצים על יצירה.
4. בקטע New Backend, בוחרים באפשרות IPv6 (single-stack) בשביל IP stack type.
5. ב-Instance group, בוחרים את קבוצת המכונות ig-a ולוחצים על Done.
6. לוחצים על Add a backend וחוזרים על השלב כדי להוסיף את קבוצת המכונות ig-c.
7. מוודאים שמופיע סימן וי כחול ליד Backend configuration.

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

1. לוחצים על Frontend configuration. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
   1. בשדה Name, מזינים fr-ilb-ipv6-only.
   2. כדי לטפל בתנועת IPv6, מבצעים את הפעולות הבאות:
      1. בשביל IP version, בוחרים IPv6. שרת ה-TCP ב-IPv6 שתיצרו בקטע הבא מקושר ל-VIP של כלל ההעברה.
      2. בשדה Subnetwork, בוחרים את lb-subnet-ipv6-only. טווח כתובות ה-IPv6 בכלל ההעברה הוא תמיד זמני.
      3. בשדה Ports, בוחרים באפשרות Multiple, ואז בשדה Port number מזינים את הערכים 80,8008,8080,8088.
      4. לוחצים על סיום.
   3. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Frontend configuration.

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

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

gcloud

1. יוצרים בדיקת תקינות אזורית חדשה של HTTP כדי לבדוק את הקישוריות של HTTP למכונות הווירטואליות ביציאה 80.

   gcloud beta compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

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

   gcloud beta compute backend-services create ilb-ipv6-only \
       --load-balancing-scheme=INTERNAL \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

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

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. יוצרים את כלל ההעברה של IPv6 עם כתובת IPv6 זמנית.

   gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
       --region=us-west1 \
       --load-balancing-scheme=INTERNAL \
       --subnet=lb-subnet-ipv6-only \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=ilb-ipv6-only \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

   שרת ה-TCP ב-IPv6 שתיצרו בקטע הבא מקושר ל-VIP של כלל ההעברה.

המסוף

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

2. לוחצים על Edit.

3. בקטע Metadata, מזינים את הסקריפט הבא בשדה סקריפט לטעינה בזמן ההפעלה.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

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

5. מפעילים מחדש את המכונה.

gcloud

1. יוצרים סקריפט לטעינה בזמן ההפעלה.

   nano startup.sh
   

2. מוסיפים את הסקריפט הבא ושומרים את הקובץ.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

3. מוסיפים את קובץ המטא-נתונים למכונה הווירטואלית.

   gcloud compute instances add-metadata VM-NAME \
     --metadata-from-file=startup-script=startup.sh
   

4. מפעילים מחדש את המכונה.

המסוף

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

   כניסה לדף VM instances

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

3. בשדה Name, מזינים vm-client.

4. בשדה Region, בוחרים באפשרות us-west1.

5. בשדה Zone, בוחרים באפשרות us-west1-a.

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

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

   1. בשדה Network tags, מזינים את הערך allow-ssh.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network-ipv6-only
      • רשת משנה: lb-subnet-ipv6-only
      • IP stack type:‏ IPv6 (single-stack)
   3. לוחצים על סיום.

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

gcloud

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

gcloud beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

המסוף

עריכת כלל ההעברה של מאזן העומסים

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

   כניסה לדף Load balancing

2. בעמודה Name, לוחצים על מאזן עומסי הרשת הפנימי להעברת סיגנל ללא שינוי. מגדירים את מאזן העומסים לדוגמה בשם be-ilb.

3. לוחצים על Frontend configuration.

4. לוחצים על Edit ‏edit.

5. בקטע גישה גלובלית, בוחרים באפשרות הפעלה.

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

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

בדף Load balancer details, מוודאים שבהגדרת ממשק המשתמש כתוב Regional (REGION) with global access.

gcloud

1. מעדכנים את כלל ההעברה של מאזן העומסים לדוגמה, fr-ilb, כך שיכלול את הדגל --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
        --region=us-west1 \
        --allow-global-access
   

2. אפשר להשתמש בפקודה forwarding-rules describe כדי לבדוק אם הגישה הגלובלית מופעלת בכלל העברה. לדוגמה:

    gcloud compute forwarding-rules describe fr-ilb \
        --region=us-west1 \
        --format="get(name,region,allowGlobalAccess)"
   

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

API

שולחים בקשת PATCH ל-method‏ forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

המסוף

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

   כניסה לדף VM instances

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

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

4. מגדירים את Region לערך europe-west1.

5. מגדירים את Zone לערך europe-west1-b.

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

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

   1. בשדה Network tags, מזינים את הערך allow-ssh.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network
      • רשת משנה: europe-subnet

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

gcloud

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

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

שולחים בקשת POST ל-method‏ instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
  {
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
    "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

המסוף

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

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

   לדף VM instance templates

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

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

4. בוחרים סוג מכונה.

5. בקטע Boot disk, מוודאים שהאפשרות Debian GNU/Linux 12 (bookworm)‎ נבחרה כאפשרות לדיסק האתחול. אם צריך, לוחצים על שינוי כדי לשנות את התמונה.

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

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

   1. בשדה Network tags, מזינים את הערכים allow-ssh ו-allow-health-check.
   2. בקטע Network interfaces, בוחרים את האפשרויות הבאות:
      • רשת: lb-network
      • רשת משנה: lb-subnet

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

   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

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

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

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

   כניסה לדף Instance groups

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

3. מגדירים את Name לערך ig-ilb.

4. בשדה Location, בוחרים באפשרות Multi-zone ומגדירים את Region לערך us-west1.

5. מגדירים את תבנית של הגדרות מכונה לערך template-vm-ilb.

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

7. מגדירים את Minimum number of instances לערך 1 ואת Maximum number of instances לערך 6.

8. אופציונלי: מגדירים תיקון תוכנה אוטומטי (autohealing). אם אתם מגדירים תיקון אוטומטי, השתמשו באותה בדיקת תקינות שבה משתמש שירות הקצה העורפי של מאזן עומסי הרשת הפנימי להעברת נתונים ללא שינוי. בדוגמה הזו, משתמשים ב-hc-http-80.

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

gcloud

1. יוצרים את תבנית של הגדרות מכונה. אפשר גם להגדיר פרמטרים אחרים, כמו סוג המכונה, לתבנית של קובץ האימג'.

   gcloud compute instance-templates create template-vm-ilb \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --region=us-west1 \
       --network=lb-network \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

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

   gcloud compute instance-groups managed create ig-ilb \
       --template=template-vm-ilb \
       --region=us-west1 \
       --size=6
   

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

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-ilb \
       --instance-group-region=us-west1
   

4. מנתקים את שתי קבוצות המכונות הלא מנוהלות (ברמת האזור) מהשירות לקצה העורפי:

   gcloud compute backend-services remove-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services remove-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

המסוף

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

   כניסה לדף VM instances

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

3. לוחצים על השם של המכונה הווירטואלית לקצה העורפי, לדוגמה vm-a1.

4. לוחצים על editעריכה.

5. בקטע Network interfaces, לוחצים על הרשת.

6. ברשימת כתובת IP חיצונית, בוחרים את הערך None ולוחצים על Done.

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

gcloud

1. כדי לחפש את האזור של מכונה – לדוגמה, אם אתם משתמשים בקבוצת מופעי מכונה מנוהלים אזורית – מריצים את הפקודה הבאה לכל מכונה כדי לקבוע את האזור שלה. מחליפים את [SERVER-VM] בשם של המכונה הווירטואלית שרוצים לחפש.

   gcloud compute instances list --filter="name=[SERVER-VM]"
   

2. חוזרים על השלב הבא לכל מכונה וירטואלית לקצה העורפי. מחליפים את [SERVER-VM] בשם של המכונה הווירטואלית, ואת [ZONE] באזור של המכונה הווירטואלית.

   gcloud compute instances delete-access-config [SERVER-VM] \
       --zone=[ZONE] \
       --access-config-name=external-nat
   

API

שולחים בקשת POST לשיטה instances.deleteAccessConfig לכל מכונה וירטואלית בקצה העורפי, ומחליפים את vm-a1 בשם של המכונה הווירטואלית ואת us-west1-a באזור של המכונה הווירטואלית.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

המסוף

מחיקת כלל ההעברה ויצירת כלל חדש

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

   כניסה לדף Load balancing

2. לוחצים על מאזן העומסים be-ilb ואז על Edit.

3. לוחצים על Frontend configuration.

4. מציבים את הסמן מעל כלל ההעברה 10.1.2.9 ולוחצים על deleteמחיקה.

5. לוחצים על Add frontend IP and port.

6. בקטע New Frontend IP and port, מזינים את הפרטים הבאים ולוחצים על Done:

   • שם: fr-ilb
   • רשת משנה: lb-subnet
   • כתובת IP פנימית: ip-ilb
   • יציאות: הכול.

7. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Frontend configuration.

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

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

gcloud

1. מוחקים את כלל ההעברה הקיים, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

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

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=ALL \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

כדי למחוק את כלל ההעברה, שולחים בקשת DELETE ל-method‏ forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

המסוף

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

   כניסה לדף Forwarding rules

2. בעמודה שם, לוחצים על fr-ilb ואז על מחיקה.

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

   כניסה לדף Load balancing

4. בעמודה שם, לוחצים על be-ilb.

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

6. לוחצים על Frontend configuration.

7. לוחצים על Add frontend IP and port.

8. בקטע New Frontend IP and port:

   1. בשדה Name, מזינים fr-ilb-http.
   2. בשדה Subnetwork, בוחרים באפשרות lb-subnet.
   3. בשדה Internal IP purpose, בוחרים באפשרות Shared.
   4. מרשימת כתובות IP, בוחרים באפשרות Create IP address, מזינים את הפרטים הבאים ולוחצים על Reserve:
      • שם: internal-10-1-2-99
      • כתובת IP סטטית: אני רוצה לבחור
      • כתובת IP בהתאמה אישית: 10.1.2.99
   5. בשדה Ports, בוחרים באפשרות Multiple, ובשדה Port numbers מזינים את הערכים 80,‏ 8008,‏ 8080 ו-8088.
   6. לוחצים על סיום.

9. לוחצים על Add frontend IP and port.

10. בקטע New Frontend IP and port:

    1. בשדה Name, מזינים fr-ilb-https.
    2. בשדה Subnetwork, בוחרים באפשרות lb-subnet.
    3. בשדה Internal IP purpose, בוחרים באפשרות Shared.
    4. מרשימת כתובות IP, בוחרים באפשרות internal-10-1-2-99.
    5. בשדה Ports, בוחרים באפשרות Multiple, ובשדה Port numbers מזינים את הערכים 443 ו-8443.
    6. לוחצים על סיום.

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

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

gcloud

1. מוחקים את כלל ההעברה הקיים, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. יוצרים כתובת IP פ��ימ��ת ��טטית (ש��ו��ה) בשביל 10.1.2.99 ומגדירים את הדגל --purpose לערך SHARED_LOADBALANCER_VIP. הדגל --purpose נדרש כדי ששני כללי העברה פנימיים יוכלו להשתמש באותה כתובת IP פנימית.

   gcloud compute addresses create internal-10-1-2-99 \
       --region=us-west1 \
       --subnet=lb-subnet \
       --addresses=10.1.2.99 \
       --purpose=SHARED_LOADBALANCER_VIP
   

   1. יוצרים שני כללי העברה חלופיים עם הפרמטרים הבאים:

   gcloud compute forwarding-rules create fr-ilb-http \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

   gcloud compute forwarding-rules create fr-ilb-https \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=443,8443 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

כדי למחוק את כלל ההעברה, שולחים בקשת DELETE ל-method‏ forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

כדי ליצור כתובת IP פנימית סטטית (שמורה) ל-10.1.2.99 ולהגדיר את המטרה שלה ל-SHARED_LOADBALANCER_VIP, שולחים בקשת POST ל-method‏ addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

יוצרים שני כללי העברה באמצעות שתי בקשות POST ל-method‏ forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

המסוף

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

   כניסה לדף Load balancing

2. לוחצים על be-ilb (הש�� של שירות הקצה העורפי שיצרתם בדוגמה הזו) ואז על Edit.

3. בדף Edit internal passthrough Network Load Balancer, לוחצים על Backend configuration.

4. ברשימה Session affinity, בוחרים באפשרות Client IP.

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

gcloud

מריצים את הפקודה הבאה של gcloud כדי לעדכן את שירות הקצה העורפי be-ilb, ומציינים זיקה לסשן (session affinity) של כתובת ה-IP של הלקוח:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

שולחים בקשת PATCH ל-method‏ regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

gcloud

משתמשים בפקודה הבאה של gcloud compute backend-services כדי לעדכן את מדיניות מעקב החיבורים של שירות הקצה העורפי:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

מחליפים את ה-placeholders בערכים תקינים:

• ‫BACKEND_SERVICE: השירות לקצה העורפי שמעדכנים
• ‫REGION: האזור של שירות הקצה העורפי שמעדכנים
• TRACKING_MODE: מצב המעקב אחרי החיבור שבו משתמשים לחבילות נכנסות. לרשימת הערכים הנתמכים, ראו מצב מעקב
• ‫CONNECTION_PERSISTENCE_BEHAVIOR: התנהגות החיבור הקבוע כשה-backends לא תקינים. לרשימת הערכים הנתמכים, ראו חיבור קבוע ב-backends לא תקינים
• ‫IDLE_TIMEOUT_VALUE: מספר השניות שבהן צריך לשמור רשומה בטבלת מעקב החיבורים, אחרי שמאזן העומסים מעבד את חבילת הנתונים האחרונה שתואמת לרשומה

המסוף

הוספת רשת המשנה השנייה

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

   כניסה לדף VPC networks

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

3. לחץ על lb-network.

4. בקטע Subnets:

   1. לוחצים על Add subnet.
   2. בקטע New subnet, מזינים את הפרטים הבאים:
      • שם: second-subnet
      • אזור: us-west1
      • טווח כתובות IP: 10.5.6.0/24
   3. לוחצים על הוספה.

הוספת כלל ההעברה השני

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

   כניסה לדף Load balancing

2. לוחצים על מאזן העומסים be-ilb ואז על Edit.

3. לוחצים על Frontend configuration.

4. לוחצים על Add frontend IP and port.

5. בקטע New Frontend IP and port, מגדירים את השדות הבאים ולוחצים על Done:

   • שם: fr-ilb-2
   • גרסת IP‏: IPv4
   • רשת משנה: second-subnet
   • כתובת IP פנימית: ip-ilb
   • יציאות: 80 ו-443

6. לפני שממשיכים, מוודאים שמופיע סימן וי כחול ליד Frontend configuration.

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

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

gcloud

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

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

2. יוצרים כלל העברה שני ליציאות 80 ו-443. הפרמטרים האחרים של הכלל הזה, כולל כתובת ה-IP והשירות לקצה העורפי, זהים לאלה של כלל ההעברה הראשי, fr-ilb.

    gcloud compute forwarding-rules create fr-ilb-2 \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=second-subnet \
        --address=10.5.6.99 \
        --ip-protocol=TCP \
        --ports=80,443 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
   

API

שולחים בקשת POST אל ה-method‏ subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

gcloud

משתמשים בפקודה gcloud הבאה כדי לעדכן את שירות הקצה העורפי be-ilb, ומציינים את מדיניות הגדרת קבוצת המשנה:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

שולחים בקשת PATCH ל-method‏ regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

המסוף

התחלת ההגדרה

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

   כניסה לדף Load balancing

2. לוחצים על יצירת מאזן עומסים.
3. בקטע Type of load balancer, בוחרים באפשרות Network Load Balancer (TCP/UDP/SSL)‎ ולוחצים על Next.
4. בקטע Proxy or passthrough, בוחרים באפשרות Passthrough load balancer ולוחצים על Next.
5. בקטע Public facing or internal, בוחרים באפשרות Internal ולוחצים על Next.
6. לוחצים על הגדרה.

הגדרה בסיסית

1. מזינים שם בשדה Load balancer name.
2. בשדה Region, בוחרים את האזור של מכונות ה-VM שבהן רוצים לשקף מנות.
3. בשדה Network, בוחרים את הרשת שבה רוצים לשקף את החבילות.
4. לוחצים על Backend configuration.
5. בקטע New Backend, בוחרים את קבוצת המכונות שאליה רוצים להעביר את החבילות בשדה Instance group.
6. ברשימה Health check, לוחצים על Create a health check ומזינים את הפרטים הבאים:
   • בשדה Name, מזינים שם לבדיקת התקינות.
   • ברשימה Protocol, בוחרים באפשרות HTTP.
   • בשדה יציאה, מזינים 80.
7. לוחצים על יצירה.
8. לוחצים על Frontend configuration.
9. בקטע New Frontend IP and port, מבצעים את הפעולות הבאות:
   1. בשדה Name, מזינים שם.
   2. בשדה Subnetwork, בוחרים רשת משנה באותו אזור של המכונות שרוצים לשכפל.
   3. בשדה Ports, בוחרים באפשרות All.
   4. לוחצים על Advanced configurations ובוחרים בתיבת הסימון Enable this load balancer for רפליקציה של חבילות נתונים.
   5. לוחצים על סיום.
10. לוחצים על יצירה.

gcloud

1. יוצרים בדיקת תקינות אזורית חדשה של HTTP כדי לבדוק את הקישוריות של HTTP לקבוצת מכונות ביציאה 80:

   gcloud compute health-checks create http HEALTH_CHECK_NAME \
       --region=REGION \
       --port=80
   

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

   • ‫HEALTH_CHECK_NAME: השם של בדיקת התקינות.
   • ‫REGION: האזור של המכונות הווירטואליות שאתם רוצים ליצור רפליקציה של חבילות הנתונים שלהן.

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

   gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --health-checks-region=REGION \
       --health-checks=HEALTH_CHECK_NAME \
       --load-balancing-scheme=internal \
       --protocol=tcp
   

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

   • ‫COLLECTOR_BACKEND_SERVICE: השם של שירות הקצה העורפי.
   • ‫REGION: האזור של המכונות הווירטואליות שבהן רוצים ליצור רפליקציה של חבילות הנתונים.
   • ‫HEALTH_CHECK_NAME: השם של בדיקת התקינות.

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

   gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --instance-group=INSTANCE_GROUP \
       --instance-group-zone=ZONE
   

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

   • ‫COLLECTOR_BACKEND_SERVICE: השם של שירות הקצה העורפי.
   • ‫REGION: האזור של קבוצת המכונות.
   • ‫INSTANCE_GROUP: השם של קבוצת המכונות.
   • ‫ZONE: האזור של קבוצת המכונות.

4. יוצרים כלל העברה לשירות לקצה העורפי:

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
       --region=REGION \
       --network=NETWORK \
       --subnet=SUBNET \
       --backend-service=COLLECTOR_BACKEND_SERVICE \
       --load-balancing-scheme=internal \
       --ip-protocol=TCP \
       --ports=all \
       --is-mirroring-collector
   

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

   • ‫FORWARDING_RULE_NAME: השם של כלל ההעברה.
   • ‫REGION: האזור של כלל ההעברה.
   • ‫NETWORK: הרשת של כלל ההעברה.
   • ‫SUBNET: רשת משנה באזור של המכונות הווירטואליות שבהן רוצים ליצור רפליקציה של חבילות נתונים.
   • ‫COLLECTOR_BACKEND_SERVICE: שירות לקצה העורפי של מאזן העומסים הזה.