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

本文档介绍了如何为 Compute Engine 虚拟机 (VM) 实例上运行的服务配置跨区域内部应用负载均衡器。

准备工作

在按照本指南进行操作之前，请先熟悉以下内容：

设置 SSL 证书资源

按照以下所述创建 Certificate Manager SSL 证书资源：

我们建议您使用 Google 管理的证书。

权限

若要按照本指南中的说明进行操作，您必须能够创建实例以及修改项目中的网络。因此，您必须是项目 Owner 或 Editor，或者必须具有以下所有 Compute Engine IAM 角色。

任务 所需角色
创建网络、子网和负载均衡器组件 Compute Network Admin
添加和移除防火墙规则 计算安全管理员
创建实例 Compute Instance Admin

如需了解详情，请参阅以下指南：

设置概览

您可以配置负载均衡器，如下图所示：

跨区域内部应用负载均衡器高可用性部署。
跨区域内部应用负载均衡器高可用性部署（点击可放大）。

如上图所示，该示例在 VPC 网络中创建了一个跨区域内部应用负载均衡器，其中 REGION_A 和 REGION_B 区域中包含一个后端服务和两个后端托管式实例组。

图中显示了以下内容：

  1. 一个具有以下子网的 VPC 网络：

    • 子网 SUBNET_A 和 REGION_A 中的代理专用子网。
    • 子网 SUBNET_B 和 REGION_B 中的代理专用子网。

    您必须在其中使用跨区域内部应用负载均衡器的 VPC 网络的每个区域中创建代理专用子网。该区域的代理专用子网会在该区域的所有跨区域内部应用负载均衡器之间共享。对于从负载均衡器发送到服务后端的数据包，系统会从代理专用子网分配其来源地址。在此示例中，区域 REGION_A 的代理专用子网的主要 IP 地址范围为 10.129.0.0/23，REGION_B 的代理专用子网的主要 IP 地址范围为 10.130.0.0/23，这是建议的子网大小。

  2. 高可用性设置具有适用于 REGION_A 和 REGION_B 区域中的 Compute Engine 虚拟机部署的托管式实例组后端。如果一个区域中的后端发生故障，则流量会故障切换到另一个区域。

  3. 用于监控后端使用情况和健康状况全球后端服务。

  4. 全球网址映射，用于解析请求的网址，并根据请求网址的主机和路径将请求转发到特定后端服务。

  5. 全球目标 HTTP 或 HTTPS 代理，用于接收用户请求并将其转发到网址映射。对于 HTTPS，请配置全球 SSL 证书资源。如果您配置 HTTPS 负载均衡，则目标代理会使用 SSL 证书来解密 SSL 流量。目标代理可以通过 HTTP 或 HTTPS 将流量转发到您的实例。

  6. 具有负载均衡器的区域级内部 IP 地址的全球转发规则，用于将每个传入请求转发到目标代理。

    与转发规则关联的内部 IP 地址可以来自与后端位于同一网络和区域的子网。请注意以下条件：

    • 该 IP 地址可以（但并非必须）与后端实例组来自同一子网。
    • 该 IP 地址不得来自 --purpose 标志设置为 GLOBAL_MANAGED_PROXY 的预留代理专用子网。
    • 如果要将同一内部 IP 地址与多个转发规则结合使用，请将 IP 地址 --purpose 标志设置为 SHARED_LOADBALANCER_VIP。

  7. 可选：配置 DNS 路由政策（类型为 GEO），以将客户端流量路由到离客户端最近的区域中的负载均衡器 VIP。

配置网络和子网

在 VPC 网络中，在配置了后端的每个区域中配置一个子网。此外，请在要配置负载均衡器的每个区域中配置 proxy-only-subnet。

本示例使用以下 VPC 网络、区域和子网：

  • 网络。网络是名为 NETWORK 的自定义模式 VPC 网络。

  • 后端子网。

    • REGION_A 区域中名为 SUBNET_A 的子网使用 10.1.2.0/24 作为其主要 IP 范围。
    • REGION_B 区域中名为 SUBNET_B 的子网使用 10.1.3.0/24 作为其主要 IP 范围。

  • 代理子网。

    • REGION_A 区域中名为 PROXY_SN_A 的子网使用 10.129.0.0/23 作为其主要 IP 范围。
    • REGION_B 区域中名为 PROXY_SN_B 的子网使用 10.130.0.0/23 作为其主要 IP 范围。

您可以从 VPC 中的任何区域访问跨区域内部应用负载均衡器。因此，来自任何区域的客户端都可以在全球范围内访问负载均衡器后端。

配置后端子网

控制台

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

配置代理专用子网

代理专用子网提供了一组 IP 地址，供 Google Cloud 用于代表您运行 Envoy 代理。代理会终结来自客户端的连接并创建与后端的新连接。

