Habilita Private Service Connect en una instancia de Cloud SQL existente que ejecute PSA (Terraform)

1. Descripción general

Existen varias opciones para conectarse a una instancia privada de Cloud SQL desde otro proyecto o red de VPC. Puedes usar el acceso privado a los servicios (PSA) para acceder a las direcciones IP internas de los servicios de Google y de terceros a través de conexiones privadas. Para extender el acceso a la base de datos, ahora también puedes habilitar Private Service Connect (PSC).

Private Service Connect (PSC) permite a los productores de servicios exponer sus servicios a través de adjuntos de servicio, que los consumidores pueden usar para crear extremos o backends de PSC en su entorno. A través de estos extremos de PSC, pueden conectarse a los servicios del productor a través de una IP privada especificada por el usuario.

En este lab, puedes configurar y probar la opción.

Nota: Esta solución tiene algunas limitaciones. Puedes revisarlas en la sección Limitaciones de Private Service Connect de la documentación.

En este lab, crearás una arquitectura simple que ilustre el uso del acceso a extremos de PSA y PSC con CloudSQL.

Figura 1.

Para este lab, necesitarás dos proyectos o VPC independientes en el mismo proyecto.

Nota: Se puede habilitar el acceso global en el extremo de PSC para que esté disponible desde otras regiones.

Objetivos

En este lab, aprenderás a realizar las siguientes tareas:

• Habilita la red de servicios
• Configura PSA
• Crea una instancia de CloudSQL con PSA
• Habilita el adjunto de servicio de PSC.
• Crea un extremo de PSC en la VPC del consumidor para conectarte a la base de datos de CloudSQL
• Verifica el acceso a la base de datos de SQL desde las VMs de prueba, en las VPC de productores y consumidores

Nota: Varios consumidores pueden usar este diseño. Obtén información sobre la multitenancy de Private Service Connect.

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

1. Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
• El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto.
• Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID del proyecto es único a nivel global y no lo puede usar nadie más después de que lo hayas seleccionado. Eres el único usuario de ese ID. Incluso si se borra un proyecto, no se puede volver a usar el ID.

Nota: Si usas una cuenta de Gmail, puedes dejar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

3. Tarea 1. Configura el entorno para el proyecto de base de datos con (Terraform)

Ten en cuenta que algunos recursos que habilites generarán costos. Para reducir el costo, asegúrate de que los recursos se destruyan cuando completes el lab. Te recomendamos revisar tu facturación y asegurarte de que el ejercicio sea aceptable para ti.

En el proyecto de base de datos, habilitaremos las redes de servicios, crearemos una VPC, crearemos un rango de PSA, crearemos un emparejamiento de redes de servicios y crearemos reglas de firewall. Abre la consola de Cloud y selecciona el proyecto que usarás para la base de datos.

1. Abre Cloud Shell, que se encuentra en la parte superior de la consola a la derecha, asegúrate de ver el ID del proyecto de la base de datos para el proyecto de base de datos en Cloud Shell y confirma las indicaciones para permitir el acceso.
2. Crea una carpeta llamada terraform-db-psc y muévela a la carpeta

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

3. Crea los archivos main.tf, variable.tf, nat-vm.tf y database.tf.

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

4. Cambia a la vista del editor de Cloud Shell. Selecciona editor y asegúrate de permitir las indicaciones necesarias para que se cargue la interfaz.
5. Una vez cargado, navega a File > Open Folder y ve a /home/your-user-name/terraform-db-psc y selecciona Ok para abrir la carpeta en el editor.
6. Selecciona el archivo variable.tf y agrega lo siguiente. Reemplaza el texto your-database-project-id-here por el ID real de tu proyecto de base de datos entre comillas. Reemplaza el texto your-consumer-project-id-here por el ID real de tu proyecto de consumidor entre comillas.

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. Luego, abre el archivo main.tf. Agregaremos código de Terraform para realizar varias acciones, como se explica a continuación.

Habilita las APIs	resource "google_project_service" "default"
Crea una VPC	resource "google_compute_network" "default"
Agregar reglas de firewall	resource "google_compute_firewall" "allow_icmp"
Crea un rango de PSA	resource "google_compute_global_address" "psa_range"
Cómo crear un intercambio de tráfico	resource "google_service_networking_connection" "private_connection"

