1. Panoramica
Esistono diverse opzioni per connettersi a un'istanza Cloud SQL privata da un altro progetto o da una rete VPC. Puoi utilizzare l'accesso privato ai servizi (PSA) per raggiungere gli indirizzi IP interni di Google e di servizi di terze parti tramite connessioni private. Per estendere l'accesso al database, ora puoi anche attivare 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 e/o backend PSC nel proprio ambiente. Tramite questi endpoint PSC, possono connettersi ai servizi del produttore tramite un IP privato specificato dall'utente.
In questo lab puoi configurare e testare l'opzione.
In questo lab, creerai un'architettura semplice che illustra l'utilizzo dell'accesso agli endpoint PSA e PSC con CloudSQL.
Figura 1.
Per questo lab, avrai bisogno di due progetti o di VPC separati nello stesso progetto.
Obiettivi
In questo lab imparerai a:
- Attivare la rete di servizi
- Configurare PSA
- Creare un'istanza CloudSQL con PSA
- Attiva il collegamento del servizio PSC.
- Crea un endpoint PSC nella VPC del consumatore per connetterti al database CloudSQL
- Verifica l'accesso al database SQL dalle VM di test, sia nei VPC producer che in quelli consumer
2. Configurazione e requisiti
Configurazione dell'ambiente a tuo ritmo
- 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 al progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco per tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca; di solito non ti interessa quale sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come
PROJECT_ID
). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare il tuo e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane invariato per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un Numero progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le API/risorse Cloud. La partecipazione a questo codelab non ha costi, o quasi. Per arrestare le risorse ed evitare di incorrere in fatturazione al termine di questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud sono idonei al programma Prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere utilizzato 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:
Dovrebbero bastare pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere qualcosa di simile a questo:
Questa macchina virtuale contiene tutti gli strumenti di sviluppo 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 di rete. Tutto il lavoro in questo codelab può essere svolto in un browser. Non devi installare nulla.
3. Attività 1: Configura l'ambiente per il progetto di database con (Terraform)
Nel progetto del database, abiliteremo la rete di servizi, creeremo un VPC, creeremo un intervallo PSA, creeremo un peering di rete di servizi e creeremo regole firewall. Apri la console Cloud e seleziona il progetto che utilizzerai per il database.
- Apri Cloud Shell in alto a destra nella console, assicurati di vedere l'ID progetto del database per il progetto del database in Cloud Shell, conferma eventuali richieste di autorizzazione di accesso.
- Crea una cartella denominata terraform-db-psc e spostati nella cartella
mkdir terraform-db-psc && cd terraform-db-psc
- Crea i file main.tf, variable.tf, nat-vm.tf e database.tf.
touch main.tf variable.tf nat-vm.tf database.tf
- Passa alla visualizzazione dell'editor di Cloud Shell. Seleziona editor, assicurati di consentire eventuali richieste necessarie per il caricamento dell'interfaccia.
- Una volta caricato, vai a File > Apri cartella e vai a /home/tuo-nome-utente/terraform-db-psc e seleziona Ok per aprire la cartella nell'editor.
- 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 testoyour-consumer-project-id-here
con l'ID effettivo del progetto consumer 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" }
- A questo punto, apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.
Abilita le API |
|
Crea VPC |
|
Aggiungi regole firewall |
|
Creare un intervallo di PSA |
|
Creare un peering |
|
- 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 }
- Torna al terminal Cloud Shell, assicurati di essere 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 necessari per la configurazione specificata.
terraform plan
Genera un piano di esecuzione che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.
- Ora, per creare le risorse, esegui il comando
terraform apply
e digitayes
per eseguirlo.
4. Attività 2: Creare un'istanza CloudSQL con PSA (Terraform)
Utilizziamo Terraform per creare un'istanza CloudSQL con l'opzione PSA per consentire la connettività. Completa questa configurazione nel progetto del database.
- Passa alla visualizzazione dell'editor di Cloud Shell. Assicurati di trovarti nella cartella
terraform-db-psc
. Seleziona il filedatabase.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
}
- Torna al terminal Cloud Shell e assicurati di trovarti nella directory terraform-db-psc. Ora, per creare le risorse, esegui il comando
terraform apply
e digitayes
per eseguirlo. La creazione dell'istanza CloudSQL con PSA potrebbe richiedere più di 15 minuti.
Verificare il database
- Al termine, vai a SQL nella console e seleziona l'istanza di database psc-psa-sql-db appena creata.
- A sinistra, espandi il riquadro popup delle opzioni SQL e seleziona Connessioni.
- Nella scheda Riepilogo puoi visualizzare le informazioni sulla connessione.
- Copia l'indirizzo IP interno e salvalo da qualche parte sul tuo sistema. Come puoi vedere, è stato assegnato dall'intervallo che abbiamo riservato.
- Ti servirà questo indirizzo IP per completare il passaggio 5 dell'attività 3.
- A sinistra, espandi il riquadro popup delle opzioni SQL e seleziona Utenti.
- Dovresti vedere un utente chiamato testsql con password cloudsql24 (che verrà utilizzato per accedere al database in un secondo momento)
5. Attività 3: Crea una VM di test e connettiti all'istanza SQL dal progetto del database (Terraform)
Utilizziamo Terraform per creare una VM di test e un gateway NAT. Completa questa configurazione nel progetto del database.
- Passa alla visualizzazione dell'editor di Cloud Shell. Assicurati di trovarti nella cartella
terraform-db-psc
. Seleziona il filenat-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
}
- Torna al terminal 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 digitayes
per eseguirlo. Verranno creati un gateway NAT e una VM con MariaDB installato.
Verificare il database
Completa questa operazione nel progetto consumer
- Vai a Istanza VM. Seleziona db-vm-test.
- Seleziona l'opzione SSH per connetterti alla VM.
- 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. Cambia l'indirizzo IP con il tuo indirizzo IP attuale per la connessione.
- Una volta stabilita la connessione, crea un database con il seguente localvpcsqldb.
CREATE DATABASE localvpcsqldb;
- Al termine, digita exit per uscire dalla connessione. Digita di nuovo exit per chiudere la VM.
6. Attività 4: Abilita PSC nell'istanza CloudSQL
Utilizziamo i comandi gcloud per attivare l'opzione PSC per consentire la connettività. Completa questa configurazione nel progetto del database.
- Passa alla visualizzazione Cloud Shell.
- Esegui il comando riportato di seguito in Cloud Shell.
- Sostituisci Assicurati che
YOUR_DB_PROJECT_HERE
con l'ID progetto del database. - Sostituisci Assicurati che
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
- Il database esistente verrà aggiornato con l'allegato PSC. L'operazione richiederà più di 10 minuti.
Se ricevi un errore di attesa per timeout, dovresti anche ricevere il comando per continuare a visualizzare l'avanzamento. Ad esempio "Puoi continuare ad attendere l'operazione eseguendo "gcloud beta sql operations wait –project"
Tieni presente che puoi implementare un nuovo database con PSA e PSC abilitati fin dall'inizio.
Verificare il database
- Al termine, vai a SQL nella console e seleziona l'istanza di database psc-psa-sql-db.
- A sinistra, espandi il riquadro popup delle opzioni SQL e seleziona Connessioni.
- Nella scheda Riepilogo puoi visualizzare le informazioni sulla connessione.
- Copia l'indirizzo dell'Allegato del servizio e salvalo da qualche parte sul tuo sistema.
- Ne avrai bisogno per completare l'attività successiva 5, passaggio 8.
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.
- Nella parte superiore della console, a destra accanto all'icona di Google Cloud, fai clic sul menu a discesa e seleziona la scheda Tutti.
- Per continuare, seleziona l'ID del tuo progetto consumer tra i progetti elencati.
- Apri Cloud Shell in alto a destra nella console, assicurati di vedere l'ID progetto consumer in Cloud Shell e conferma eventuali richieste per consentire l'accesso.
- Crea una cartella denominata terraform-consumer-psc e spostati nella cartella
mkdir terraform-consumer-psc && cd terraform-consumer-psc
- Crea i file main.tf, variable.tf e psc.tf.
touch main.tf variable.tf psc.tf
- Passa alla visualizzazione dell'editor Cloud Shell per l'ID progetto consumer. Seleziona editor, assicurati di consentire eventuali richieste necessarie per il caricamento dell'interfaccia.
- Una volta caricato, vai a File > Apri cartella e vai a /home/tuo-nome-utente/terraform-consumer-psc e seleziona Ok per aprire la cartella nell'editor.
- 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 testoyour-psc-attachment-id-here
con l'indirizzo dell'allegato psc tra virgolette. Si tratta dell'ID che hai copiato nella sezione 5-7 della 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" }
- A questo punto, apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.
Abilita le API |
|
Crea VPC |
|
Crea gateway NAT |
|
Aggiungi regole firewall |
|
- 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"] }
- 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 necessari per la configurazione specificata.
terraform plan
Genera un piano di esecuzione che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura.
- Ora, per creare le risorse, esegui il comando
terraform apply
e digitayes
per eseguirlo.
8. Attività 6: Crea l'endpoint PSC per l'attacco al database SQL nel progetto consumer e testa la VM (Terraform)
Completa questa configurazione nel progetto consumer.
- 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. Verranno creati un IP interno statico, un endpoint PSC e una VM di test con Maria DB 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 }
- 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.
- Ora, per creare le risorse, esegui il comando
terraform apply
e digitayes
per eseguire
9. Attività 7: Verifica la connettività dell'endpoint dalla VM tramite l'indirizzo IP del PSC
Completa questa operazione nel progetto consumer
- Vai a Istanza VM. Seleziona remote-sql-test-vm
- Seleziona l'opzione SSH per connetterti alla VM.
- Connettiti al database tramite endpoint con quanto segue:
mysql --host=192.168.100.100 --user=testsql --password=cloudsql24
- Una volta stabilita la connessione, crea un database con il seguente psc-sql-db.
CREATE DATABASE remotepscpsasqldb;
- Al termine, digita exit per uscire dalla connessione. Digita di nuovo exit per chiudere la VM.
10. Attività 8: Verificare l'inserimento nel database
Completa questa verifica nel progetto del database
- Nella parte superiore della console, a destra accanto all'icona di Google Cloud, fai clic sul menu a discesa e seleziona la scheda Tutti.
- Dai progetti elencati, seleziona l'ID progetto del database per continuare.
- Vai a SQL, seleziona il database psc-psa-sql-db, espandi le opzioni SQL e seleziona Database. Dovresti vedere il database appena creato denominato remotepscpsasqldb dalla VM del progetto consumer e anche localvpcsqldb dalla VM del progetto del database**
.
**
11. Esegui la pulizia
Completa questa operazione nel progetto consumer
- Seleziona l'ID progetto consumer
- Vai a Cloud Shell e assicurati di vedere l'ID progetto consumer
- Vai alla directory terraform-consumer-psc
cd terraform-consumer-psc
ed esegui il seguente comandoterraform destroy
e digitayes
. Tutte le risorse che hai creato nel progetto consumer con Terraform verranno rimosse.
Completa questa operazione nel progetto Database
- Seleziona l'ID progetto del database
- Vai a Cloud Shell e assicurati di vedere l'ID progetto del database
- Vai alla directory terraform-db-psc
cd terraform-db-psc
ed esegui il seguente comandoterraform destroy
e digitayes
la maggior parte delle risorse che hai creato nel progetto DB con Terraform verrà rimossa. La rete di servizi potrebbe non essere eliminata e restituire un errore. - Successivamente, elimina i seguenti file dalla cartella terraform-db-psc.
rm -r terraform.tfstate terraform.tfstate.backup
- Nella console, vai a Reti VPC.
- Seleziona il VPC database-net, seleziona ACCESSO PRIVATO AI SERVIZI, in Intervalli IP allocati per i servizi, seleziona psa-range-database-net e seleziona l'opzione Rilascia
- Quindi seleziona PEERING DI RETE VPC,servicenetworking-googleapis-com e l'opzione Elimina.
- Quindi, seleziona Elimina rete VPC
.
12. Complimenti
Congratulazioni, hai configurato correttamente un'istanza Cloud SQL con il collegamento a PSA e PSC e hai creato un endpoint Private Service Connect in un'altra 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