Connessione a CloudSQL tramite Private Service Connect (Terraform)

1. Panoramica

Esistono diverse opzioni per connettersi a un'istanza Cloud SQL privata da un altro progetto o da VPC. Private Service Connect (PSC) consente ai producer di servizi di esporre i propri servizi tramite i collegamenti di servizio. Questi collegamenti di servizio possono essere utilizzati dai consumer per creare endpoint e/o backend PSC nel proprio ambiente e connettersi a questi servizi di produzione tramite un IP privato specificato.

Cloud SQL ha la possibilità di utilizzare il collegamento a un servizio PSC per consentire la connessione privata. In questo lab puoi configurare e testare l'opzione.

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

In questo lab, creerai un'architettura semplice che illustra l'utilizzo dell'accesso all'endpoint PSC con CloudSQL.

Figura 1.

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

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

Obiettivi

In questo lab imparerai a:

• Crea un'istanza CloudSQL con il collegamento a un servizio PSC.
• Creare un indirizzo IP statico
• Crea un endpoint PSC nella VPC del consumatore per connetterti al database CloudSQL
• Verifica l'accesso al database SQL da una VM di test nella rete del consumatore tramite l'indirizzo IP dell'endpoint PSC.

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

2. Configurazione e requisiti

Configurazione dell'ambiente a tuo ritmo

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

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

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

2. 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: Configurare l'ambiente per il progetto di database con (Terraform)

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

Nel progetto del database,creeremo un VPC personalizzato con regole firewall e subnet. 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 vedere l'ID progetto del database per il progetto del database in Cloud Shell, conferma eventuali richieste di autorizzazione di accesso.
2. Crea una cartella denominata terraform-db e spostati nella cartella

mkdir terraform-db  && cd terraform-db

3. Crea i file main.tf, variable.tf e database.tf.

touch main.tf variable.tf database.tf 

4. Passa alla visualizzazione dell'editor di Cloud Shell. Seleziona editor, assicurati di consentire eventuali richieste necessarie per il caricamento dell'interfaccia.
5. Una volta caricato, vai a File > Apri cartella e vai a /home/tuo-nome-utente/terraform-db 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 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"
}

7. Apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.

Abilita le API	resource "google_project_service" "default"
Crea VPC	resource "google_compute_network" "default"
Aggiungi regole firewall	resource "google_compute_firewall" "allow_icmp"

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

resource "google_project_service" "default" {
  for_each = toset([
    "compute.googleapis.com",
    "sqladmin.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_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"]
 }

9. Torna al terminal Cloud Shell, assicurati di trovarti nella directory terraform-db cd terraform-db 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.

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

Verifica la configurazione:

Controlla il tuo ambiente per verificare

1 VPC in modalità automatica denominata database-net

Firewall-rules

4. Attività 2: Crea un'istanza CloudSQL con allegato PSC (Terraform)

Utilizziamo Terraform per creare un'istanza CloudSQL con l'opzione PSC per consentire la connettività. Completa questa configurazione nel progetto del database.

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

resource "google_sql_database_instance" "default" {
  name             = "psc-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 {
      psc_config {
        psc_enabled               = true
        allowed_consumer_projects = var.project_id_consumer
      }
      ipv4_enabled = false
    }
  }
  deletion_protection = false 
}

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

2. Torna al terminal Cloud Shell e assicurati di essere nella directory terraform-db. Ora, per creare le risorse, esegui il comando terraform apply e digita yes per eseguire. La creazione dell'istanza CloudSQL con allegato PSC può richiedere fino a 5 minuti o più.

Verificare il database

3. Al termine, vai a SQL nella console e seleziona l'istanza di database psc-sql-db appena creata.
4. A sinistra, espandi il riquadro popup delle opzioni SQL e seleziona Connessioni.
5. Nella scheda Riepilogo puoi visualizzare le informazioni sulla connessione.
6. Copia l'indirizzo dell'allegato del servizio e salvalo da qualche parte sul tuo sistema.
7. Ti servirà per completare il passaggio 8 dell'attività 3.

8. A sinistra, espandi il riquadro popup delle opzioni SQL e seleziona Utenti.
9. Dovresti vedere un utente chiamato testsql con password cloudsql24 (che verrà utilizzato per accedere al database in un secondo momento)