此代理专用子网用于与 VPC 网络位于同一区域的所有基于 Envoy 的区域级负载均衡器。在每个网络中，每个区域只能有一个活跃代理专用子网用于给定目的。

控制台

如果您使用的是 Google Cloud 控制台，则可以稍后在负载均衡页面上创建代理专用子网。

如需立即创建代理专用子网，请按以下步骤操作：

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

    转到 VPC 网络页面

  2. 点击 VPC 网络的名称。
  3. 在子网标签页上，点击添加子网。
  4. 为代理专用子网提供名称。
  5. 选择区域：REGION_A
  6. 在用途列表中，选择跨区域托管式代理。
  7. 在 IP 地址范围字段中，输入 10.129.0.0/23。
  8. 点击添加。

在 REGION_B 中创建代理专用子网

  1. 在子网标签页上，点击添加子网。
  2. 为代理专用子网提供名称。
  3. 选择区域：REGION_B
  4. 在用途列表中，选择跨区域托管式代理。
  5. 在 IP 地址范围字段中，输入 10.130.0.0/23。
  6. 点击添加。

gcloud

使用 gcloud compute networks subnets create 命令创建代理专用子网。

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=10.129.0.0/23
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=10.130.0.0/23

Terraform

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

resource "google_compute_subnetwork" "proxy_subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.129.0.0/23"
  name          = "proxy-only-subnet1"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}
resource "google_compute_subnetwork" "proxy_subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.130.0.0/23"
  name          = "proxy-only-subnet2"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-east1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

API

使用 subnetworks.insert 方法创建代理专用子网，并将 PROJECT_ID 替换为您的项目 ID。

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

    {
      "name": " PROXY_SN_A",
      "ipCidrRange": "10.129.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": "PROXY_SN_B",
      "ipCidrRange": "10.130.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

配置防火墙规则

此示例使用以下防火墙规则：

  • fw-ilb-to-backends. 适用于负载均衡实例的入站流量规则，该规则允许从任何地址到 TCP 端口 22 的传入 SSH 连接。您可以为此规则选择限制性更高的来源 IP 地址范围；例如，您可以仅指定从中启动 SSH 会话的系统的 IP 地址范围。此示例使用目标标记 allow-ssh 来标识防火墙规则应用于的虚拟机。

  • fw-healthcheck。适用于负载均衡实例的入站流量规则，该规则允许来自 Google Cloud 健康检查系统（130.211.0.0/22 和 35.191.0.0/16）的所有 TCP 流量。此示例使用目标标记 load-balanced-backend 来标识防火墙规则应用于的虚拟机。

  • fw-backends。适用于负载均衡实例的入站流量规则，该规则允许从内部应用负载均衡器的托管式代理到端口 80、443 和 8080 的 TCP 流量。此示例使用目标标记 load-balanced-backend 来标识防火墙规则应用于的虚拟机。

如果不使用上述防火墙规则，则默认拒绝入站规则会阻止传入后端实例的流量。

目标标记定义了后端实例。没有目标标记，防火墙规则将应用于 VPC 网络中的所有后端实例。创建后端虚拟机时，请务必包括指定的目标标记，如创建代管实例组中所示。

控制台

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

创建代管式实例组

本部分介绍如何创建模板和托管式实例组。托管式实例组提供运行示例跨区域内部应用负载均衡器的后端服务器的虚拟机实例。对于您的实例组，您可以定义一个 HTTP 服务并将端口名称映射到相关端口上。负载均衡器的后端服务会将流量转发到已命名的端口。 来自客户端的流量在经过负载均衡处理后传送到后端服务器。出于演示目的，后端会传送其各自的主机名。

控制台

  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
}

配置负载均衡器

此示例展示了如何创建以下跨区域内部应用负载均衡器资源：

  • 全球 HTTP 健康检查。
  • 将代管式实例组用作后端的全球后端服务。
  • 网址映射。请务必参阅目标 HTTP(S) 代理的全球网址映射。全球网址映射会根据您为传入网址的主机和路径定义的规则将请求路由到全球后端服务。全球网址映射可由全球目标代理规则引用。
  • 全球 SSL 证书（适用于 HTTPS）。
  • 全球目标代理。

  • 两条使用区域级 IP 地址的全球转发规则。对于转发规则的 IP 地址，请使用 SUBNET_A 或 SUBNET_B IP 地址范围。如果您尝试使用代理专用子网，则转发规则创建会失败。

控制台

开始配置

  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：

如果您在客户端和负载均衡器之间使用 HTTPS，则需要一个或多个 SSL 证书资源来配置代理。如需创建 Google 管理的 all-regions 证书，请参阅以下文档：

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

