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 em outro projeto ou rede VPC. É possível usar o Acesso a serviços privados (PSA) para acessar os endereços IP internos do Google e de serviços de terceiros usando conexões particulares. Para estender o acesso ao banco de dados, agora você também pode ativar o Private Service Connect (PSC).

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

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

Observação:há algumas limitações para essa solução. Você pode conferir essas informações na seção limitação do Private Service Connect da documentação.

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

Figura 1.

Para este laboratório, você vai precisar de dois projetos ou VPCs separados 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 a rede de serviços
• Configurar a PSA
• Criar uma instância do CloudSQL 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 CloudSQL
• Verifique o acesso ao banco de dados SQL nas VMs de teste, nas VPCs de produtor e de 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 do banco de dados com o Terraform

Alguns recursos ativados vão ter custos. Para reduzir custos, confirme 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 de cima do console, à direita. Verifique se o ID do projeto do banco de dados aparece para o projeto do banco de dados no Cloud Shell. Confirme todos os avisos para permitir o acesso.
2. Crie uma pasta chamada terraform-db-psc e mova para a pasta

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

3. Crie um arquivo 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 as solicitações necessárias para que a interface possa ser carregada.
5. Depois de carregar, navegue até File > Open Folder e acesse /home/your-user-name/terraform-db-psc e 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 real entre aspas. Substitua o texto your-consumer-project-id-here pelo ID do seu projeto de consumidor real 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 as APIs	resource "google_project_service" "default"
Criar VPC	resource "google_compute_network" "default"
Adicionar regras de firewall	resource "google_compute_firewall" "allow_icmp"
Criar 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, verifique se você está no diretório cd terraform-db-psc terraform-db-psc e execute os comandos a seguir.

terraform init

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

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:

Verificar se o ambiente tem um intervalo de IP PSA pareado com rede VPC ativada para rede de serviços alocado

VPC de modo automático chamada database-net criada

Regras de firewall criadas

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

Vamos usar o Terraform para criar uma instância do CloudSQL com a opção PSA para permitir a conectividade. Conclua essa configuração no projeto do 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 verifique 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 CloudSQL com o PSA pode levar mais de 15 minutos.

Verificar o banco de dados

3. Após a conclusão, acesse SQL no console e selecione a instância de banco de dados psc-psa-sql-db recém-criada.
4. No lado esquerdo, abra o menu suspenso de opções do SQL e selecione Conexões.
5. Na guia "Resumo", você pode conferir informações sobre a conexão.
6. Copie o endereço IP interno e salve-o 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. No lado esquerdo, abra o menu suspenso de opções do SQL e selecione Usuários.
9. Um usuário chamado testsql com a senha cloudsql24 (que 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 do 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 verifique 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 o 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 pelo 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 encerrar a 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 CloudSQL

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

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

• Substitua YOUR_DB_PROJECT_HERE pelo ID do projeto do banco de dados.
• Substitua 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 com o anexo do PSC. Isso vai levar mais de 10 minutos.

Se você receber um erro de tempo limite de espera, o comando também vai ser exibido para continuar a ver 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 PSA e PSC ativados desde o início.

Verificar o banco de dados

4. Depois de concluir, acesse SQL no console e selecione a instância de banco de dados psc-psa-sql-db.
5. No lado esquerdo, abra o menu suspenso de opções do SQL e selecione Conexões.
6. Na guia "Resumo", você pode conferir informações sobre a conexão.
7. Copie o endereço do Anexo do serviço e salve-o em algum lugar do seu sistema.
8. Você vai precisar dele para concluir a próxima tarefa 5, etapa 8.

Verifique sua configuração:

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

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

No projeto do 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 do ícone do Google Cloud, clique no menu suspenso e selecione a guia todos.

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

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 as solicitações necessárias para que a interface possa ser carregada.
7. Depois de carregar, navegue até File > Open Folder e acesse /home/your-user-name/terraform-consumer-psc e 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 seu ID do projeto do consumidor real entre aspas. Substitua o texto your-psc-attachment-id-here pelo endereço de anexo do PSC entre aspas. Este é o ID que você copiou na tarefa 4, seção 5-7

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 as 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, verifique se você está no diretório cd terraform-consumer-psc terraform-consumer-psc no projeto do consumidor e execute os comandos a seguir.

terraform init

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

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 se o ambiente:

Uma VPC personalizada chamada psc-endpoint-vpc

Gateway NAT de regras de firewall

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

Conclua essa configuração no projeto do consumidor.

1. Volte para o 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, verifique se você está no diretório cd terraform-consumer-psc terraform-consumer-psc no projeto do consumidor e execute os comandos a seguir.

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 pelo 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 DB pelo 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 encerrar a 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 de banco de dados.

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

2. Nos projetos listados, selecione o ID do projeto do banco de dados para continuar.
3. Navegue até 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, deve aparecer na VM do projeto do consumidor e também no localvpcsqldb da VM do projeto do banco de dados**.**

Observação:também é possível se conectar usando um nome DNS. Saiba mais sobre a configuração do DNS neste link.

11. Limpeza

Faça uma limpeza para evitar cobranças desnecessárias.

Conclua isso no projeto de consumidor

1. Selecione o ID do projeto do consumidor
2. Acesse o Cloud Shell e verifique se o ID do projeto do consumidor está disponível.
3. Acesse o diretório terraform-consumer-psc cd terraform-consumer-psc e execute o comando terraform destroy a seguir e digite yes. Todos os recursos que você criou no projeto do consumidor com o Terraform serão removidos.

Conclua isso no projeto do banco de dados

1. Selecione o ID do projeto do 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 a seguir e digite yes. A maioria dos recursos que você criou no projeto do banco de dados com o Terraform será removida. A rede de serviços pode não ser excluída e gerar um erro.
4. Em seguida, exclua os seguintes arquivos da pasta terraform-db-psc.

rm -r terraform.tfstate terraform.tfstate.backup

5. Em seguida, acesse Redes VPC no console.
6. Selecione a VPC database-net, selecione 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 VPC NETWORK PEERING, servicenetworking-googleapis-com e a opção Delete.

8. Em seguida, selecione Excluir rede VPC

12. Parabéns

Parabéns! Você configurou uma instância do Cloud SQL com anexos de PSA e 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