设置具有虚拟机实例组后端的跨区域内部应用负载均衡器

控制台

1. 在 Google Cloud 控制台中，前往 VPC 网络页面。

   进入 VPC 网络页面

2. 点击创建 VPC 网络。

3. 为网络提供名称。

4. 在子网部分中，将子网创建模式设置为自定义。

5. 为负载均衡器的后端创建子网。在新子网部分中，输入以下信息：

   • 为子网提供名称。
   • 选择区域：REGION_A
   • 输入 IP 地址范围：10.1.2.0/24

6. 点击完成。

7. 点击添加子网。

8. 为负载均衡器的后端创建子网。在新子网部分中，输入以下信息：

   • 为子网提供名称。
   • 选择区域：REGION_B
   • 输入 IP 地址范围：10.1.3.0/24

9. 点击完成。

10. 点击创建。

gcloud

1. 使用 gcloud compute networks create 命令创建自定义 VPC 网络：

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

2. 使用 gcloud compute networks subnets create 命令在 REGION_A 区域的 NETWORK 网络中创建子网：

   gcloud compute networks subnets create SUBNET_A \
       --network=NETWORK \
       --range=10.1.2.0/24 \
       --region=REGION_A
   

3. 使用 gcloud compute networks subnets create 命令在 REGION_B 区域的 NETWORK 网络中创建子网：

   gcloud compute networks subnets create SUBNET_B \
       --network=NETWORK \
       --range=10.1.3.0/24 \
       --region=REGION_B
   

Terraform

如需创建 VPC 网络，请使用 google_compute_network 资源。

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

如需在 lb-network-crs-reg 网络中创建 VPC 子网，请使用 google_compute_subnetwork 资源。

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}

resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

向 networks.insert 方法发出 POST 请求。请将 PROJECT_ID 替换为您的项目 ID。

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

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

向 subnetworks.insert 方法发出 POST 请求。请将 PROJECT_ID 替换为您的项目 ID。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

向 subnetworks.insert 方法发出 POST 请求。请将 PROJECT_ID 替换为您的项目 ID。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "10.1.3.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

控制台

1. 在 Google Cloud 控制台中，前往防火墙政策页面。

   转到“防火墙政策”

2. 点击创建防火墙规则，以创建允许传入 SSH 连接的规则：

   • 名称：fw-ilb-to-backends
   • 网络：NETWORK
   • 流量方向：入站
   • 匹配时执行的操作：允许
   • 目标：指定的目标标记
   • 目标标记：allow-ssh
   • 来源过滤条件：IPv4 范围
   • 来源 IPv4 范围：0.0.0.0/0
   • 协议和端口：
     • 选择指定的协议和端口。
     • 选中 TCP 复选框，然后输入 22 作为端口号。

3. 点击创建。

4. 再次点击创建防火墙规则，以创建允许Google Cloud 健康检查的规则：

   • 名称：fw-healthcheck
   • 网络：NETWORK
   • 流量方向：入站
   • 匹配时执行的操作：允许
   • 目标：指定的目标标记
   • 目标标记：load-balanced-backend
   • 来源过滤条件：IPv4 范围
   • 来源 IPv4 范围：130.211.0.0/22 和 35.191.0.0/16

   • 协议和端口：

     • 选择指定的协议和端口。
     • 选中 TCP 复选框，然后输入 80 作为端口号。

     最佳实践是将此规则限制为仅使用与健康检查所使用的协议和端口匹配的协议和端口。如果您使用 tcp:80 协议和端口，则 Google Cloud 可以使用 HTTP 通过端口 80 联系您的虚拟机，但无法使用 HTTPS 通过端口 443 联系这些虚拟机。

5. 点击创建。

6. 第三次点击创建防火墙规则，以创建允许负载均衡器的代理服务器连接后端的规则：

   • 名称：fw-backends
   • 网络：NETWORK
   • 流量方向：入站
   • 匹配时执行的操作：允许
   • 目标：指定的目标标记
   • 目标标记：load-balanced-backend
   • 来源过滤条件：IPv4 范围
   • 来源 IPv4 范围：10.129.0.0/23 和 10.130.0.0/23
   • 协议和端口：
     • 选择指定的协议和端口。
     • 选中 TCP 复选框，然后输入 80, 443, 8080 作为端口号。

