本頁面由 Cloud Translation API 翻譯而成。

為 PostgreSQL 適用的 Cloud SQL 目的地設定私人 IP 連線
透過集合功能整理內容你可以依據偏好儲存及分類內容。

資料庫遷移服務會使用 Private Service Connect，透過私人 IP 位址連線至目的地 Cloud SQL 執行個體。透過 Private Service Connect，您可以將目的地資料庫公開給傳入的安全連線，並控管可存取資料庫的使用者。

Private Service Connect 的網路架構設定會因您使用的是啟用 PSC 或未啟用 PSC 的 Cloud SQL 目的地而有所不同。

如要進一步瞭解目的地連線方法，請參閱「目的地資料庫連線方法總覽」。

適用於已啟用 PSC 的 Cloud SQL 執行個體的 Private Service Connect

如要使用私人連線功能，並連線至啟用 PSC 的 PostgreSQL 適用 Cloud SQL 目的地，請按照下列步驟操作：

建立及設定目的地執行個體時，請務必將其設為支援 PSC 的執行個體，並使用私人 IP。您無法修改現有的 Cloud SQL 執行個體，讓該執行個體啟用 Private Service Connect。
稍後建立目的地連線設定檔時，請在「Define connectivity method」部分選取「Private IP」。
「Service attachment name」欄位會自動填入為目的地例項建立的服務連結。

針對未啟用 PSC 的 Cloud SQL 執行個體使用 Private Service Connect

如要為未啟用私人服務連線功能而建立的 PostgreSQL 適用 Cloud SQL 目的地使用私人 IP 連線，您必須建立其他網路元件，以便在資料庫移轉服務和目的地之間路由流量。詳情請參閱非 PSC Cloud SQL 執行個體的私人 IP 目的地連線。

如果單一堡壘虛擬機器 (VM) 無法滿足網路需求，請為網路內容製作者設定執行個體群組。詳情請參閱「受管理服務中的網路連線」。

如要建立必要的 Private Service Connect 製作者設定，建議您使用 Google Cloud CLI 或 Terraform 自動化指令碼。使用任何指令資料之前，請先替換以下項目：

PROJECT_ID 與您建立 Private Service Connect 生產端服務設定的專案相關。
REGION 與您建立 Private Service Connect 供應商設定的區域。
ZONE 與 REGION 中的區域，您可以在該區域中建立所有區域資源 (例如堡壘 VM)。
BASTION 與要建立的堡壘 VM。
DB_SUBNETWORK 與要轉送流量的子網路。子網路必須具備 Cloud SQL 執行個體的存取權。
DB_SUBNETWORK_GATEWAY 與子網路的 IPv4 閘道。
CLOUD_SQL_INSTANCE_CONNECTION_NAME 使用 Cloud SQL 執行個體連線名稱 (格式為 project:region:name)。
PORT 與 Bastion 用來公開基礎資料庫的通訊埠。
CLOUD_SQL_INSTANCE_PRIVATE_IP 使用目的地 Cloud SQL 執行個體的私人 IP 位址。

gcloud

下列 bash 指令碼會使用 Google Cloud CLI 為目的地資料庫建立 Private Service Connect 製作者設定。請注意，您可能需要調整某些預設值，例如 Private Service Connect 子網路的 CIDR 範圍。

#!/bin/bash

# Create the VPC network for the Database Migration Service Private Service Connect.
gcloud compute networks create dms-psc-vpc \
--project=PROJECT_ID \
--subnet-mode=custom

# Create a subnet for the Database Migration Service Private Service Connect.
gcloud compute networks subnets create dms-psc-REGION \
--project=PROJECT_ID \
--range=10.0.0.0/16 --network=dms-psc-vpc \
--region=REGION

# Create a router required for the bastion to be able to install external
# packages (for example, Dante SOCKS server):
gcloud compute routers create ex-router-REGION \
--network dms-psc-vpc \
--project=PROJECT_ID \
--region=REGION

gcloud compute routers nats create ex-nat-REGION \
--router=ex-router-REGION \
--auto-allocate-nat-external-ips \
--nat-all-subnet-ip-ranges \
--enable-logging \
--project=PROJECT_ID \
--region=REGION

# Create the bastion VM.
gcloud compute instances create BASTION \
    --project=PROJECT_ID \
    --zone=ZONE \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --network-interface subnet=dms-psc-REGION,no-address \
    --network-interface subnet=DB_SUBNETWORK,no-address \
    --metadata=startup-script='#!/bin/bash

# Route the private IP address using the gateway of the database subnetwork.
# Find the gateway for the relevant subnetwork on the VPC network page
# in the Google Cloud console. Click VPC networks and select the database VPC
# to see the details.
ip route add CLOUD_SQL_INSTANCE_PRIVATE_IP via DB_SUBNETWORK_GATEWAY

# Install Dante SOCKS server.
apt-get install -y dante-server

# Create the Dante configuration file.
touch /etc/danted.conf

# Create a proxy.log file.
touch proxy.log

# Add the following configuration for Dante:
cat > /etc/danted.conf << EOF
logoutput: /proxy.log
user.privileged: proxy
user.unprivileged: nobody