如需创建自行管理的 all-regions 证书，请参阅以下文档：部署自行管理的区域级证书。

  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. 在添加证书部分中，选择证书。
    8. 可选：如需添加除了主要 SSL 证书之外的其他证书，请执行以下操作：
      1. 点击添加证书。
      2. 从列表中选择证书。
    9. 从 SSL 政策列表中选择一项 SSL 政策。如果您尚未创建任何 SSL 政策，则系统会应用默认 Google Cloud SSL 政策。
    10. 点击完成。

    添加第二个前端配置：

    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 证书之外的其他证书，请执行以下操作：
      1. 点击添加证书。
      2. 从列表中选择证书。
    9. 从 SSL 政策列表中选择一项 SSL 政策。如果您尚未创建任何 SSL 政策，则系统会应用默认 Google Cloud SSL 政策。
    10. 点击完成。
    配置后端服务
    1. 点击后端配置。
    2. 在创建或选择后端服务列表中，点击创建后端服务。
    3. 为后端服务提供名称。
    4. 对于协议，选择 HTTP。
    5. 对于已命名端口，输入 http。
    6. 在后端类型列表中，选择实例组。
    7. 在新后端部分：
      • 在实例组列表中，选择 REGION_A 中的 gl7-ilb-mig-a。
      • 将端口号设置为 80。
      • 点击完成。
      • 如需添加其他后端，请点击添加后端。
      • 在实例组列表中，选择 REGION_B 中的 gl7-ilb-mig-b。
      • 将端口号设置为 80。
      • 点击完成。
    8. 在健康检查列表中，点击创建健康检查。
      • 在名称字段中，输入 global-http-health-check。
      • 将协议设置为 HTTP。
      • 将端口设置为 80。
      • 点击保存。

    配置路由规则

    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 管理的证书，请参阅以下文档：

    创建 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"
}

测试负载均衡器

创建虚拟机实例以测试连接性

  1. 创建客户端虚拟机：

    gcloud compute instances create l7-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

    gcloud compute instances create l7-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

  2. 使用 SSH 连接到每个客户端实例。

    gcloud compute ssh l7-ilb-client-a --zone=ZONE_A

    gcloud compute ssh l7-ilb-client-b --zone=ZONE_B

  3. 验证 IP 地址是否传送其主机名

    • 验证客户端虚拟机是否可以访问以下两个 IP 地址。该命令返回处理请求的后端虚拟机的名称：

      curl 10.1.2.99

      curl 10.1.3.99

      对于 HTTPS 测试，请将 curl 替换为以下命令行：

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443

      -k 标志会导致 curl 跳过证书验证。

    • 可选：使用配置的 DNS 记录解析离客户端虚拟机最近的 IP 地址。例如，DNS_NAME 可以是 service.example.com。

      curl DNS_NAME

运行 100 个请求并确认它们已进行负载均衡

对于 HTTP：

  {
    RESULTS=
    for i in {1..100}
    do
        RESULTS="$RESULTS:$(curl --silent 10.1.2.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl --silent 10.1.3.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }

对于 HTTPS：

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
       RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }

