Diese Seite wurde von der Cloud Translation API übersetzt.

Private Service Connect für einen Zielcluster konfigurieren

Auf dieser Seite wird beschrieben, wie Sie Database Migration Service einrichten, um Ihre Oracle-Arbeitslasten mithilfe der privaten IP-Adresse des Ziel-AlloyDB for PostgreSQL-Clusters zu AlloyDB for PostgreSQL zu migrieren. Über private Verbindungen kann der Database Migration Service auf Dienste zugreifen, ohne das Internet zu nutzen oder externe IP-Adressen zu verwenden.

Database Migration Service verwendet Private Service Connect, um über eine private IP-Adresse eine Verbindung zu Ihrem AlloyDB for PostgreSQL-Cluster herzustellen. Mit Private Service Connect können Sie Ihre Zieldatenbank für eingehende sichere Verbindungen freigeben und steuern, wer auf die Datenbank zugreifen kann.

Private Service Connect für PSC-kompatible AlloyDB for PostgreSQL-Cluster

Wenn Sie Ihre AlloyDB for PostgreSQL-Zielinstanz mit aktiviertem Private Service Connect erstellen, können Sie die private IP-Konnektivität ohne zusätzliche Netzwerkeinrichtung verwenden. Achten Sie beim Erstellen des Verbindungsprofils für die Zieldatenbank nur auf Folgendes:

Verwenden Sie den DNS-Eintrag Ihres AlloyDB for PostgreSQL-Clusters anstelle des Hostnamens des Ziels.
Nur für programmatischen Zugriff über die Google Cloud CLI oder die API: Geben Sie in der Anfrage den Dienstanhang des Ziels explizit an. Dies geschieht automatisch durch den Database Migration Service, wenn Sie Verbindungsprofile in der Google Cloud Console erstellen.

Privater Dienstzugriff für AlloyDB for PostgreSQL-Cluster, für die PSC nicht aktiviert ist

Wenn Sie einen Dienst mit Private Service Connect für AlloyDB for PostgreSQL-Cluster freigeben möchten, erstellen Sie in Ihrem Projekt einen Dienstanhang. Du kannst das Beispiel-gcloud und die Terraform-Scripts im Abschnitt Private Service Connect-Produzenteinrichtung erstellen verwenden, um die erforderlichen Ressourcen zu erstellen.

Wenn eine Bastion-VM nicht für Ihre Netzwerkanforderungen ausreicht, konfigurieren Sie eine Instanzgruppe für die Einrichtung des Netzwerk-Produzenten. Weitere Informationen finden Sie unter Netzwerkkonnektivität in verwalteten Diensten.

Das folgende Diagramm zeigt die verschiedenen Rechen- und Netzwerkressourcen, die der Database Migration Service verwendet, um eine private Verbindung zu Ihrem AlloyDB for PostgreSQL-Cluster einzurichten.

Private Service Connect-Einrichtung

Der Worker des Database Migration Service ist eine interne Verarbeitungseinheit, die für die Migration mit dem Database Migration Service verantwortlich ist. Es verwendet eine ausgehende Private Service Connect-Weiterleitungsregel, um den Traffic vom Worker an das VPC-Netzwerk zu senden, in dem sich die Bastion-VM befindet.

Die wichtigsten Ressourcen, die Sie mit den Scripts erstellen können, sind:

Dienstanhang: Eine Ressource, die einen Dienst freigibt, indem Traffic an den Zieldienst weitergeleitet wird. Im Diagramm ist der Zieldienst eine eingehende Weiterleitungsregel.
Eine Regel für die Weiterleitung eingehender Zugriffe: Ein Traffic-Weiterleiter, der den eingehenden Traffic von der Dienstanwendung an ein bestimmtes Ziel weiterleitet (z. B. eine VM oder eine Instanzgruppe). Im Diagramm leitet die Regel den Traffic an eine Bastions-VM weiter.
Bastion-VM: Eine VM mit zwei Netzwerkschnittstellencontrollern (NICs), von denen einer mit dem dedizierten Private Service Connect-Netzwerk und der andere mit dem Netzwerk verbunden ist, mit dem der AlloyDB for PostgreSQL-Cluster gepeert ist. Auf der Bastion wird ein Dante-SOCKS-Server ausgeführt, mit dem die Verbindungen sicher weitergeleitet werden. Die Beispielscripts erstellen für Sie ein eigenes Netzwerk und Subnetze im Private Service Connect-Netzwerk.