internal: 0.0.0.0 port = PORT
external: ens5

clientmethod: none
socksmethod: none

client pass {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error disconnect
}
client block {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error
}
socks pass {
        from: 0.0.0.0/0
        to: CLOUD_SQL_INSTANCE_PRIVATE_IP/32
        protocol: tcp
        log: connect error disconnect
}
socks block {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error
}
EOF

# Start the Dante server.
systemctl restart danted

tail -f proxy.log'

# Create the target instance from the created bastion VM.
gcloud compute target-instances create bastion-ti-REGION \
--instance=BASTION \
--project=PROJECT_ID \
--instance-zone=ZONE \
--network=dms-psc-vpc

# Create a forwarding rule for the backend service.
gcloud compute forwarding-rules create dms-psc-forwarder-REGION \
--project=PROJECT_ID \
--region=REGION \
--load-balancing-scheme=internal \
--network=dms-psc-vpc \
--subnet=dms-psc-REGION \
--ip-protocol=TCP \
--ports=all \
--target-instance=bastion-ti-REGION \
--target-instance-zone=ZONE

# Create a TCP NAT subnet.
gcloud compute networks subnets create dms-psc-nat-REGION-tcp \
--network=dms-psc-vpc \
--project=PROJECT_ID \
--region=REGION \
--range=10.1.0.0/16 \
--purpose=private-service-connect

# Create a service attachment.
gcloud compute service-attachments create dms-psc-svc-att-REGION \
--project=PROJECT_ID \
--region=REGION \
--producer-forwarding-rule=dms-psc-forwarder-REGION \
--connection-preference=ACCEPT_MANUAL \
--nat-subnets=dms-psc-nat-REGION-tcp

# Create a firewall rule allowing the Private Service Connect NAT subnet.
# access the Private Service Connect subnet
gcloud compute \
--project=PROJECT_ID firewall-rules create dms-allow-psc-tcp \
--direction=INGRESS \
--priority=1000 \
--network=dms-psc-vpc \
--action=ALLOW \
--rules=all \
--source-ranges=10.1.0.0/16 \
--enable-logging

# Print out the created service attachment.
gcloud compute service-attachments describe dms-psc-svc-att-REGION \
--project=PROJECT_ID \
--region=REGION

Terraform

variables.tf：

variable "project_id" {
  type        = string
  description = <<DESC
The Google Cloud project in which the setup is created. This should be the same project as
the one that the Cloud SQL instance belongs to.
DESC
}

variable "region" {
  type        = string
  description = "The Google Cloud region in which you create the Private Service Connect
regional resources."
}

variable "zone" {
  type        = string
  description = <<DESC
The Google Cloud zone in which you create the Private Service Connect zonal resources
(should be in the same region as the one specified in the "region" variable).
DESC
}

variable "cloud_sql_instance_name" {
  type        = string
  description = "The Cloud SQL instance name."
}

variable "port" {
  type        = string
  description = "The port that the bastion will use to expose the underlying database."
  default     = "5432"
}

variable "cloud_sql_instance_network" {
  type        = string
  description = <<DESC
The VPC to which the Cloud SQL instance is peered. This is where the bastion will
forward connections to (the destination database needs to be accessible in this VPC).
DESC
}

main.tf：

/* To execute the call:
terraform apply
-var="project_id=PROJECT_ID"
-var="region=REGION"
-var="zone=ZONE"
-var="cloud_sql_instance_name=CLOUD_SQL_INSTANCE_NAME"
-var="port=PORT"
-var="cloud_sql_instance_network=CLOUD_SQL_INSTANCE_NETWORK" */

locals {
  cloud_sql_instance_connection_name = "${var.project_id}:${var.region}:${var.cloud_sql_instance_name}"
}

# Needed for getting the private IP address of the Cloud SQL instance.
data "google_sql_database_instance" "csql_instance" {
  name    = var.cloud_sql_instance_name
  project = var.project_id
}

# Needed for getting the IPv4 gateway of the subnetwork for the database.
data "google_compute_subnetwork" "db_network_subnet" {
  name    = var.cloud_sql_instance_network
  project = var.project_id
  region  = var.region
}

resource "google_compute_network" "psc_sp_network" {
  name                    = "dms-psc-network"
  project                 = var.project_id
  auto_create_subnetworks = false
}

resource "google_compute_subnetwork" "psc_sp_subnetwork" {
  name    = "dms-psc-subnet"
  region  = var.region
  project = var.project_id

  network = google_compute_network.psc_sp_network.id
  # CIDR range can be lower.
  ip_cidr_range = "10.0.0.0/16"
}

resource "google_compute_subnetwork" "psc_sp_nat" {
  provider = google-beta
  name     = "dms-psc-nat"
  region   = var.region
  project  = var.project_id

  network = google_compute_network.psc_sp_network.id
  purpose = "PRIVATE_SERVICE_CONNECT"
  # CIDR range can be lower.
  ip_cidr_range = "10.1.0.0/16"
}

