Abilita Private Service Connect nell'istanza Cloud SQL esistente che esegue PSA (Terraform)

1. Panoramica

Esistono diverse opzioni per connettersi a un'istanza privata Cloud SQL da un altro progetto o rete VPC. Puoi utilizzare l'accesso privato ai servizi (PSA) per raggiungere gli indirizzi IP interni dei servizi Google e di terze parti tramite connessioni private. Per estendere l'accesso al database, ora puoi abilitare anche Private Service Connect (PSC).

Private Service Connect (PSC) consente ai producer di servizi di esporre i propri servizi tramite collegamenti di servizio, che i consumer possono utilizzare per creare endpoint PSC e/o backend PSC nel proprio ambiente. Tramite questi endpoint PSC possono connettersi ai servizi producer tramite un IP privato specificato dall'utente.

In questo lab puoi configurare e testare l'opzione.

Nota:questa soluzione presenta alcune limitazioni, che puoi consultare nella sezione Limitazione di Private Service Connect della documentazione.

In questo lab, creerai un'architettura semplice che illustra l'utilizzo dell'accesso agli endpoint PSA e PSC con Cloud SQL.

Figura 1.

Per questo lab, avrai bisogno di due progetti o di VPC separati nello stesso progetto.

Nota:l'accesso globale può essere abilitato sull'endpoint PSC per renderlo disponibile da altre regioni.

Obiettivi

In questo lab imparerai a eseguire la seguente attività:

• Abilita il service networking
• Configurare PSA
• Crea un'istanza Cloud SQL con PSA
• Abilita il collegamento del servizio PSC.
• Crea un endpoint PSC nel VPC consumer per connetterti al database CloudSQL
• Verifica l'accesso al database SQL dalle VM di test, sia nei VPC producer che consumer

Nota:questo design può essere utilizzato da più consumatori. Scopri di più sulla multi-tenancy di Private Service Connect.

2. Configurazione e requisiti

Configurazione dell'ambiente autonomo

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da altri dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la località predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

3. Attività 1: Configura l'ambiente per il progetto di database con (Terraform)

Tieni presente che alcune risorse che attivi comportano dei costi. Per ridurre i costi, assicurati che le risorse vengano eliminate al termine del lab. Ti consigliamo di controllare la fatturazione e assicurarti che l'esercizio sia accettabile per te.

Nel progetto di database, abiliteremo il service networking, creeremo un VPC, un intervallo PSA, un peering di service networking e regole firewall. Apri la console Cloud e seleziona il progetto che utilizzerai per il database.

1. Apri Cloud Shell in alto a destra nella console, assicurati di visualizzare l'ID progetto del progetto di database in Cloud Shell e conferma le richieste per consentire l'accesso.
2. Crea una cartella denominata terraform-db-psc e spostati al suo interno

mkdir terraform-db-psc  && cd terraform-db-psc

3. Crea un file main.tf, variable.tf, nat-vm.tf e database.tf.

touch main.tf variable.tf nat-vm.tf database.tf 

4. Passa alla visualizzazione dell'editor di Cloud Shell. Seleziona Editor e assicurati di consentire tutti i prompt necessari per caricare l'interfaccia.
5. Una volta caricato, vai a File > Apri cartella e vai a /home/your-user-name/terraform-db-psc e seleziona Ok per aprire la cartella nell'editor.
6. Seleziona il file variable.tf e aggiungi quanto segue. Sostituisci il testo your-database-project-id-here con l'ID effettivo del progetto di database tra virgolette. Sostituisci il testo your-consumer-project-id-here con l'ID del tuo progetto consumer effettivo tra virgolette.

variable "project_id" {
  type = string
  default = "your-database-project-id-here"
}

variable "project_id_consumer" {
  type = set(string)
  default = ["your-consumer-project-id-here"]
}

variable "network_id" {
  type = string
  default = "database-net"
}

variable "region_id" {
  type = string
  default = "us-east1"
}

variable "db_password" {
  type = string
  default = "cloudsql24"
}

7. A questo punto, apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.

Abilita API	resource "google_project_service" "default"
Crea VPC	resource "google_compute_network" "default"
Aggiungere regole firewall	resource "google_compute_firewall" "allow_icmp"
Creare un intervallo PSA	resource "google_compute_global_address" "psa_range"
Creare un peering	resource "google_service_networking_connection" "private_connection"

8. Copia e incolla quanto segue nel file main .tf.

resource "google_project_service" "default" {
 for_each = toset([
   "compute.googleapis.com",
   "servicenetworking.googleapis.com", 
   "sqladmin.googleapis.com",
   "cloudresourcemanager.googleapis.com"
 ])

 service            = each.value
 disable_on_destroy = false
}

