Ativar o Private Service Connect em uma instância do Cloud SQL com PSA (Terraform)

1. Visão geral

Há várias opções para se conectar a uma instância privada do Cloud SQL de outro projeto ou rede VPC. É possível usar o acesso a serviços particulares (PSA, na sigla em inglês) para acessar os endereços IP internos de serviços do Google e de terceiros por conexões particulares. Para estender o acesso ao banco de dados, agora também é possível ativar o Private Service Connect (PSC).

O Private Service Connect (PSC) permite que os produtores de serviços exponham os serviços deles por anexos de serviço, que os consumidores podem usar para criar endpoints e/ou back-ends do PSC no ambiente deles. Com esses endpoints do PSC, eles podem se conectar aos serviços do produtor usando um IP particular especificado pelo usuário.

Neste laboratório, você pode configurar e testar a opção.

Observação:há algumas limitações nessa solução. Consulte a seção Limitação do Private Service Connect na documentação.

Neste laboratório, você vai criar uma arquitetura simples que ilustra o uso do acesso a endpoints de PSA e PSC com o Cloud SQL.

Figura 1.

Para este laboratório, você vai precisar de dois projetos ou VPCs separadas no mesmo projeto.

Observação:o acesso global pode ser ativado no endpoint do PSC para disponibilizá-lo em outras regiões.

Objetivos

Neste laboratório, você vai aprender a fazer o seguinte:

• Ativar o Service Networking
• Configurar o PSA
• Criar uma instância do Cloud SQL com PSA
• Ative o anexo do serviço PSC.
• Crie um endpoint do PSC na VPC do consumidor para se conectar ao banco de dados do Cloud SQL.
• Verificar o acesso ao banco de dados SQL em VMs de teste, nas VPCs de produtor e consumidor

Observação:esse design pode ser usado por vários consumidores. Leia sobre a multitenância do Private Service Connect.

2. Configuração e requisitos

Configuração de ambiente autoguiada

1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

• O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
• Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Atenção: o ID do projeto é globalmente exclusivo e não pode ser usado por outras pessoas após a seleção. Você é o único usuário com esse ID. Mesmo que um projeto seja excluído, o ID não poderá ser usado novamente.

Observação: se você usa uma conta do Gmail, defina o local padrão como Sem organização. Se você usa uma conta do Google Workspace, escolha um local adequado para a organização.

2. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

3. Tarefa 1: Configurar o ambiente para o projeto de banco de dados com o Terraform

Alguns recursos ativados vão ter custos. Para reduzir custos, verifique se os recursos foram destruídos após a conclusão do laboratório. É recomendável conferir o faturamento e confirmar se o exercício é adequado para você.

No projeto de banco de dados, vamos ativar a rede de serviços, criar uma VPC, criar um intervalo de PSA, criar um peering de rede de serviços e criar regras de firewall. Abra o console do Cloud e selecione o projeto que você vai usar para o banco de dados.

1. Abra o Cloud Shell, localizado na parte superior direita do console. Verifique se o ID do projeto do banco de dados aparece no projeto do banco de dados no Cloud Shell e confirme todas as solicitações para permitir o acesso.
2. Crie uma pasta chamada terraform-db-psc e mova para ela.

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

3. Crie os arquivos main.tf, variable.tf, nat-vm.tf e database.tf.

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

4. Mude para a visualização do editor do Cloud Shell. Selecione editor e permita todas as solicitações necessárias para que a interface possa ser carregada.
5. Depois de carregado, navegue até Arquivo > Abrir pasta e acesse /home/your-user-name/terraform-db-psc. Selecione Ok para abrir a pasta no editor.
6. Selecione o arquivo variable.tf e adicione o seguinte. Substitua o texto your-database-project-id-here pelo ID do seu projeto de banco de dados entre aspas. Substitua o texto your-consumer-project-id-here pelo ID do seu projeto de consumidor entre aspas.

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. Em seguida, abra o arquivo main.tf. Vamos adicionar um código do Terraform para realizar várias ações, conforme explicado abaixo.