resource "google_compute_service_attachment" "psc_sp_service_attachment" {
  provider = google-beta
  name     = "dms-psc-svc-att"
  region   = var.region
  project  = var.project_id

  enable_proxy_protocol = false
  connection_preference = "ACCEPT_MANUAL"
  nat_subnets           = [google_compute_subnetwork.psc_sp_nat.id]
  target_service        = google_compute_forwarding_rule.psc_sp_target_direct_rule.id
}

resource "google_compute_forwarding_rule" "psc_sp_target_direct_rule" {
  name       = "dms-psc-fr"
  region     = var.region
  project    = var.project_id
  network    = google_compute_network.psc_sp_network.id
  subnetwork = google_compute_subnetwork.psc_sp_subnetwork.id

  load_balancing_scheme = "INTERNAL"
  ip_protocol           = "TCP"
  all_ports             = true

  target = google_compute_target_instance.psc_sp_target.id

}

resource "google_compute_target_instance" "psc_sp_target" {
  provider = google-beta
  name     = "dms-psc-fr-target"
  zone     = var.zone
  instance = google_compute_instance.psc_sp_bastion.id
  network  = google_compute_network.psc_sp_network.id
}

resource "google_compute_instance" "psc_sp_bastion" {
  name           = "dms-psc-cloud-sql-bastion"
  project        = var.project_id
  machine_type   = "e2-medium"
  zone           = var.zone
  can_ip_forward = true

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  # The incoming NIC defines the default gateway which must be the Private Service Connect subnet.
  network_interface {
    network    = google_compute_network.psc_sp_network.id
    subnetwork = google_compute_subnetwork.psc_sp_subnetwork.id
  }

  # The outgoing NIC which is on the same network as the Cloud SQL instance.
  network_interface {
    network = data.google_compute_subnetwork.db_network_subnet.network
  }

  metadata_startup_script = <<SCRIPT

#!/bin/bash

# Route the private IP address of the database using the gateway of the database subnetwork.
# To find the gateway for the relevant subnetwork, go to the VPC network page
# in the Google Cloud console. Click VPC networks, and select the database VPC
# to see the details.
ip route add ${data.google_sql_database_instance.csql_instance.private_ip_address} \
via ${data.google_compute_subnetwork.db_network_subnet.gateway_address}

# Install Dante SOCKS server.
apt-get install -y dante-server

# Create the Dante configuration file.
touch /etc/danted.conf

# Create a proxy.log file.
touch proxy.log

# Add the following configuration for Dante:
cat > /etc/danted.conf << EOF
logoutput: /proxy.log
user.privileged: proxy
user.unprivileged: nobody

internal: 0.0.0.0 port = ${var.port}
external: ens5

clientmethod: none
socksmethod: none

client pass {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error disconnect
}
client block {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error
}
socks pass {
        from: 0.0.0.0/0
        to: ${data.google_sql_database_instance.csql_instance.private_ip_address}/32
        protocol: tcp
        log: connect error disconnect
}
socks block {
        from: 0.0.0.0/0
        to: 0.0.0.0/0
        log: connect error
}
EOF

# Start the Dante server.
systemctl restart danted

tail -f proxy.log

SCRIPT
}

# Required firewall rules:

/* Firewall rule allowing the Private Service Connect NAT subnet to access
the Private Service Connect subnet. */
resource "google_compute_firewall" "psc_sp_in_fw" {
  name    = "dms-psc-ingress-nat-fw"
  project = var.project_id
  network = google_compute_network.psc_sp_network.id

  log_config {
    metadata = "INCLUDE_ALL_METADATA"
  }

  allow {
    protocol = "all"
  }

  priority  = 1000
  direction = "INGRESS"
  source_ranges = [google_compute_subnetwork.psc_sp_nat.ip_cidr_range]
}

/* The router that the bastion VM uses to install external packages
(for example, Dante SOCKS server). */

resource "google_compute_router" "psc_sp_ex_router" {
  name    = "dms-psc-external-router"
  project = var.project_id
  region  = var.region
  network = google_compute_network.psc_sp_network.id
}

resource "google_compute_router_nat" "psc_sp_ex_router_nat" {
  name    = "dms-psc-external-router-nat"
  project = var.project_id
  region  = var.region
  router  = google_compute_router.psc_sp_ex_router.name

  nat_ip_allocate_option             = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}

outputs.tf：

# The Private Service Connect service attachment.
output "service_attachment" {
  value = google_compute_service_attachment.psc_sp_service_attachment.id
}

稍後建立目的地連線設定檔時，請執行下列操作：

在「Define connectivity method」(定義連線方式) 部分，選取「Private IP」。
在「Service attachment name」下拉式選單中，選取「dms-psc-svc-att-REGION」。

為 PostgreSQL 適用的 Cloud SQL 目的地設定私人 IP 連線 透過集合功能整理內容 你可以依據偏好儲存及分類內容。

適用於已啟用 PSC 的 Cloud SQL 執行個體的 Private Service Connect

針對未啟用 PSC 的 Cloud SQL 執行個體使用 Private Service Connect

gcloud

Terraform

為 PostgreSQL 適用的 Cloud SQL 目的地設定私人 IP 連線
透過集合功能整理內容你可以依據偏好儲存及分類內容。