8. Copia y pega lo siguiente en el archivo 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. Regresa a la terminal de Cloud Shell, asegúrate de que te encuentras en el directorio cd terraform-db-psc terraform-db-psc y ejecuta los siguientes comandos:

terraform init

Inicializa el directorio de trabajo. En este paso, se descargan los proveedores necesarios para la configuración determinada.

terraform plan

Genera un plan de ejecución que muestra las acciones que Terraform realizará para implementar tu infraestructura.

10. Ahora, para crear los recursos, ejecuta el comando terraform apply y escribe yes para ejecutarlo.

Verifica la configuración:

Verifica si tu entorno tiene asignado un rango de IP de PSA de red de VPC con intercambio de tráfico habilitado para la red de servicios

Se creó una VPC en modo automático llamada database-net

Se crearon las reglas de firewall

4. Tarea 2: Crea una instancia de CloudSQL con PSA (Terraform)

Usemos Terraform para crear una instancia de CloudSQL, con la opción de PSA para permitir la conectividad. Completa esta configuración en el proyecto de base de datos.

1. Cambia a la vista del editor de Cloud Shell. Asegúrate de estar en la carpeta terraform-db-psc. Selecciona el archivo database.tf y agrega lo siguiente.

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. Regresa a la terminal de Cloud Shell y asegúrate de que te encuentres en el directorio terraform-db-psc. Ahora, para crear los recursos, ejecuta el comando terraform apply y escribe yes para ejecutarlo. La creación de la instancia de CloudSQL con PSA puede tardar más de 15 minutos.

Verifica la base de datos

3. Cuando termines, ve a SQL en la consola y selecciona la instancia de base de datos psc-psa-sql-db que acabas de crear.
4. En el lado izquierdo, expande el panel lateral de opciones de SQL y selecciona Conexiones.
5. En la pestaña Resumen, puedes ver información sobre la conexión.
6. Copia la dirección IP interna y guárdala en algún lugar del sistema. Como puedes ver, se asignó desde el rango que reservamos.
7. Necesitarás esta IP para completar el paso 5 de la tarea 3.

8. En el lado izquierdo, expande el panel lateral de opciones de SQL y selecciona Usuarios.
9. Deberías ver un usuario llamado testsql con la contraseña cloudsql24 (se usará para acceder a la base de datos más adelante)

Verifica la configuración:

1 instancia de base de datos de SQL con IP privada

1 usuario llamado testsql y contraseña cloudsql24

5. Tarea 3: Crea una VM de prueba y conéctate a la instancia de SQL desde el proyecto de la base de datos (Terraform)

Usemos Terraform para crear una VM de prueba y una puerta de enlace NAT. Completa esta configuración en el proyecto de base de datos.

1. Cambia a la vista del editor de Cloud Shell. Asegúrate de estar en la carpeta terraform-db-psc. Selecciona el archivo nat-vm.tf y agrega lo siguiente.

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. Regresa a la terminal de Cloud Shell y asegúrate de que te encuentres en el directorio terraform-db-psc. Ahora, para crear los recursos, ejecuta el comando terraform plan, then terraform apply y escribe yes para ejecutarlo. De esta forma, se creará una puerta de enlace NAT y una VM con MariaDB instalado.

Verifica la base de datos

Completa esta acción en el proyecto de consumidor

3. Ve a Instancia de VM. Selecciona db-vm-test.
4. Selecciona la opción SSH para conectarte a la VM.
5. Conéctate a la base de datos a través de la IP local que copiaste antes con lo siguiente:

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

P.D.: Cambia la dirección IP a tu IP real para que se conecte.

6. Cuando se establezca la conexión, crea una base de datos con el siguiente localvpcsqldb.

CREATE DATABASE localvpcsqldb;

7. Cuando termines, escribe exit para salir de la conexión. Vuelve a escribir exit para cerrar la VM.

Verifica la configuración:

1 puerta de enlace NAT

1 VM llamada db-vm-test

6. Tarea 4: Habilita PSC en la instancia de CloudSQL

Usemos los comandos de gcloud para habilitar la opción de PSC y permitir la conectividad. Completa esta configuración en el proyecto de base de datos.