7. 点击创建。

gcloud

1. 创建 fw-ilb-to-backends 防火墙规则，允许通过 SSH 连接到网络标记为 allow-ssh 的虚拟机。如果省略 source-ranges，则Google Cloud 会将规则解读为表示任何来源。

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

2. 创建 fw-healthcheck 规则以允许 Google Cloud健康检查。本示例允许来自健康检查探测工具的所有 TCP 流量；但是，您可以根据自己的需求配置较小范围的端口集。

   gcloud compute firewall-rules create fw-healthcheck \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
   

3. 创建 fw-backends 规则以允许内部应用负载均衡器的代理连接到您的后端。将 source-ranges 设置为代理专用子网的分配范围，例如 10.129.0.0/23 和 10.130.0.0/23。

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

Terraform

如需创建防火墙规则，请使用 google_compute_firewall 资源。

resource "google_compute_firewall" "fw_healthcheck" {
  name          = "gl7-ilb-fw-allow-hc"
  provider      = google-beta
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16", "35.235.240.0/20"]
  allow {
    protocol = "tcp"
  }
}

resource "google_compute_firewall" "fw_ilb_to_backends" {
  name          = "fw-ilb-to-fw"
  provider      = google-beta
  network       = google_compute_network.default.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22", "80", "443", "8080"]
  }
}