测试故障切换

  1. 当 REGION_B 中的后端健康状况不佳或无法访问时，验证故障切换到 REGION_A 区域中的后端。如需模拟故障切换，请从 REGION_B 中移除所有后端：

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

  2. 使用 SSH 连接到 REGION_B 中的客户端虚拟机。

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  3. 向 REGION_B 区域中的负载均衡 IP 地址发送请求。命令输出会显示来自 REGION_A 中的后端虚拟机的响应：

    {
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
done
echo "***"
echo "*** Results of load-balancing to 10.1.3.99: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

其他配置选项

本部分对配置示例进行了扩展，以提供一些额外的替代配置选项。所有任务均为可选任务。您可以按任意顺序执行这些任务。

启用会话亲和性

以下过程介绍了如何为示例区域级内部应用负载均衡器或跨区域内部应用负载均衡器更新后端服务，以便后端服务使用生成的 Cookie 亲和性、标头字段亲和性或 HTTP Cookie 亲和性。

启用生成的 Cookie 亲和性后，负载均衡器会针对第一个请求发出一个 Cookie。对于具有相同 Cookie 的每个后续请求，负载均衡器会将请求定向到同一个后端虚拟机 (VM) 实例或端点。在此示例中，Cookie 名为 GCILB。

启用标头字段亲和性后，负载均衡器会根据 --custom-request-header 标志中指定的 HTTP 标头的值将请求路由到网络端点组 (NEG) 中的后端虚拟机或端点。仅当负载均衡位置政策为 RING_HASH 或 MAGLEV 且后端服务的一致性哈希指定 HTTP 标头的名称时，标头字段亲和性才有效。

启用 HTTP Cookie 亲和性后，负载均衡器会根据带有可选 --affinity-cookie-ttl 标志的 HTTP_COOKIE 标志中指定的 HTTP Cookie，将请求路由到 NEG 中的后端虚拟机或端点。如果客户端未在其 HTTP 请求中提供 Cookie，则代理会生成 Cookie 并通过 Set-Cookie 标头将其返回给客户端。仅当负载均衡位置政策为 RING_HASH 或 MAGLEV 且后端服务的一致性哈希指定 HTTP Cookie 时，HTTP Cookie 亲和性才有效。

控制台

如需针对后端服务启用或更改会话亲和性，请执行以下操作：

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

    进入“负载均衡”

  2. 点击后端。
  3. 点击 gil7-backend-service（您为此示例创建的后端服务的名称），然后点击修改。
  4. 在后端服务详情页面上，点击高级配置。
  5. 在会话亲和性下，选择所需的会话亲和性类型。
  6. 点击更新。

gcloud

使用以下 Google Cloud CLI 命令可以将后端服务更新为不同类型的会话亲和性：

    gcloud compute backend-services update gil7-backend-service \
        --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \
        --global

API

如需设置会话亲和性，请向 backendServices/patch 方法发出“PATCH”请求。

    PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service
    {
    "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
    }

限制哪些客户端可以向负载均衡器发送流量

您可以通过在客户端上配置出站防火墙规则，限制客户端连接到内部应用负载均衡器转发规则 VIP。您可以根据服务账号或标记在特定客户端虚拟机上设置这些防火墙规则。

您无法使用防火墙规则将入站流量限制到特定的内部应用负载均衡器转发规则 VIP 地址。与转发规则 VIP 位于同一 VPC 网络和同一区域的任何客户端通常都可以将流量发送到该转发规则 VIP。

此外，发送到后端的所有请求都来自使用代理专用子网范围内的 IP 地址的代理。您无法创建防火墙规则来根据客户端使用的转发规则 VIP 允许或拒绝这些后端上的入站流量。

以下示例说明了如何使用出站防火墙规则来限制到负载均衡器的转发规则 VIP 的流量。

控制台

如需标识客户端虚拟机，请标记要限制的特定虚拟机。这些标记用于将防火墙规则与标记的客户端虚拟机相关联。然后，在以下步骤中，将标记添加到 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 标志。

根据子网扩缩对内部应用负载均衡器后端的受限访问

随着转发规则数量的增加，维护单独的防火墙规则或向现有规则添加新的负载均衡 IP 地址（如以上部分所述）变得非常不方便。防止这种情况的一个方法是从预留子网中分配转发规则 IP 地址。然后，通过将预留子网用作防火墙规则的目标范围，可以允许或阻止来自标记的实例或服务账号的流量。这样，您就可以有效地控制对一组转发规则 VIP 的访问，而无需维护每个 VIP 的防火墙出站规则。

下面简要说明了设置步骤（假设您要分别创建所有其他必需的负载均衡器资源）。

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

在多个内部转发规则中使用同一 IP 地址

如果多个内部转发规则共用同一内部 IP 地址，您必须预留该 IP 地址，并将其 --purpose 标志设置为 SHARED_LOADBALANCER_VIP。

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP
如果您需要将 HTTP 流量重定向到 HTTPS，则可以创建两个共用一个 IP 地址的转发规则。如需了解详情，请参阅为内部应用负载均衡器设置 HTTP 到 HTTPS 重定向。

配置 DNS 路由政策

如果您的客户端位于多个区域，则建议您在这些区域中使用 VIP 使跨区域内部应用负载均衡器可供访问。这种多区域设置可最大限度地减少延迟和网络传输费用。此外，您还可以设置基于 DNS 的全球负载均衡解决方案，以应对区域级服务中断。如需了解详情，请参阅管理 DNS 路由政策和健康检查。

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

启用离群值检测

您可以在全球后端服务上启用离群值检测，以识别运行状况不佳的无服务器 NEG 并减少发送到运行状况不佳的无服务器 NEG 的请求数。

可以使用以下方法之一在后端服务上启用离群值检测：

  • consecutiveErrors 方法 (outlierDetection.consecutiveErrors)，其中 5xx 系列 HTTP 状态代码被视为错误。
  • consecutiveGatewayFailure 方法 (outlierDetection.consecutiveGatewayFailure)，其中只有 502、503 和 504 HTTP 状态代码被视为错误。

请按照以下步骤为现有后端服务启用离群值检测。请注意，即使在启用离群值检测后，某些请求也可以发送到运行状况不佳的服务，并向客户端返回 5xx 状态代码。为了进一步降低错误率，您可以为离群值检测参数配置更激进的值。如需了解详情，请参阅 outlierDetection 字段。

控制台

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

    转到“负载均衡”

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

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

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

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

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

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

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

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

    属性 值
    连续错误数 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

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

后续步骤