1. Cambia a la vista Cloud Shell.
2. Ejecuta el siguiente comando en Cloud Shell.

• Reemplaza YOUR_DB_PROJECT_HERE por el ID del proyecto de la base de datos.
• Reemplaza Asegúrate de que YOUR_CONSUMER_PROJECT_HERE sea el ID del proyecto de 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. Esto actualizará la base de datos existente con el archivo adjunto del PSC. Este proceso tardará más de 10 minutos.

Si recibes un error de tiempo de espera, también deberías recibir el comando para seguir viendo el progreso. Algo como "Puedes seguir esperando a que se complete la operación ejecutando "gcloud beta sql operations wait –project".

Ten en cuenta que puedes implementar una nueva base de datos con PSA y PSC habilitados desde el principio.

Verifica la base de datos

4. Cuando termines, ve a SQL en la consola y selecciona la instancia de base de datos psc-psa-sql-db.
5. En el lado izquierdo, expande el panel lateral de opciones de SQL y selecciona Conexiones.
6. En la pestaña Resumen, puedes ver información sobre la conexión.
7. Copia la dirección del conector de servicio y guárdala en algún lugar de tu sistema.
8. La necesitarás para completar la siguiente tarea, paso 8 de la tarea 5.

Verifica la configuración:

1 instancia de base de datos de SQL con archivo adjunto de servicio

7. Tarea 5. Configura el entorno para el proyecto de consumidor (Terraform)

En el proyecto de consumidor, crearemos una VPC personalizada con reglas de firewall y subred. Abre la consola de Cloud y selecciona el proyecto que usarás.

1. En la parte superior de la consola, a la derecha, junto al ícono de Google Cloud, haz clic en el menú desplegable y, luego, selecciona la pestaña todo.

2. En la lista de proyectos, selecciona el ID de tu proyecto de consumidor para continuar.
3. Abre Cloud Shell, que se encuentra en la parte superior de la consola a la derecha, asegúrate de ver el ID del proyecto de consumidor en Cloud Shell y confirma las indicaciones para permitir el acceso.
4. Crea una carpeta llamada terraform-consumer-psc y muévela a la carpeta

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

5. Crea los archivos main.tf, variable.tf y psc.tf.

touch main.tf variable.tf psc.tf 

6. Cambia a la vista del editor de Cloud Shell para el ID del proyecto de consumidor. Selecciona editor y asegúrate de permitir las indicaciones necesarias para que se cargue la interfaz.
7. Una vez cargado, navega a File > Open Folder y ve a /home/your-user-name/terraform-consumer-psc y selecciona Ok para abrir la carpeta en el editor.
8. Selecciona el archivo variable.tf y agrega lo siguiente. Reemplaza el texto your-consumer-project-id-here por el ID de proyecto de consumidor real entre comillas. Reemplaza el texto your-psc-attachment-id-here por la dirección de archivo adjunto de PSC entre comillas. Este es el ID que copiaste en la tarea 4, sección 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. Luego, abre el archivo main.tf. Agregaremos código de Terraform para realizar varias acciones, como se explica a continuación.

Habilita las APIs	resource "google_project_service"
Crea una VPC	resource "google_compute_network"
Crear puerta de enlace NAT	resource "google_compute_router" resource "google_compute_router_nat"
Agregar reglas de firewall	resource "google_compute_firewall"

10. Copia y pega lo siguiente en el archivo 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. Regresa a la terminal de Cloud Shell, asegúrate de que te encuentras en el directorio cd terraform-consumer-psc terraform-consumer-psc del proyecto del consumidor y ejecuta los siguientes comandos:

terraform init

Inicializa el directorio de trabajo. En este paso, se descargan los proveedores necesarios para la configuración determinada.

terraform plan

Genera un plan de ejecución que muestra las acciones que Terraform realizará para implementar tu infraestructura.

12. Ahora, para crear los recursos, ejecuta el comando terraform apply y escribe yes para ejecutarlo.

Verifica la configuración:

Verifica lo siguiente en tu entorno:

1 VPC personalizada llamada psc-endpoint-vpc

Puerta de enlace NAT con reglas de firewall

8. Tarea 6. Crea el extremo de PSC para el archivo adjunto de la base de datos de SQL en el proyecto del consumidor y prueba la VM (Terraform)