Ativar APIs	resource "google_project_service" "default"
Criar VPC	resource "google_compute_network" "default"
Adicionar regras de firewall	resource "google_compute_firewall" "allow_icmp"
Criar um intervalo de PSA	resource "google_compute_global_address" "psa_range"
Criar um peering	resource "google_service_networking_connection" "private_connection"

8. Copie e cole o seguinte no arquivo 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. Volte para o terminal do Cloud Shell, confira se você está no diretório terraform-db-psc cd terraform-db-psc e execute os comandos a seguir:

terraform init

Inicializa o diretório de trabalho. Essa etapa faz o download dos provedores necessários para a configuração especificada.

terraform plan

Gera um plano de execução, mostrando quais ações o Terraform vai realizar para implantar sua infraestrutura.

10. Agora, para criar os recursos, execute o comando terraform apply e digite yes para executar.

Verifique sua configuração:

Verifique se o intervalo de IP do PSA alocado na rede VPC com peering e rede de serviços está ativado no seu ambiente.

VPC de modo automático chamada "database-net" criada

Regras de firewall criadas

4. Tarefa 2: Criar uma instância do Cloud SQL com PSA (Terraform)

Vamos usar o Terraform para criar uma instância do Cloud SQL com a opção PSA para permitir a conectividade. Conclua essa configuração no projeto de banco de dados.

1. Mude para a visualização do editor do Cloud Shell. Verifique se você está na pasta terraform-db-psc. Selecione o arquivo database.tf e adicione o seguinte.

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. Volte para o terminal do Cloud Shell e confira se você está no diretório terraform-db-psc. Agora, para criar os recursos, execute o comando terraform apply e digite yes para executar. A criação da instância do Cloud SQL com PSA pode levar mais de 15 minutos.

Verificar banco de dados

3. Depois da conclusão, acesse SQL no console e selecione a instância de banco de dados psc-psa-sql-db recém-criada.
4. À esquerda, expanda o painel de opções do SQL e selecione Conexões.
5. Na guia "Resumo", você encontra informações sobre a conexão.
6. Copie o endereço IP interno e salve em algum lugar do sistema. Como você pode ver, ele foi atribuído do intervalo que reservamos.
7. Você vai precisar desse IP para concluir a etapa 5 da tarefa 3.

8. À esquerda, abra o painel lateral de opções do SQL e selecione Usuários.
9. Você vai encontrar um usuário chamado testsql com a senha cloudsql24 (será usada para acessar o banco de dados mais tarde)

Verifique sua configuração:

1 instância de banco de dados SQL com IP particular

1 usuário chamado testsql e senha cloudsql24

5. Tarefa 3: Criar uma VM de teste e se conectar à instância do SQL no projeto do banco de dados (Terraform)

Vamos usar o Terraform para criar uma VM de teste e um gateway NAT. Conclua essa configuração no projeto de banco de dados.

1. Mude para a visualização do editor do Cloud Shell. Verifique se você está na pasta terraform-db-psc. Selecione o arquivo nat-vm.tf e adicione o seguinte.

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. Volte para o terminal do Cloud Shell e confira se você está no diretório terraform-db-psc. Agora, para criar os recursos, execute o comando terraform plan, then terraform apply e digite yes para executar. Isso vai criar um gateway NAT e uma VM com o MariaDB instalado.

Verificar banco de dados

Conclua isso no projeto do consumidor

3. Acesse Instância de VM. Selecione db-vm-test.
4. Selecione a opção SSH para se conectar à VM.
5. Conecte-se ao banco de dados usando o IP local que você copiou antes com o seguinte:

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

Observação: mude o endereço IP para o seu IP real para que ele se conecte.

6. Quando a conexão for estabelecida, crie um banco de dados com o seguinte localvpcsqldb.

CREATE DATABASE localvpcsqldb;

7. Quando terminar, digite "exit" para sair da conexão. Digite "exit" novamente para fechar a VM.

Verifique sua configuração:

1 gateway NAT

Uma VM chamada db-vm-test

6. Tarefa 4: Ativar o PSC na instância do Cloud SQL