Das Google Cloud Projekt, mit dem Sie Ihren Dienst über den Dienstanhang veröffentlichen, ist der Dienstersteller. Der Dienstnutzer ist der Datenbank-Migrationsdienst. Weitere Informationen zu Private Service Connect, seiner Einrichtung und Architektur finden Sie in der Private Service Connect-Dokumentation.

Private Service Connect-Produzenteinrichtung erstellen

Mit den folgenden Scripts können Sie die Private Service Connect-Einrichtung erstellen und eine Verbindung zum Ziel-AlloyDB for PostgreSQL-Cluster herstellen. Wenn bei der Einrichtung der Verbindung Probleme auftreten, besuchen Sie die Seiten zur Fehlerbehebung für die Verbindung.

gcloud

Im folgenden Bash-Script wird mit der Google Cloud CLI die Private Service Connect-Produzenteneinrichtung für die Zieldatenbank erstellt. Einige Standardeinstellungen müssen möglicherweise angepasst werden, z. B. die CIDR-Bereiche des Private Service Connect-Subnetzes.

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

# 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 ALLOYDB_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: ALLOYDB_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

Ersetzen Sie Folgendes:

PROJECT_ID: das Projekt, in dem du die Private Service Connect-Erstellereinrichtung erstellst.
REGION: die Region, in der du die Private Service Connect-Producer-Einrichtung erstellst.
ZONE: Eine Zone innerhalb von REGION, in der Sie alle Zonenressourcen erstellen (z. B. die Bastions-VM).
BASTION: die zu erstellende Bastions-VM.
DB_SUBNETWORK: das Subnetz, an das der Traffic weitergeleitet wird. Das Unternetzwerk muss Zugriff auf den AlloyDB for PostgreSQL-Cluster haben.
DB_SUBNETWORK_GATEWAY: Das IPv4-Gateway des Subnetzes.
PORT: Der Port, über den die Bastion die zugrunde liegende Datenbank freigibt.
ALLOYDB_INSTANCE_PRIVATE_IP: die private IP-Adresse des AlloyDB for PostgreSQL-Clusters.

Terraform

Die folgenden Dateien können in einem Terraform-Modul verwendet werden, um die Private Service Connect-Produzenteneinrichtung für die Zieldatenbank zu erstellen. Einige Standardeinstellungen müssen möglicherweise angepasst werden, z. B. die CIDR-Bereiche für Private Service Connect-Subnetze.

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 AlloyDB for PostgreSQL cluster 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 "primary_instance_private_ip" {
  type = string
  description = "The cluster's primary instance private IP"
}

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

variable "alloydb_cluster_network" {
  type        = string
  description = <<DESC
The VPC to which the AlloyDB for PostgreSQL cluster 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="primary_instance_private_ip=PRIMARY_INSTANCE_PRIVATE_IP"
-var="port=PORT"
-var="alloydb_cluster_network=ALLOYDB_CLUSTER_NETWORK" */

# Needed for getting the IPv4 gateway of the subnetwork for the database.

data "google_compute_subnetwork" "db_network_subnet" {
  name    = var.alloydb_cluster_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 AlloyDB for PostgreSQL cluster.

  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 ${var.primary_instance_private_ip} \
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: ${var.primary_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

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
}

Zurück

Tabellen ohne Primärschlüssel migrieren

Weiter

Private Verbindungskonfiguration erstellen