resource "google_compute_network" "default" {
 project                = var.project_id
 name                    = var.network_id
 auto_create_subnetworks = true
 mtu                     = 1460
 routing_mode            = "GLOBAL"
}

resource "google_compute_global_address" "psa_range" {
  name                  = "psa-range-${google_compute_network.default.name}"
  project               = var.project_id
  purpose               = "VPC_PEERING"
  address_type          = "INTERNAL"
  prefix_length         = 20
  address               = "172.18.0.0"
  network               = google_compute_network.default.id

}

resource "google_service_networking_connection" "private_connection" {
  network = google_compute_network.default.self_link
  service = "servicenetworking.googleapis.com"

  reserved_peering_ranges = [
    google_compute_global_address.psa_range.name,
  ]
}

resource "google_compute_firewall" "allow_icmp" {
 name    = "allow-icmp-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "icmp"
 }

 source_ranges = ["0.0.0.0/0"]
 target_tags   = ["allow-icmp"]
}

resource "google_compute_firewall" "allow_ssh" {
 name    = "allow-ssh-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "tcp"
   ports    = ["22"]
 }

 source_ranges = ["0.0.0.0/0"]
 target_tags   = ["allow-ssh"]
}

resource "google_compute_firewall" "allow_sql" {
 name    = "allow-sql-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "tcp"
   ports    = ["3306"]
 }

 source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "allow_internal" {
 name    = "allow-internal-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "icmp"
 }

 allow {
   protocol = "tcp"
   ports    = ["0-65535"]
 }
 allow {
   protocol = "udp"
   ports    = ["0-65535"]
 }

 source_ranges = ["10.128.0.0/9", "172.18.0.0/20"] # Include PSA range
}

9. Torna al terminale Cloud Shell, assicurati di trovarti nella directory terraform-db-psc cd terraform-db-psc ed esegui i seguenti comandi:

terraform init

Inizializza la directory di lavoro. Questo passaggio scarica i provider richiesti per la configurazione specificata.

terraform plan

Genera un piano di esecuzione, che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.

10. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguire.

Verifica la configurazione:

Controlla che nel tuo ambiente sia allocato l'intervallo IP PSA in peering con la rete VPC con Service Networking abilitato

VPC in modalità automatica chiamato database-net creato

Regole firewall create

4. Attività 2: Crea un'istanza Cloud SQL con PSA (Terraform)

Utilizziamo Terraform per creare un'istanza Cloud SQL con l'opzione PSA per consentire la connettività. Completa questa configurazione nel progetto di database.

1. Passa alla visualizzazione dell'editor di Cloud Shell. Assicurati di trovarti nella cartella terraform-db-psc. Seleziona il file database.tf e aggiungi quanto segue.

resource "google_sql_database_instance" "default" {
  name             = "psc-psa-sql-db"
  region           = var.region_id
  database_version = "MYSQL_8_0"  
  settings {
    tier              = "db-f1-micro"
    availability_type = "REGIONAL"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
    ip_configuration {      
      ipv4_enabled    = "false"
      private_network = google_compute_network.default.id
      
    }
  }
  deletion_protection = false 
}

resource "google_sql_user" "users" {
  name     = "testsql"
  instance = google_sql_database_instance.default.name
  password = var.db_password 
}

2. Torna al terminale Cloud Shell e assicurati di trovarti nella directory terraform-db-psc. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguire. La creazione dell'istanza Cloud SQL con PSA può richiedere fino a 15 minuti o più.

Verificare il database

3. Al termine, vai a SQL nella console e seleziona l'istanza di database psc-psa-sql-db appena creata.
4. Sul lato sinistro, espandi il riquadro delle opzioni SQL e seleziona Connessioni.
5. Nella scheda Riepilogo puoi visualizzare le informazioni sulla connessione.
6. Copia l'indirizzo IP interno e salvalo da qualche parte sul tuo sistema. Come puoi vedere, è stato assegnato dall'intervallo che abbiamo riservato.
7. Avrai bisogno di questo IP per completare il passaggio 5 dell'attività 3.

8. Sul lato sinistro, espandi il riquadro delle opzioni SQL e seleziona Utenti.
9. Dovresti visualizzare un utente chiamato testsql con la password cloudsql24 (che verrà utilizzata per accedere al database in un secondo momento)

Verifica la configurazione:

1 istanza del database SQL con IP privato

Un utente chiamato testsql e password cloudsql24