Verifica la configurazione:

1 istanza di database SQL con collegamento a un servizio

1 utente denominato testsql e password cloudsql24

5. Attività 3: 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. Per continuare, seleziona l'ID del tuo progetto consumer tra i progetti elencati.
3. 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.
4. Crea una cartella denominata terraform-consumer e spostati nella cartella

mkdir terraform-consumer  && cd terraform-consumer

5. Crea i 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, assicurati di consentire eventuali richieste necessarie per il caricamento dell'interfaccia.
7. Una volta caricato, vai a File > Apri cartella e vai a /home/tuo-nome-utente/terraform-consumer 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 2-5 della task 2

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-net"
}

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

variable "region_id2" {
  type = string
  default = "us-central1"
}

9. Apri il file main.tf. Aggiungeremo del codice Terraform per eseguire varie azioni, come spiegato di seguito.

Abilita le API	resource "google_project_service"
Crea VPC	resource "google_compute_network"
Crea gateway NAT	resource "google_compute_router" resource "google_compute_router_nat"
Aggiungi 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" {
  name          = "vm-subnet"
  ip_cidr_range = "192.168.50.0/24"
  region        = var.region_id2
  network       = google_compute_network.default.name
  project       = var.project_id
}

resource "google_compute_subnetwork" "psc_subnet" {
  name          = "psc-subnet"
  ip_cidr_range = "192.168.90.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_id2
  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 terminal Cloud Shell, assicurati di trovarti nella directory terraform-consumer cd terraform-consumer 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.

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

Verifica la configurazione:

Controlla il tuo ambiente per verificare

1 VPC personalizzata denominata psc-endpoint-net

Gateway NAT con regole firewall

6. Attività 4: Crea l'endpoint PSC per l'attacco al database SQL nel progetto consumer e testa la VM (Terraform)

Completa questa configurazione nel progetto consumer.

1. Torna all'editor di Cloud Shell, apri la directory terraform-consumer 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"
  region = var.region_id
  address_type = "INTERNAL"
  subnetwork = google_compute_subnetwork.psc_subnet.name
  address = "192.168.90.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         = "sql-test-vm"
  machine_type = "e2-medium"
  zone         = "${var.region_id2}-b"
  project      = var.project_id

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

  network_interface {
    subnetwork = google_compute_subnetwork.vm_subnet.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 terminal Cloud Shell, assicurati di trovarti nella directory terraform-consumer cd terraform-consumer 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
4. Poiché la VM e l'endpoint si trovano in regioni diverse, dobbiamo attivare l'accesso globale sull'endpoint PSC. Lo facciamo tramite la console
5. Nella console del progetto consumer, vai a Private Service Connect. Nella scheda Endpoint connesso, cerca la sezione Endpoint e seleziona psc-sql-endpoint.
6. Ora seleziona MODIFICA,quindi fai clic sulla casella di controllo accanto ad Abilita l'accesso globale e all'opzione Salva.
7. Vai al passaggio successivo per verificare la connettività

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

Completa questa operazione nel progetto consumer

1. Vai a Istanza VM. Seleziona sql-test-vm
2. Seleziona l'opzione SSH per connetterti alla VM.
3. Connettiti al database tramite endpoint con quanto segue:

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

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

CREATE DATABASE remotesqldb;

5. Al termine, digita exit per uscire dalla connessione.

8. Attività 6: Verificare la voce del database

Completa questa verifica nel progetto del 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. Dai progetti elencati, seleziona l'ID progetto del database per continuare.
3. Vai a SQL, seleziona il database psc-sql-db, espandi le opzioni SQL e seleziona Database. Dovresti vedere il database appena creato denominato remotesqldb dalla VM del progetto consumer**.**

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

9. Esegui la pulizia

Esegui la pulizia per evitare addebiti non necessari.

Completa questa operazione nel progetto Database

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

Completa questa operazione nel progetto consumer

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

10. Complimenti

Congratulazioni, hai configurato correttamente un'istanza Cloud SQL con il collegamento a PSC e hai creato un endpoint Private Service Connect in un'altra VPC. Hai potuto connetterti correttamente al database da una VM remota tramite l'endpoint PSC.

Scopri di più

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