Configurare Private Service Connect per un cluster di destinazione

Questa pagina descrive come configurare Database Migration Service per eseguire la migrazione dei carichi di lavoro Oracle in AlloyDB per PostgreSQL utilizzando l'indirizzo IP privato del cluster AlloyDB per PostgreSQL di destinazione. Le connessioni private consentono a Database Migration Service di accedere ai servizi senza passare da internet o utilizzare indirizzi IP esterni.

Database Migration Service utilizza Private Service Connect per connettersi al tuo cluster AlloyDB per PostgreSQL utilizzando un indirizzo IP privato. Con Private Service Connect, puoi esporre il database di destinazione alle connessioni sicure in entrata e controllare chi può accedere al database.

Private Service Connect per i cluster AlloyDB per PostgreSQL abilitati a PSC

Nota: i cluster AlloyDB per PostgreSQL con PSC abilitato presentano alcune limitazioni funzionali. Assicurati che queste configurazioni soddisfino i tuoi requisiti prima di eseguire la migrazione ai cluster AlloyDB per PostgreSQL abilitati per PSC. Consulta Limitazioni di Private Service Connect nella documentazione di AlloyDB per PostgreSQL.

Se crei l'istanza di destinazione AlloyDB per PostgreSQL con Private Service Connect abilitato, puoi utilizzare la connettività IP privato senza alcuna configurazione di rete aggiuntiva. Quando crei il profilo di connessione del database di destinazione, devi solo assicurarti di quanto segue:

• Utilizza il record DNS del tuo cluster AlloyDB per PostgreSQL anziché il nome host della destinazione.

• Solo per l'accesso programmatico tramite Google Cloud CLI o API: specifica esplicitamente l'attacco del servizio di destinazione nella richiesta (questa operazione viene eseguita automaticamente da Database Migration Service quando crei i profili di connessione nella console Google Cloud ).

Private Service Connect per i cluster AlloyDB per PostgreSQL non abilitati a PSC

Per esporre un servizio utilizzando Private Service Connect per i cluster AlloyDB per PostgreSQL, crea un collegamento di servizio nel tuo progetto. Puoi utilizzare gli script gcloud e Terraform di esempio nella sezione Creare la configurazione del producer Private Service Connect per creare le risorse richieste.

Il seguente diagramma mostra le varie risorse di calcolo e di rete utilizzate da Database Migration Service per configurare la connettività privata al cluster AlloyDB per PostgreSQL.

Il worker di Database Migration Service è un'unità di elaborazione interna responsabile della migrazione di Database Migration Service. Utilizza una regola di forwarding Private Service Connect in uscita per inviare il traffico dal worker alla rete VPC in cui risiede la macchina virtuale (VM) bastion.

Le risorse chiave che gli script ti aiutano a creare sono:

• Un collegamento al servizio: una risorsa che espone un servizio inoltrando il traffico al servizio di destinazione. Nel diagramma, il servizio di destinazione è una regola di forwarding in entrata.
• Una regola di forwarding in entrata: un inoltro del traffico che indirizza il traffico in entrata dall'attacco del servizio a una destinazione dedicata (ad esempio una VM o un gruppo di istanze). Nel diagramma, la regola inoltra il traffico a una VM bastion.
• Una VM bastion: una VM con due controller di interfaccia di rete (NIC), una delle quali è collegata alla rete Private Service Connect dedicata e l'altra alla rete a cui è collegato il cluster AlloyDB per PostgreSQL. Il bastione esegue un server SOCKS Dante, che viene utilizzato per inoltrare le connessioni in modo sicuro. Gli script di esempio creano per te una rete e subnet dedicate nella rete Private Service Connect.

Il progetto Google Cloud che utilizzi per pubblicare il servizio utilizzando l'allegato del servizio è il producer di servizi. Il consumatore del servizio è Database Migration Service. Per ulteriori informazioni su Private Service Connect, sulla sua configurazione e sulla sua architettura, consulta la documentazione di Private Service Connect.

Crea la configurazione del producer di Private Service Connect

Puoi utilizzare i seguenti script per creare la configurazione di Private Service Connect e connetterti al cluster AlloyDB per PostgreSQL di destinazione. Se riscontri problemi durante la configurazione della connettività, consulta le pagine sulla risoluzione dei problemi di connettività.

gcloud

Il seguente script bash utilizza Google Cloud CLI per creare la configurazione del produttore Private Service Connect per il database di destinazione. Tieni presente che potrebbe essere necessario modificare alcuni valori predefiniti, ad esempio gli intervalli CIDR della subnet di Private Service Connect.

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

Sostituisci quanto segue:

• PROJECT_ID: il progetto in cui crei la configurazione del producer Private Service Connect.
• REGION: la regione in cui crei la configurazione del producer Private Service Connect.
• ZONE: una zona all'interno di REGION in cui crei tutte le risorse zonali (ad esempio la VM bastion).
• BASTION: la VM bastion da creare.
• DB_SUBNETWORK: la subnet a cui verrà inoltrato il traffico. La sottorete deve avere accesso al cluster AlloyDB per PostgreSQL.
• DB_SUBNETWORK_GATEWAY: il gateway IPv4 della sottorete.
• PORT: la porta utilizzata dal bastione per esporre il database sottostante.
• ALLOYDB_INSTANCE_PRIVATE_IP: l'indirizzo IP privato del cluster AlloyDB per PostgreSQL.

Terraform

I seguenti file possono essere utilizzati in un modulo Terraform per creare la configurazione del producer Private Service Connect per il database di destinazione. Potrebbe essere necessario modificare alcuni valori predefiniti, ad esempio gli intervalli CIDR della subnet Private Service Connect.

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
}

Puoi creare le risorse di calcolo e di rete necessarie per esporre il tuo database AlloyDB per PostgreSQL senza utilizzare gli script. Tuttavia, devi assicurarti di disporre di un allegato del servizio che esponga il database e di poterlo utilizzare da un altro progetto Google Cloud . Per ulteriori informazioni, consulta la documentazione di Private Service Connect.