Completa esta configuración en el proyecto de consumidor.

1. Regresa al editor de Cloud Shell, abre el directorio terraform-consumer-psc y selecciona el archivo psc.tf. Agrega el siguiente código de Terraform al archivo. Esto crea una IP interna estática, un extremo de PSC y una VM de prueba con MariaDB 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. Regresa a la terminal de Cloud Shell, asegúrate de que te encuentras en el directorio cd terraform-consumer-psc terraform-consumer-psc del proyecto del consumidor y ejecuta los siguientes comandos:

terraform plan

Genera un plan de ejecución que muestra las acciones que Terraform realizará para implementar tu infraestructura.

3. Ahora, para crear los recursos, ejecuta el comando terraform apply y escribe yes para ejecutarlo.

9. Tarea 7. Verifica la conectividad del extremo desde la VM a través de la dirección IP de PSC

Completa esta acción en el proyecto de consumidor

8. Ve a Instancia de VM. Selecciona remote-sql-test-vm.
9. Selecciona la opción SSH para conectarte a la VM.
10. Conéctate a la base de datos a través del extremo con lo siguiente:

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

11. Cuando se establezca la conexión, crea una base de datos con el siguiente psc-sql-db.

CREATE DATABASE remotepscpsasqldb;

12. Cuando termines, escribe exit para salir de la conexión. Vuelve a escribir exit para cerrar la VM.

10. Tarea 8. Verifica la entrada de la base de datos

Completa esta verificación en el proyecto de base de datos.

1. En la parte superior de la consola, a la derecha, junto al ícono de Google Cloud, haz clic en el menú desplegable y, luego, selecciona la pestaña todo.

2. En la lista de proyectos, selecciona el ID de tu proyecto de base de datos para continuar.
3. Navega a SQL, selecciona la base de datos psc-psa-sql-db, expande las opciones de SQL y selecciona Bases de datos. Deberías ver la base de datos que acabas de crear llamada remotepscpsasqldb desde la VM del proyecto de consumidor y también localvpcsqldb desde la VM del proyecto de la base de datos**.**

Nota: También puedes conectarte con un nombre de DNS. Obtén más información para configurar DNS aquí Configura una zona administrada de DNS y un registro DNS.

11. Limpieza

Asegúrate de realizar una limpieza para evitar cargos innecesarios.

Completa esta tarea en el proyecto de consumidor

1. Selecciona el ID del proyecto de consumidor
2. Ve a Cloud Shell y asegúrate de ver el ID del proyecto del consumidor.
3. Ve al directorio terraform-consumer-psc cd terraform-consumer-psc y ejecuta el siguiente comando terraform destroy y escribe yes. Se quitarán todos los recursos que creaste en tu proyecto de consumidor con Terraform.

Completa esta tarea en el proyecto de base de datos

1. Selecciona el ID del proyecto de la base de datos
2. Ve a Cloud Shell y asegúrate de ver el ID del proyecto de la base de datos.
3. Ve al directorio terraform-db-psc cd terraform-db-psc y ejecuta el siguiente comando terraform destroy y escribe yes. Se quitarán la mayoría de los recursos que creaste en tu proyecto de db con Terraform. Es posible que no se borre la red de servicios y se muestre un error.
4. A continuación, borra los siguientes archivos de la carpeta terraform-db-psc.

rm -r terraform.tfstate terraform.tfstate.backup

5. A continuación, en la consola, ve a Redes de VPC.
6. Selecciona la VPC database-net, selecciona PRIVATE SERVICES ACCESS, en Allocated IP Ranges for Services, selecciona psa-range-database-net y selecciona la opción Release.

7. A continuación, selecciona INTERCAMBIO DE TRÁFICO ENTRE REDES DE VPC, selecciona servicenetworking-googleapis-com y, luego, la opción Borrar.

8. A continuación, selecciona Borrar red de VPC

12. Felicitaciones

¡Felicitaciones! Configuraste correctamente una instancia de Cloud SQL con adjuntos de PSA y PSC, y creaste un extremo de Private Service Connect en otra VPC.

Más información

Puedes obtener más información sobre Private Service Connect y Cloud SQL.

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