5. Attività 3: Crea una VM di test e connettiti all'istanza SQL dall'interno del progetto db (Terraform)

Utilizziamo Terraform per creare una VM di test e un gateway NAT. Completa questa configurazione nel progetto di database.

1. Passa alla visualizzazione dell'editor di Cloud Shell. Assicurati di trovarti nella cartella terraform-db-psc. Seleziona il file nat-vm.tf e aggiungi quanto segue.

resource "google_compute_router" "default" {
  name    = "outbound-nat"
  region  = var.region_id
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name = "outbound-nat-gw"
  router = google_compute_router.default.name
  region = google_compute_router.default.region
  nat_ip_allocate_option = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

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


resource "google_compute_instance" "sql_net_vm" {
  name         = "db-vm-test"
  machine_type = "e2-medium"
  zone         = "${var.region_id}-b"
  project      = var.project_id

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

  network_interface {
    network = google_compute_network.default.self_link
  }

  # No external IP address
  network_performance_config {
    total_egress_bandwidth_tier = "DEFAULT"
  }

  tags = ["allow-icmp", "allow-ssh", "allow-internal", "allow-health-check"]

  # Install MariaDB at startup
  metadata_startup_script = <<EOF
#!/bin/bash
apt-get update
apt-get install -y mariadb-server
systemctl enable mariadb
EOF
}

2. Torna al terminale Cloud Shell e assicurati di trovarti nella directory terraform-db-psc. Ora, per creare le risorse, esegui il comando terraform plan, then terraform apply e digita yes per eseguire. Verranno creati un gateway NAT e una VM con MariaDB installato.

Verificare il database

Completa questa operazione nel progetto consumer

3. Vai a Istanza VM. Seleziona db-vm-test
4. Seleziona l'opzione SSH per connetterti alla VM.
5. Connettiti al database tramite l'IP locale che hai copiato in precedenza con quanto segue:

mysql --host=172.18.0.2 --user=testsql --password=cloudsql24

P.S. Modifica l'indirizzo IP con il tuo indirizzo IP effettivo per la connessione.

6. Una volta stabilita la connessione, crea un database con il seguente localvpcsqldb.

CREATE DATABASE localvpcsqldb;

7. Al termine, digita exit per uscire dalla connessione. Digita di nuovo exit per chiudere la VM.

Verifica la configurazione:

1 gateway NAT

Una VM chiamata db-vm-test

6. Attività 4: Abilita PSC sull'istanza Cloud SQL

Utilizziamo i comandi gcloud per abilitare l'opzione PSC per consentire la connettività. Completa questa configurazione nel progetto di database.

1. Passa alla visualizzazione Cloud Shell.
2. Esegui questo comando in Cloud Shell.

• Sostituisci Ensure YOUR_DB_PROJECT_HERE con l'ID progetto del database.
• Sostituisci Ensure YOUR_CONSUMER_PROJECT_HERE con l'ID progetto consumer.

project_id=YOUR_DB_PROJECT_HERE
allowed_project=YOUR_CONSUMER_PROJECT_HERE

gcloud beta sql instances patch psc-psa-sql-db \
--project=$project_id \
--enable-private-service-connect \
--allowed-psc-projects=$allowed_project

3. Il database esistente verrà aggiornato con l'allegato PSC. L'operazione richiederà un po' di tempo, più di 10 minuti.

Se ricevi un errore di timeout di attesa, dovresti anche visualizzare il comando per continuare a vedere l'avanzamento. Qualcosa del tipo "Puoi continuare ad attendere l'operazione eseguendo `gcloud beta sql operations wait –project "

Tieni presente che puoi eseguire il deployment di un nuovo database con PSA e PSC abilitati fin dall'inizio.

Verificare il database

4. Al termine, vai a SQL nella console e seleziona l'istanza di database psc-psa-sql-db.
5. Sul lato sinistro, espandi il riquadro delle opzioni SQL e seleziona Connessioni.
6. Nella scheda Riepilogo puoi visualizzare le informazioni sulla connessione.
7. Copia l'indirizzo dell'allegato di servizio e salvalo in un punto qualsiasi del sistema.
8. Ti servirà per completare l'attività successiva, il passaggio 8.

Verifica la configurazione:

1 istanza di database SQL con collegamento al servizio

7. Attività 5: Configura l'ambiente per il progetto consumer (Terraform)

Nel progetto consumer,creeremo un VPC personalizzato con regole firewall e subnet. Apri la console Cloud e seleziona il progetto che utilizzerai.

1. Nella parte superiore della console, a destra, accanto all'icona di Google Cloud, fai clic sul menu a discesa e seleziona la scheda Tutti.

2. Seleziona l'ID del tuo progetto consumer tra quelli elencati per continuare.
3. Apri Cloud Shell, che si trova in alto a destra nella console, assicurati di visualizzare l'ID progetto consumer in Cloud Shell e conferma le richieste di autorizzazione dell'accesso.
4. Crea una cartella denominata terraform-consumer-psc e spostati nella cartella

mkdir terraform-consumer-psc  && cd terraform-consumer-psc

5. Crea un file main.tf, variable.tf e psc.tf.

touch main.tf variable.tf psc.tf 

6. Passa alla visualizzazione dell'editor Cloud Shell per l'ID progetto consumer. Seleziona Editor e assicurati di consentire tutti i prompt necessari per caricare l'interfaccia.
7. Una volta caricato, vai a File > Apri cartella e vai a /home/your-user-name/terraform-consumer-psc e seleziona Ok per aprire la cartella nell'editor.
8. Seleziona il file variable.tf e aggiungi quanto segue. Sostituisci il testo your-consumer-project-id-here con il tuo ID progetto consumer effettivo tra virgolette. Sostituisci il testo your-psc-attachment-id-here con l'indirizzo dell'allegato PSC tra virgolette. Questo è l'ID che hai copiato nella sezione 5-7 dell'attività 4

variable "project_id" {
  type = string
  default = "your-consumer-project-id-here"
}

variable "psc_attachment_id" {
  type = string
  default = "your-psc-attachment-id-here"
}

variable "network_id" {
  type = string
  default = "psc-endpoint-vpc"
}

variable "region_id" {
  type = string
  default = "us-east1"
}

9. A questo punto, apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.

Abilita API	resource "google_project_service"
Crea VPC	resource "google_compute_network"
Crea gateway NAT	resource "google_compute_router" resource "google_compute_router_nat"
Aggiungere regole firewall	resource "google_compute_firewall"

10. Copia e incolla quanto segue nel file main .tf.

resource "google_project_service" "default" {
  for_each = toset([
    "compute.googleapis.com",
    "cloudresourcemanager.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "vm_subnet_pc" {
  name          = "vm-net"
  ip_cidr_range = "192.168.80.0/24"
  region        = var.region_id
  network       = google_compute_network.default.name
  project       = var.project_id
}

resource "google_compute_subnetwork" "psc_subnet_ip" {
  name          = "psc-subnet"
  ip_cidr_range = "192.168.100.0/24"
  region        = var.region_id
  network       = google_compute_network.default.name
  project       = var.project_id
}

resource "google_compute_router" "default" {
  name    = "outbound-nat"
  region  = var.region_id
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name = "outbound-nat-gw"
  router = google_compute_router.default.name
  region = google_compute_router.default.region
  nat_ip_allocate_option = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

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

resource "google_compute_firewall" "allow_icmp" {
  name    = "allow-icmp-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
  
}

resource "google_compute_firewall" "allow_ssh" {
  name    = "allow-ssh-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-ssh"]
}


resource "google_compute_firewall" "allow_internal" {
  name    = "allow-internal-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
    }


  allow {
    protocol = "tcp"
    ports    = ["0-65535"]
  }
  allow {
    protocol = "udp"
    ports    = ["0-65535"]
  }

  source_ranges = ["192.168.0.0/16"]
 }

11. Torna al terminale Cloud Shell, assicurati di trovarti nella directory terraform-consumer-psc cd terraform-consumer-psc nel progetto consumer ed esegui i seguenti comandi

terraform init

Inizializza la directory di lavoro. Questo passaggio scarica i provider richiesti per la configurazione specificata.

terraform plan

Genera un piano di esecuzione, che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.

12. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguire.

Verifica la configurazione:

Controlla l'ambiente per

1 VPC personalizzata denominata psc-endpoint-vpc

Gateway NAT con regole firewall

8. Attività 6: Crea l'endpoint PSC per l'allegato SQL DB nel progetto consumer e nella VM di test (Terraform)

Completa questa configurazione nel progetto consumer.

1. Torna all'editor di Cloud Shell, apri la directory terraform-consumer-psc e seleziona il file psc.tf. Aggiungi il seguente codice Terraform al file. Vengono creati un IP interno statico, un endpoint PSC e una VM di test con MariaDB installato.

resource "google_compute_address" "default" {
  name = "psc-ip-1"
  region = var.region_id
  address_type = "INTERNAL"
  subnetwork = google_compute_subnetwork.psc_subnet_ip.name
  address = "192.168.100.100" 
}

resource "google_compute_forwarding_rule" "default" {
  name = "psc-sql-endpoint"
  region = var.region_id
  network = google_compute_network.default.name
  ip_address = google_compute_address.default.self_link
  load_balancing_scheme = ""
  target = var.psc_attachment_id
}


resource "google_compute_instance" "sql_test_vm" {
  name         = "remote-sql-test-vm"
  machine_type = "e2-medium"
  zone         = "${var.region_id}-b"
  project      = var.project_id

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

  network_interface {
    subnetwork = google_compute_subnetwork.vm_subnet_pc.name
  }

  # No external IP address
  network_performance_config {
    total_egress_bandwidth_tier = "DEFAULT"
  }

  tags = ["allow-icmp", "allow-ssh", "allow-internal", "allow-health-check"]

  # Install MariaDB at startup
  metadata_startup_script = <<EOF
#!/bin/bash
apt-get update
apt-get install -y mariadb-server
systemctl enable mariadb
EOF
}

2. Torna al terminale Cloud Shell, assicurati di trovarti nella directory terraform-consumer-psc cd terraform-consumer-psc nel progetto consumer ed esegui i seguenti comandi

terraform plan

Genera un piano di esecuzione, che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.

3. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguire

9. Attività 7: Verifica la connettività dell'endpoint dalla VM tramite l'indirizzo IP PSC

Completa questa operazione nel progetto consumer

8. Vai a Istanza VM. Seleziona remote-sql-test-vm
9. Seleziona l'opzione SSH per connetterti alla VM.
10. Connettiti al database tramite l'endpoint con quanto segue:

mysql --host=192.168.100.100 --user=testsql --password=cloudsql24

11. Una volta stabilita la connessione, crea un database con il seguente psc-sql-db.

CREATE DATABASE remotepscpsasqldb;

12. Al termine, digita exit per uscire dalla connessione. Digita di nuovo exit per chiudere la VM.

10. Attività 8: Verifica la voce del database

Completa questa verifica nel progetto di database

1. Nella parte superiore della console, a destra, accanto all'icona di Google Cloud, fai clic sul menu a discesa e seleziona la scheda Tutti.

2. Per continuare, seleziona l'ID progetto del database tra i progetti elencati.
3. Vai a SQL, seleziona il database psc-psa-sql-db, espandi le opzioni SQL e seleziona Database. Dovresti vedere il database appena creato chiamato remotepscpsasqldb dalla VM del progetto consumer e anche localvpcsqldb dalla VM del progetto db**.**

Nota:puoi anche connetterti utilizzando un nome DNS. Scopri di più sulla configurazione del DNS qui: Configura una zona gestita DNS e un record DNS.

11. Esegui la pulizia

Assicurati di liberare spazio per evitare addebiti non necessari.

Completa questa operazione nel progetto consumer

1. Seleziona l'ID progetto consumer
2. Vai a Cloud Shell e assicurati di visualizzare l'ID progetto consumer.
3. Vai alla directory terraform-consumer-psc cd terraform-consumer-psc ed esegui il seguente comando terraform destroy e digita yes tutte le risorse che hai creato nel tuo progetto consumer con Terraform verranno rimosse.

Completa questa operazione nel progetto Database

1. Seleziona l'ID progetto del database
2. Vai a Cloud Shell e assicurati di visualizzare l'ID progetto del database
3. Vai alla directory terraform-db-psc cd terraform-db-psc ed esegui il seguente comando terraform destroy e digita yes la maggior parte delle risorse create nel progetto db con Terraform verrà rimossa. Il servizio di networking potrebbe non essere eliminato e generare un errore.
4. Poi elimina i seguenti file dalla cartella terraform-db-psc.

rm -r terraform.tfstate terraform.tfstate.backup

5. Nella console, vai a Reti VPC.
6. Seleziona il VPC database-net, seleziona ACCESSO PRIVATO AI SERVIZI, nella sezione Intervalli IP allocati per i servizi, seleziona psa-range-database-net e l'opzione Rilascia.

7. Poi seleziona PEERING DI RETE VPC,seleziona servicenetworking-googleapis-com e l'opzione Elimina.

8. Poi seleziona Elimina rete VPC

12. Complimenti

Congratulazioni, hai configurato correttamente un'istanza Cloud SQL con PSA e collegamento PSC e hai creato un endpoint Private Service Connect in un altro VPC.

Scopri di più

Puoi scoprire di più su Private Service Connect e Cloud SQL.

Altro codelab correlato: https://codelabs.developers.google.com/codelabs/cloudsql-psc-terraform