Vamos usar comandos gcloud para ativar a opção PSC e permitir a conectividade. Conclua essa configuração no projeto de banco de dados.

1. Mude para a visualização do Cloud Shell.
2. Execute o seguinte comando no Cloud Shell:

• Substitua Ensure YOUR_DB_PROJECT_HERE pelo ID do projeto do banco de dados.
• Substitua Ensure YOUR_CONSUMER_PROJECT_HERE pelo ID do projeto do consumidor.

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. Isso vai atualizar o banco de dados atual com a vinculação do PSC. Isso vai levar um tempo (mais de 10 minutos).

Se você receber um erro de tempo limite de espera, também vai receber o comando para continuar acompanhando o progresso. Algo como "Você pode continuar aguardando a operação executando `gcloud beta sql operations wait –project "

É possível implantar um novo banco de dados com o PSA e o PSC ativados desde o início.

Verificar banco de dados

4. Depois da conclusão, acesse SQL no console e selecione a instância de banco de dados psc-psa-sql-db.
5. À esquerda, expanda o painel de opções do SQL e selecione Conexões.
6. Na guia "Resumo", você encontra informações sobre a conexão.
7. Copie o endereço do Anexo de serviço e salve em algum lugar do seu sistema.
8. Você vai precisar disso para concluir a próxima tarefa 5, etapa 8.

Verifique sua configuração:

1 instância de banco de dados SQL com vinculação de serviço

7. Tarefa 5: Configurar o ambiente para o projeto do consumidor (Terraform)

No projeto consumidor,vamos criar uma VPC personalizada com regras de firewall e sub-rede. Abra o console do Cloud e selecione o projeto que você vai usar.

1. Na parte de cima do console, à direita, ao lado do ícone do Google Cloud, clique no menu suspenso e selecione a guia all.

2. Na lista de projetos, selecione o ID do seu projeto consumidor para continuar.
3. Abra o Cloud Shell, localizado na parte superior direita do console. Verifique se o ID do projeto do consumidor aparece no Cloud Shell e confirme todas as solicitações para permitir o acesso.
4. Crie uma pasta chamada terraform-consumer-psc e mova para ela.

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

5. Crie um arquivo main.tf, variable.tf e psc.tf.

touch main.tf variable.tf psc.tf 

6. Mude para a visualização do editor do Cloud Shell para o ID do projeto do consumidor. Selecione editor e permita todas as solicitações necessárias para que a interface possa ser carregada.
7. Depois de carregado, navegue até Arquivo > Abrir pasta e acesse /home/your-user-name/terraform-consumer-psc. Selecione Ok para abrir a pasta no editor.
8. Selecione o arquivo variable.tf e adicione o seguinte. Substitua o texto your-consumer-project-id-here pelo ID do projeto do consumidor entre aspas. Substitua o texto your-psc-attachment-id-here pelo endereço do anexo do PSC entre aspas. Esse é o ID que você copiou na seção 5 a 7 da tarefa 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. Em seguida, abra o arquivo main.tf. Vamos adicionar um código do Terraform para realizar várias ações, conforme explicado abaixo.

Ativar APIs	resource "google_project_service"
Criar VPC	resource "google_compute_network"
Criar gateway NAT	resource "google_compute_router" resource "google_compute_router_nat"
Adicionar regras de firewall	resource "google_compute_firewall"

10. Copie e cole o seguinte no arquivo 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. Volte para o terminal do Cloud Shell, confira se você está no diretório terraform-consumer-psc cd terraform-consumer-psc no projeto consumidor e execute os seguintes comandos:

terraform init

Inicializa o diretório de trabalho. Essa etapa faz o download dos provedores necessários para a configuração especificada.

terraform plan

Gera um plano de execução, mostrando quais ações o Terraform vai realizar para implantar sua infraestrutura.

12. Agora, para criar os recursos, execute o comando terraform apply e digite yes para executar.

Verifique sua configuração:

Verifique seu ambiente para

Uma VPC personalizada chamada psc-endpoint-vpc

Gateway NAT de regras de firewall