resource "google_compute_firewall" "fw_backends" {
  name          = "gl7-ilb-fw-allow-ilb-to-backends"
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["10.129.0.0/23", "10.130.0.0/23"]
  target_tags   = ["http-server"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
}

API

通过向 firewalls.insert 方法发出 POST 请求来创建 fw-ilb-to-backends 防火墙规则，并将 PROJECT_ID 替换为您的项目 ID。

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

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

通过向 firewalls.insert 方法发出 POST 请求来创建 fw-healthcheck 防火墙规则，并将 PROJECT_ID 替换为您的项目 ID。

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

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

通过 firewalls.insert 方法创建 fw-backends 防火墙规则以允许代理子网内的 TCP 流量，并将 PROJECT_ID 替换为您的项目 ID。

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

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

控制台

1. 在 Google Cloud 控制台中，前往实例模板页面。

   转到“实例模板”

   1. 点击创建实例模板。
   2. 对于名称，输入 gil7-backendeast1-template。
   3. 确保启动磁盘已设置为 Debian 映像，例如 Debian GNU/Linux 12 (bookworm)。本文中的说明使用仅 Debian 支持的命令，例如 apt-get。
   4. 点击高级选项。
   5. 点击网络并配置以下字段：
      1. 在网络标记部分，输入 allow-ssh 和 load-balanced-backend。
      2. 对于网络接口，请选择以下内容：
         • 网络：NETWORK
         • 子网：SUBNET_B

   6. 点击管理。将以下脚本输入启动脚本字段。

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. 点击创建。

   8. 点击创建实例模板。

   9. 对于名称，输入 gil7-backendwest1-template。

   10. 确保启动磁盘已设置为 Debian 映像，例如 Debian GNU/Linux 12 (bookworm)。本文中的说明使用仅 Debian 支持的命令，例如 apt-get。

   11. 点击高级选项。

   12. 点击网络并配置以下字段：

       1. 在网络标记部分，输入 allow-ssh 和 load-balanced-backend。
       2. 对于网络接口，请选择以下内容：
          • 网络：NETWORK
          • 子网：SUBNET_A

   13. 点击管理。将以下脚本输入启动脚本字段。

       #! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2
       

   14. 点击创建。

2. 在 Google Cloud 控制台中，前往实例群组页面。

   进入“实例组”

   1. 点击创建实例组。
   2. 选择 New managed instance group (stateless)（新的托管式实例组 [无状态]）。如需了解详情，请参阅无状态或有状态 MIG。
   3. 对于名称，输入 gl7-ilb-mig-a。
   4. 对于位置，选择单个可用区。
   5. 对于区域，请选择 REGION_A。
   6. 对于可用区，请选择 ZONE_A。
   7. 对于实例模板，请选择 gil7-backendwest1-template。

   8. 指定要在组中创建的实例数。

      对于此示例，请在自动扩缩下指定以下选项：

      • 对于自动扩缩模式，请选择 Off:do not autoscale。
      • 对于实例数上限，请输入 2。

      （可选）在界面的自动扩缩部分中，您可以将实例组配置为根据实例 CPU 使用情况自动添加或移除实例。

   9. 点击创建。

   10. 点击创建实例组。

   11. 选择 New managed instance group (stateless)（新的托管式实例组 [无状态]）。如需了解详情，请参阅无状态或有状态 MIG。

   12. 对于名称，输入 gl7-ilb-mig-b。

   13. 对于位置，选择单个可用区。

   14. 对于区域，请选择 REGION_B。

   15. 对于可用区，请选择 ZONE_B。

   16. 对于实例模板，请选择 gil7-backendeast1-template。

   17. 指定要在组中创建的实例数。

       对于此示例，请在自动扩缩下指定以下选项：

       • 对于自动扩缩模式，请选择 Off:do not autoscale。
       • 对于实例数上限，请输入 2。

       （可选）在界面的自动扩缩部分中，您可以将实例组配置为根据实例 CPU 使用情况自动添加或移除实例。

   18. 点击创建。

gcloud

本指南中的 gcloud CLI 说明假定您使用的是Cloud Shell 或安装了 bash 的其他环境。

1. 使用 gcloud compute instance-templates create 命令创建一个具有 HTTP 服务器的虚拟机实例模板。

   gcloud compute instance-templates create gil7-backendwest1-template \
     --region=REGION_A \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --tags=allow-ssh,load-balanced-backend \
     --image-family=debian-12 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://169.254.169.254/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2'
   

   gcloud compute instance-templates create gil7-backendeast1-template \
       --region=REGION_B \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --tags=allow-ssh,load-balanced-backend \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://169.254.169.254/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         systemctl restart apache2'
   

2. 使用 gcloud compute instance-groups managed create 命令在可用区中创建一个托管式实例组。

   gcloud compute instance-groups managed create gl7-ilb-mig-a \
       --zone=ZONE_A \
       --size=2 \
       --template=gil7-backendwest1-template
   

   gcloud compute instance-groups managed create gl7-ilb-mig-b \
       --zone=ZONE_B \
       --size=2 \
       --template=gil7-backendeast1-template
   

Terraform

如需创建实例模板，请使用 google_compute_instance_template 资源。

resource "google_compute_instance_template" "instance_template_a" {
  name         = "gil7-backendwest1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-west1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_a.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

resource "google_compute_instance_template" "instance_template_b" {
  name         = "gil7-backendeast1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-east1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_b.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

如需创建托管式实例组，请使用 google_compute_instance_group_manager 资源。

resource "google_compute_region_instance_group_manager" "mig_a" {
  name     = "gl7-ilb-miga"
  provider = google-beta
  region   = "us-west1"
  version {
    instance_template = google_compute_instance_template.instance_template_a.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

resource "google_compute_region_instance_group_manager" "mig_b" {
  name     = "gl7-ilb-migb"
  provider = google-beta
  region   = "us-east1"
  version {
    instance_template = google_compute_instance_template.instance_template_b.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

使用 instanceTemplates.insert 方法创建实例模板，并将 PROJECT_ID 替换为您的项目 ID。

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

{
  "name":"gil7-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

使用 instanceGroupManagers.insert 方法在每个可用区中创建一个托管式实例组，并将 PROJECT_ID 替换为您的项目 ID。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-a",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

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

{
  "name":"gil7-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

使用 instanceGroupManagers.insert 方法在每个可用区中创建一个托管式实例组，并将 PROJECT_ID 替换为您的项目 ID。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-b",
  "zone": "projects/PROJECT_ID/zones/ZONE_B",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

控制台

选择负载均衡器类型

1. 在 Google Cloud 控制台中，前往负载均衡页面。

   转到“负载均衡”

2. 点击创建负载均衡器。
3. 在负载均衡器的类型字段中，选择应用负载均衡器 (HTTP/HTTPS)，然后点击下一步。
4. 在公共或内部字段中，选择内部，然后点击下一步。
5. 在跨区域或单区域部署字段中，选择最适合跨区域工作负载，然后点击下一步。
6. 点击配置。

基本配置

1. 为负载均衡器提供名称。
2. 对于网络，请选择 NETWORK。

使用两个转发规则配置前端

对于 HTTP：

1. 点击前端配置。
1. 为转发规则提供名称。
2. 在 Subnetwork region 列表中，选择 REGION_A。
   

   预留代理专用子网

3. 在子网列表中，选择 SUBNET_A。
4. 在 IP 地址列表中，点击创建 IP 地址。系统会打开预留静态内部 IP 地址页面。
• 为静态 IP 地址提供名称。
• 在静态 IP 地址列表中，选择让我选择。
• 在自定义 IP 地址字段中，输入 10.1.2.99。
• 选择预留。
2. 点击完成。
3. 如需添加第二条转发规则，请点击添加前端 IP 和端口。
1. 为转发规则提供名称。
2. 在 Subnetwork region 列表中，选择 REGION_B。
   

   预留代理专用子网

3. 在子网列表中，选择 SUBNET_B。
4. 在 IP 地址列表中，点击创建 IP 地址。系统会打开预留静态内部 IP 地址页面。
• 为静态 IP 地址提供名称。
• 在静态 IP 地址列表中，选择让我选择。
• 在自定义 IP 地址字段中，输入 10.1.3.99。
• 选择预留。
4. 点击完成。

对于 HTTPS：

如需将 SSL 证书分配给负载均衡器的目标 HTTPS 代理，您需要使用 Certificate Manager 证书。

1. 点击前端配置。
1. 为转发规则提供名称。
2. 在协议字段中，选择 HTTPS (includes HTTP/2)。
3. 确保将端口设置为 443。
4. 在 Subnetwork region 列表中，选择 REGION_A。
   

   预留代理专用子网

5. 在子网列表中，选择 SUBNET_A。
6. 在 IP 地址列表中，点击创建 IP 地址。系统会打开预留静态内部 IP 地址页面。
• 为静态 IP 地址提供名称。
• 在静态 IP 地址列表中，选择让我选择。
• 在自定义 IP 地址字段中，输入 10.1.3.99。
• 选择预留。
7. 点击添加证书以选择现有证书或创建新证书。

   如果您已有 Certificate Manager 证书可供选择，请执行以下操作：

   1. 点击添加证书。
   2. 点击选择现有证书，然后从证书列表中选择相应证书。
   3. 点击选择。

   选择新的 Certificate Manager 证书后，该证书会显示在证书列表中。

   如需创建新的 Certificate Manager 证书，请执行以下操作：

   1. 点击添加证书。
   2. 点击创建新证书。
   3. 如需创建新证书，请按照 Certificate Manager 文档中以下任一配置方法所述的步骤（从第 3 步开始）操作：
      • 创建引用 DNS 授权的 Google 管理的证书
      • 创建由 CA Service 实例颁发的 Google 管理的证书
      • 将自行管理的证书上传到 Certificate Manager
8. 从 SSL 政策列表中选择一项 SSL 政策。如果您尚未创建任何 SSL 政策，则应用默认 Google Cloud SSL 政策。
9. 点击完成。

添加第二个前端配置：

1. 为前端配置提供名称。
2. 在协议字段中，选择 HTTPS (includes HTTP/2)。
3. 确保将端口设置为 443。
4. 在 Subnetwork region 列表中，选择 REGION_B。
   

   预留代理专用子网

5. 在子网列表中，选择 SUBNET_B。
6. 在 IP 地址列表中，点击创建 IP 地址。系统会打开预留静态内部 IP 地址页面。
• 为静态 IP 地址提供名称。
• 在静态 IP 地址列表中，选择让我选择。
• 在自定义 IP 地址字段中，输入 10.1.3.99。
• 选择预留。
7. 点击添加证书，然后选择现有证书或创建新证书。
8. 从 SSL 政策列表中选择一项 SSL 政策。如果您尚未创建任何 SSL 政策，则应用默认 Google Cloud SSL 政策。
9. 点击完成。
配置后端服务
1. 点击后端配置。
2. 在创建或选择后端服务列表中，点击创建后端服务。
3. 为后端服务提供名称。
4. 对于协议，选择 HTTP。
5. 对于已命名端口，输入 http。
6. 在后端类型列表中，选择实例组。
7. 在健康检查列表中，点击创建健康检查，然后输入以下信息：
• 在名称字段中，输入 global-http-health-check。
• 在协议列表中，选择 HTTP。
• 在端口字段中，输入 80。
• 点击创建。
8. 在新后端部分：
1. 在实例组列表中，在 REGION_A 中选择 gl4-ilb-miga。
2. 将端口号设置为 80。
3. 在均衡模式字段中，选择 Utilization。
4. 点击完成。
5. 如需添加其他后端，请点击添加后端。
6. 在实例组列表中，在 REGION_B 中选择 gl4-ilb-migb。
7. 将端口号设置为 80。
8. 点击完成。

配置路由规则

1. 点击路由规则。
2. 对于模式，选择简单主机和路径规则。
3. 确保任何不匹配的主机和任何不匹配的路径只有一个后端服务。

检查配置

1. 点击检查并最终确定。
2. 查看负载均衡器配置设置。
3. 点击创建。

gcloud

1. 使用 gcloud compute health-checks create http 命令定义 HTTP 健康检查。

   gcloud compute health-checks create http global-http-health-check \
      --use-serving-port \
      --global
   

2. 使用 gcloud compute backend-services create 命令定义后端服务。

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=global-http-health-check \
     --global-health-checks \
     --global
   

3. 使用 gcloud compute backend-services add-backend 命令将后端添加到后端服务。

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-a \
     --instance-group-zone=ZONE_A \
     --global
   

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=gl7-ilb-mig-b \
     --instance-group-zone=ZONE_B \
     --global
   

4. 使用 gcloud compute url-maps create 命令创建网址映射。

   gcloud compute url-maps create gl7-gilb-url-map \
     --default-service=BACKEND_SERVICE_NAME \
     --global
   

5. 创建目标代理。

   对于 HTTP：

   使用 gcloud compute target-http-proxies create 命令创建目标代理。

   gcloud compute target-http-proxies create gil7-http-proxy \
     --url-map=gl7-gilb-url-map \
     --global
   

   对于 HTTPS：

   如需创建 Google 管理的证书，请参阅以下文档：

   • 创建由 Certificate Authority Service 实例颁发的 Google 管理的证书。
   • 创建具有 DNS 授权的 Google 代管的证书。

   创建 Google 管理的证书后，请将该证书直接附加到目标代理。跨区域内部应用负载均衡器不支持证书映射。

   如需创建自行管理的证书，请参阅以下文档：

   • 创建私钥和证书。

   将文件路径分配给变量名称。

   export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
   

   export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE
   

   使用 gcloud beta certificate-manager certificates create 命令创建全区域 SSL 证书。

   gcloud certificate-manager certificates create gilb-certificate \
     --private-key-file=$LB_PRIVATE_KEY \
     --certificate-file=$LB_CERT \
     --scope=all-regions
   

   使用 SSL 证书通过 gcloud compute target-https-proxies create 命令创建目标代理

   gcloud compute target-https-proxies create gil7-https-proxy \
     --url-map=gl7-gilb-url-map \
     --certificate-manager-certificates=gilb-certificate \
     --global
   

6. 创建两条转发规则，一条规则使用 REGION_B 区域中的 VIP (10.1.2.99)，另一条规则使用 REGION_A 区域中的 VIP (10.1.3.99)。如需了解详情，请参阅预留静态内部 IPv4 地址。

   对于自定义网络，必须在转发规则中引用子网。请注意，这是虚拟机子网，而非代理子网。

   对于 HTTP：

   将 gcloud compute forwarding-rules create 命令与正确的标志结合使用。

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   对于 HTTPS：

   将 gcloud compute forwarding-rules create 命令与正确的标志结合使用。

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=10.1.2.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=10.1.3.99 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

Terraform

如需创建健康检查，请使用 google_compute_health_check 资源。

resource "google_compute_health_check" "default" {
  provider = google-beta
  name     = "global-http-health-check"
  http_health_check {
    port_specification = "USE_SERVING_PORT"
  }
}

如需创建后端服务，请使用 google_compute_backend_service 资源。

resource "google_compute_backend_service" "default" {
  name                  = "gl7-gilb-backend-service"
  provider              = google-beta
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_region_instance_group_manager.mig_a.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
  backend {
    group           = google_compute_region_instance_group_manager.mig_b.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

如需创建网址映射，请使用 google_compute_url_map 资源。

resource "google_compute_url_map" "default" {
  name            = "gl7-gilb-url-map"
  provider        = google-beta
  default_service = google_compute_backend_service.default.id
}

如需创建目标 HTTP 代理，请使用 google_compute_target_http_proxy 资源。

resource "google_compute_target_http_proxy" "default" {
  name     = "gil7target-http-proxy"
  provider = google-beta
  url_map  = google_compute_url_map.default.id
}

如需创建转发规则，请使用 google_compute_forwarding_rule 资源。

resource "google_compute_global_forwarding_rule" "fwd_rule_a" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_a]
  ip_address            = "10.1.2.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-a"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_a.id
}

resource "google_compute_global_forwarding_rule" "fwd_rule_b" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_b]
  ip_address            = "10.1.3.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-b"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_b.id
}

如需了解如何应用或移除 Terraform 配置，请参阅基本 Terraform 命令。

API

向 healthChecks.insert 方法发出 POST 请求来创建健康检查，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "global-http-health-check",
"type": "HTTP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

向 backendServices.insert 方法发出 POST 请求来创建全球后端服务，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "BACKEND_SERVICE_NAME",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a",
    "balancingMode": "UTILIZATION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

向 urlMaps.insert 方法发出 POST 请求来创建网址映射，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME"
}

对于 HTTP：

向 targetHttpProxies.insert 方法发出 POST 请求来创建目标 HTTP 代理，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map"
}

向 forwardingRules.insert 方法发出 POST 请求来创建转发规则，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil7forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

对于 HTTPS：

读取证书和私钥文件，然后创建 SSL 证书。以下示例展示了如何使用 Python 执行此操作。

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

向 targetHttpsProxies.insert 方法发出 POST 请求以创建目标 HTTPS 代理，注意要将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME
}

向 globalForwardingRules.insert 方法发出 POST 请求来创建转发规则，并将 PROJECT_ID 替换为您的项目 ID。

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

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "FWRULE_B",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

控制台

如需标识客户端虚拟机，请标记要限制的特定虚拟机。这些标记用于将防火墙规则与标记的客户端虚拟机相关联。然后，在以下步骤中，将标记添加到 TARGET_TAG 字段中。

请使用一个或多个防火墙规则进行设置。

单个出站防火墙规则

您可以配置一个防火墙出站规则，以拒绝从标记客户端虚拟机到负载均衡器的 VIP 的所有出站流量。

1. 在 Google Cloud 控制台中，前往防火墙规则页面。

   转到“防火墙规则”

2. 点击创建防火墙规则以创建一个规则，拒绝从标记的客户端虚拟机到负载均衡器的 VIP 的出站流量。

   • 名称：fr-deny-access
   • 网络：lb-network
   • 优先级：100
   • 流量方向：出站
   • 对匹配项执行的操作：拒绝
   • 目标：指定的目标标记
   • 目标标记：TARGET_TAG
   • 目标过滤条件：IP 范围
   • 目标 IP 地址范围：10.1.2.99
   • 协议和端口：
     • 选择指定的协议和端口。
     • 选中 tcp 复选框，然后输入 80 作为端口号。

3. 点击创建。

多个出站防火墙规则

扩缩性更高的方法涉及设置两个规则。默认的低优先级规则禁止所有客户端访问负载均衡器的 VIP。第二个优先级较高的规则允许一部分标记客户端访问负载均衡器的 VIP。只有标记的虚拟机才能访问 VIP。

1. 在 Google Cloud 控制台中，前往防火墙规则页面。

   转到“防火墙规则”

2. 点击创建防火墙规则，创建优先级较低的规则以默认拒绝访问：

   • 名称：fr-deny-all-access-low-priority
   • 网络：lb-network
   • 优先级：200
   • 流量方向：出站
   • 对匹配项执行的操作：拒绝
   • 目标：指定的目标标记
   • 目标标记：TARGET_TAG
   • 目标过滤条件：IP 范围
   • 目标 IP 地址范围：10.1.2.99
   • 协议和端口：
     • 选择指定的协议和端口。
     • 选中 TCP 复选框，然后输入 80 作为端口号。

3. 点击创建。

4. 点击创建防火墙规则，创建优先级较高的规则，以允许来自某些标记实例的流量。

   • 名称：fr-allow-some-access-high-priority
   • 网络：lb-network
   • 优先级：100
   • 流量方向：出站
   • 对匹配项执行的操作：允许
   • 目标：指定的目标标记
   • 目标标记：TARGET_TAG
   • 目标过滤条件：IP 范围
   • 目标 IP 地址范围：10.1.2.99
   • 协议和端口：
     • 选择指定的协议和端口。
     • 选中 TCP 复选框，然后输入 80 作为端口号。

5. 点击创建。

gcloud

如需标识客户端虚拟机，请标记要限制的特定虚拟机。然后，在这些步骤中，在 TARGET_TAG 字段中添加标记。

请使用一个或多个防火墙规则进行设置。

单个出站防火墙规则

您可以配置一个防火墙出站规则，以拒绝从标记客户端虚拟机到负载均衡器的 VIP 的所有出站流量。

gcloud compute firewall-rules create fr-deny-access \
    --network=lb-network \
    --action=deny \
    --direction=egress \
    --rules=tcp \
    --priority=100 \
    --destination-ranges=10.1.2.99 \
    --target-tags=TARGET_TAG

多个出站防火墙规则

扩缩性更高的方法涉及设置两个规则：默认的低优先级规则，限制所有客户端访问负载均衡器的 VIP；第二个优先级较高的规则，允许一部分标记的客户端访问负载均衡器的 VIP。只有标记的虚拟机才能访问 VIP。

1. 创建优先级较低的规则：

   gcloud compute firewall-rules create fr-deny-all-access-low-priority \
       --network=lb-network \
       --action=deny \
       --direction=egress \
       --rules=tcp \
       --priority=200 \
       --destination-ranges=10.1.2.99
   

2. 创建优先级较高的规则：

   gcloud compute firewall-rules create fr-allow-some-access-high-priority \
       --network=lb-network \
       --action=allow \
       --direction=egress \
       --rules=tcp \
       --priority=100 \
       --destination-ranges=10.1.2.99 \
       --target-tags=TARGET_TAG
   

如需使用服务账号（而不是标记）来控制访问，请在创建防火墙规则时使用 --target-service-accounts 选项 而不是 --target-tags 标志。

gcloud

1. 创建一个区域级子网，用于为转发规则分配负载均衡的 IP 地址：

   gcloud compute networks subnets create l7-ilb-restricted-subnet \
       --network=lb-network \
       --region=us-west1 \
       --range=10.127.0.0/24
   

2. 创建一个转发规则以从子网中获取地址。以下示例使用上一步中创建的子网中的地址 10.127.0.1。

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
       --load-balancing-scheme=INTERNAL_MANAGED \
       --network=lb-network \
       --subnet=l7-ilb-restricted-subnet \
       --address=10.127.0.1 \
       --ports=80 \
       --global \
       --target-http-proxy=gil7-http-proxy
   

3. 创建一个防火墙规则以限制流向转发规则子网 (l7-ilb-restricted-subnet) 中 IP 地址范围的流量：

   gcloud compute firewall-rules create restrict-traffic-to-subnet \
       --network=lb-network \
       --action=deny \
       --direction=egress \
       --rules=tcp:80 \
       --priority=100 \
       --destination-ranges=10.127.0.0/24 \
       --target-tags=TARGET_TAG
   

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

gcloud

如需创建 TTL 为 30 秒 DNS 条目，请使用 gcloud dns record-sets create 命令。

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

请替换以下内容：

• DNS_ENTRY：记录集的 DNS 或域名

  例如 service.example.com。

• REGION_A 和 REGION_B：您在其中配置了负载均衡器的区域

API

通过向 ResourceRecordSets.create 方法发出 POST 请求来创建 DNS 记录。请将 PROJECT_ID 替换为您的项目 ID。

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

控制台

1. 在 Google Cloud 控制台中，前往负载均衡页面。

   转到“负载均衡”

2. 点击要修改其后端服务的负载均衡器的名称。

3. 在负载均衡器详情页面上，点击 edit 修改。

4. 在修改跨区域内部应用负载均衡器页面上，点击后端配置。

5. 在后端配置页面上，针对要修改的后端服务点击 edit 修改。

6. 向下滚动并展开高级配置部分。

7. 在离群值检测部分中，选中启用复选框。

8. 点击 edit 修改以配置离群值检测。

   验证以下选项是否配置了这些值：

   属性	值
   连续错误数	5
   间隔时间	1000
   基本移除时间	30000
   最大移除百分比	50
   引发强制执行的连续错误数	100

   在此示例中，离群值检测分析每秒运行一次。如果 Envoy 代理收到的连续 HTTP 5xx 状态代码数为 5 个或更多，则后端端点会从 Envoy 代理的负载均衡池中移除 30 秒。当强制百分比设置为 100% 时，后端服务会在每次运行离群值检测分析时从这些特定 Envoy 代理的负载均衡池中逐出运行状况不佳的端点。如果满足移除条件，则最多可以从负载均衡池中移除 50% 的后端端点。

9. 点击保存。

10. 如需更新后端服务，请点击更新。

11. 如需更新负载均衡器，请在修改跨区域内部应用负载均衡器页面上，点击更新。

gcloud

1. 将后端服务导出到 YAML 文件。

   gcloud compute backend-services export BACKEND_SERVICE_NAME \
     --destination=BACKEND_SERVICE_NAME.yaml --global
   

   将 BACKEND_SERVICE_NAME 替换为后端服务的名称。

2. 修改后端服务的 YAML 配置，以添加离群值检测字段，如 outlierDetection 部分中的以下 YAML 配置所示。

   在此示例中，离群值检测分析每秒运行一次。如果 Envoy 代理收到的连续 HTTP 5xx 状态代码数为 5 个或更多，则后端端点会从 Envoy 代理的负载均衡池中移除 30 秒。当强制百分比设置为 100% 时，后端服务会在每次运行离群值检测分析时从这些特定 Envoy 代理的负载均衡池中逐出运行状况不佳的端点。如果满足移除条件，则最多可以从负载均衡池中移除 50% 的后端端点。

   name: BACKEND_SERVICE_NAME
   backends:
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
   outlierDetection:
     baseEjectionTime:
       nanos: 0
       seconds: 30
     consecutiveErrors: 5
     enforcingConsecutiveErrors: 100
     interval:
       nanos: 0
       seconds: 1
     maxEjectionPercent: 50
   port: 80
   selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
   sessionAffinity: NONE
   timeoutSec: 30
   ...
   

   请替换以下内容：

   • BACKEND_SERVICE_NAME：后端服务的名称
   • PROJECT_ID：您的项目的 ID
   • REGION_A 和 REGION_B：已配置负载均衡器的区域。
   • SERVERLESS_NEG_NAME：第一个无服务器 NEG 的名称
   • SERVERLESS_NEG_NAME_2：第二个无服务器 NEG 的名称

3. 通过导入最新配置来更新后端服务。

   gcloud compute backend-services import BACKEND_SERVICE_NAME \
     --source=BACKEND_SERVICE_NAME.yaml --global
   

   离群值检测现已在后端服务上启用。