Cómo conectarse a CloudSQL a través de Private Service Connect (Terraform)

1. Descripción general

Existen varias opciones para conectarse a una instancia privada de Cloud SQL desde otro proyecto o VPC. Private Service Connect (PSC) permite a los productores de servicios exponer sus servicios a través de adjuntos de servicio. Los consumidores pueden usar estos adjuntos de servicio para crear extremos o backends de PSC en su entorno y conectarse a estos servicios de productor a través de una IP privada especificada.

Cloud SQL tiene la capacidad de usar el adjunto de servicio de PSC para permitir la conexión privada. 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 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:

• Crea una instancia de Cloud SQL con un archivo adjunto de servicio de PSC.
• Crea una dirección IP estática
• 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 una VM de prueba en la red del consumidor a través de la IP del extremo de PSC.

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, crearemos una VPC personalizada con reglas de firewall y subred. 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 y muévela a la carpeta

mkdir terraform-db  && cd terraform-db

3. Crea los archivos main.tf, variable.tf y database.tf.

touch main.tf variable.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 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"

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

1 VPC en modo automático llamada database-net

Firewall-rules

4. Tarea 2: Crea una instancia de CloudSQL con un archivo adjunto de PSC (Terraform)

Usemos Terraform para crear una instancia de CloudSQL con la opción de PSC 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. Selecciona el archivo database.tf y agrega lo siguiente.

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

Verifica la base de datos

3. Cuando termines, ve a SQL en la consola y selecciona la instancia de base de datos psc-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 del archivo adjunto del servicio y guárdala en algún lugar de tu sistema.
7. La necesitarás para completar el paso 8 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 archivo adjunto de servicio

1 usuario llamado testsql y contraseña cloudsql24

5. Tarea 3: 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 y muévela a la carpeta

mkdir terraform-consumer  && cd terraform-consumer

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 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 2, sección 2-5

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. 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" {
  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. Regresa a la terminal de Cloud Shell, asegúrate de que estás en el directorio cd terraform-consumer terraform-consumer del proyecto de 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-net

Puerta de enlace NAT con reglas de firewall

6. Tarea 4: 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 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"
  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. Regresa a la terminal de Cloud Shell, asegúrate de que estás en el directorio cd terraform-consumer terraform-consumer del proyecto de 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.
4. Debido a que nuestra VM y el extremo se encuentran en regiones diferentes, debemos habilitar el acceso global en el extremo de PSC. Para ello, usamos la consola.
5. En la consola del proyecto de consumidor, ve a Private Service Connect. En la pestaña Extremo conectado, busca la sección Extremo y selecciona psc-sql-endpoint.
6. Ahora selecciona EDITAR y, luego, haz clic en la casilla de verificación junto a Habilitar el acceso global y la opción Guardar.
7. Continúa con el siguiente paso para verificar la conectividad

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

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

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

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

CREATE DATABASE remotesqldb;

5. Cuando termines, escribe exit para salir de la conexión.

8. Tarea 6. 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-sql-db, expande las opciones de SQL y selecciona Bases de datos. Deberías ver la base de datos que acabas de crear llamada remotesqldb desde la VM del proyecto de consumidor**.**

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.

9. Limpieza

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

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 cd terraform-db y ejecuta el siguiente comando terraform destroy y escribe yes. Se quitarán todos los recursos que creaste en tu proyecto de db con Terraform.

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 cd terraform-consumer y ejecuta el siguiente comando terraform destroy y escribe yes. Se quitarán todos los recursos que creaste en tu proyecto de db con Terraform.

10. Felicitaciones

¡Felicidades! Configuraste correctamente una instancia de Cloud SQL con el adjunto de PSC y creaste un extremo de Private Service Connect en otra VPC. Pudiste conectarte correctamente a la base de datos desde una VM remota a través del extremo de PSC.

Más información

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