8. Tarefa 6: Crie o endpoint do PSC para o anexo do banco de dados SQL no projeto do consumidor e teste a VM (Terraform)

Conclua essa configuração no projeto do consumidor.

1. Volte ao editor do Cloud Shell, abra o diretório terraform-consumer-psc e selecione o arquivo psc.tf. Adicione o seguinte código do Terraform ao arquivo. Isso cria um IP interno estático, um endpoint do PSC e uma VM de teste com o Maria DB instalado.

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. Volte para o terminal do Cloud Shell, confira se você está no diretório terraform-consumer-psc cd terraform-consumer-psc no projeto consumidor e execute os seguintes comandos:

terraform plan

Gera um plano de execução, mostrando quais ações o Terraform vai realizar para implantar sua infraestrutura.

3. Agora, para criar os recursos, execute o comando terraform apply e digite yes para executar.

9. Tarefa 7: Verificar a conectividade do endpoint da VM usando o endereço IP do PSC

Conclua isso no projeto do consumidor

8. Acesse Instância de VM. Selecione remote-sql-test-vm.
9. Selecione a opção SSH para se conectar à VM.
10. Conecte-se ao banco de dados via endpoint com o seguinte:

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

11. Quando a conexão for estabelecida, crie um banco de dados com o seguinte psc-sql-db.

CREATE DATABASE remotepscpsasqldb;

12. Quando terminar, digite "exit" para sair da conexão. Digite "exit" novamente para fechar a VM.

10. Tarefa 8: Verificar a entrada do banco de dados

Conclua essa verificação no projeto do banco de dados.

1. Na parte de cima do console, à direita, ao lado do ícone do Google Cloud, clique no menu suspenso e selecione a guia all.

2. Selecione o ID do projeto do banco de dados na lista para continuar.
3. Acesse SQL, selecione o banco de dados psc-psa-sql-db, expanda as opções de SQL e selecione Bancos de dados. O banco de dados que você acabou de criar chamado remotepscpsasqldb vai aparecer na VM do projeto consumidor e também o localvpcsqldb na VM do projeto de banco de dados**.**

Observação:também é possível se conectar usando um nome DNS. Leia mais sobre como configurar o DNS Configure uma zona gerenciada de DNS e um registro DNS.

11. Limpeza

Libere espaço para evitar cobranças desnecessárias.

Conclua isso no projeto do consumidor

1. Selecione o ID do projeto do consumidor
2. Acesse o Cloud Shell e verifique se o ID do projeto consumidor aparece.
3. Acesse o diretório terraform-consumer-psc cd terraform-consumer-psc e execute o comando terraform destroy. Digite yes. Todos os recursos criados no projeto consumidor com o Terraform serão removidos.

Conclua isso no projeto do banco de dados

1. Selecione o ID do projeto de banco de dados
2. Acesse o Cloud Shell e verifique se o ID do projeto do banco de dados aparece.
3. Acesse o diretório terraform-db-psc cd terraform-db-psc e execute o comando terraform destroy. Digite yes. A maioria dos recursos criados no projeto de banco de dados com o Terraform será removida. A rede de serviços não pode ser excluída e gera um erro.
4. Em seguida, exclua os seguintes arquivos da pasta terraform-db-psc.

rm -r terraform.tfstate terraform.tfstate.backup

5. Em seguida, no console, acesse Redes VPC.
6. Selecione a VPC database-net, ACESSO A SERVIÇOS PARTICULARES. Em Intervalos de IP alocados para serviços, selecione psa-range-database-net e a opção Liberar.

7. Em seguida, selecione PEERING DE REDE VPC, servicenetworking-googleapis-com e Excluir.

8. Em seguida, selecione Excluir rede VPC .

12. Parabéns

Parabéns! Você configurou uma instância do Cloud SQL com PSA e anexo do PSC e criou um endpoint do Private Service Connect em outra VPC.

Saiba mais

Leia mais sobre o Private Service Connect e o Cloud SQL.

Outro codelab relacionado: https://codelabs.developers.google.com/codelabs/cloudsql-psc-terraform