Ejemplo: Conectividad privada para una instancia de Cloud SQL

En esta página, se explica a través de un ejemplo cómo usar Private Service Connect (PSC) para establecer una conexión entre tu instancia de Cloud SQL habilitada para Acceso privado a servicios (PSA) y el entorno de ejecución de Integration Connectors. Tu instancia de Cloud SQL puede ser de cualquiera de los siguientes tipos:

Cloud SQL para MySQL
Cloud SQL para PostgreSQL
Cloud SQL for SQL Server (Cloud SQL para el servidor SQL)

Consideraciones

Cuando crees un adjunto de servicio de PSC, ten en cuenta los siguientes puntos clave:

El adjunto de servicio de PSC y el balanceador de cargas se crean en diferentes subredes dentro de la misma VPC. Específicamente, el adjunto de servicio siempre se crea en una subred NAT.
Los servidores proxy SOCKS5 deben estar vinculados a la dirección IP 0.0.0.0:<port> porque esto es necesario para el tráfico entrante desde el balanceador de cargas y los sondeos de verificación de estado. Para obtener más información, consulta Verificación de estado.
El tráfico del balanceador de cargas y el sondeo de verificación de estado se debe enviar al mismo puerto.
Configurar las reglas de firewall para facilitar el flujo de tráfico
Reglas de entrada
- El tráfico de la subred del adjunto de servicio de PSC debe llegar a la subred del ILB.
- Dentro de la subred del ILB, el ILB debería poder enviar tráfico a los servidores proxy SOCKS5.
- El sondeo de verificación de estado debe poder acceder a los servidores proxy SOCKS5. Los sondeos de verificación de estado de Google Cloud tienen un rango de IP fijo (35.191.0.0/16, 130.211.0.0/22). Por lo tanto, se puede permitir que estas IP envíen tráfico a los servidores proxy de SOCKS.
Reglas de salida

El tráfico de salida está habilitado de forma predeterminada en un proyecto de Google Cloud, a menos que se configuren reglas de denegación específicas.
Todos tus componentes de Google Cloud, como el adjunto de servicio de PSC y el balanceador de cargas, deben estar en la misma región.
Tu sistema de backend no debe estar abierto a la red pública, ya que esto puede representar un problema de seguridad. Sin embargo, asegúrate de que tus servidores proxy de SOCKS5 acepten tráfico en las siguientes situaciones:
- Balanceadores de cargas de transferencia (ILB L4 TCP/UDP): Las solicitudes de las IP de NAT del adjunto del servicio de PSC deben poder llegar a tus servidores proxy SOCKS5. Estas IP de NAT se generan automáticamente. Por lo tanto, debes permitir todo el rango de IP de la subred de NAT en el que reside el adjunto de servicio. Para obtener más información, consulta Subredes de Private Service Connect.
- Balanceadores de cargas basados en proxy/HTTP(s) (ILB de proxy L4, ILB L7): Todas las solicitudes nuevas se originan en el balanceador de cargas. Por lo tanto, tus servidores proxy de SOCKS5 deben aceptar solicitudes de la subred del proxy de tu red de VPC. Si deseas obtener más información, consulta Subredes de solo proxy para balanceadores de cargas basados en Envoy.

Configura PSC para una instancia de Cloud SQL

Integration Connectors usa el proxy de autenticación de Cloud SQL para conectarse a una instancia de Cloud SQL. El proxy de autenticación de Cloud SQL admite el encadenamiento a través de un proxy de SOCKS5, lo que te permite reenviar el tráfico encriptado del proxy de autenticación de Cloud SQL a la instancia de Cloud SQL de destino. Por lo tanto, necesitas que los servidores proxy SOCKS5 se conecten a una instancia privada de Cloud SQL.

En el siguiente diagrama, se muestra cómo se verá tu proyecto de Google Cloud una vez que se configure el adjunto de servicio de PSC para la configuración de una instancia de Cloud SQL de muestra.

En este ejemplo, los servidores proxy SOCKS5 se exponen a través de un adjunto de servicio para que PSC pueda conectarse de forma segura a una instancia de Cloud SQL. Los servidores proxy de SOCKS tienen acceso a una instancia de Cloud SQL a través del acceso privado a servicios. Los servidores proxy SOCKS5 se encuentran en un grupo de instancias de Compute Engine no administrado y puedes decidir la cantidad de instancias de proxy según el tráfico de entrada esperado.

¿Cómo fluye el tráfico en el ejemplo?

Integration Connectors envía una solicitud a un adjunto de servicio.
El adjunto de servicio reenvía la solicitud a un ILB L4.
El ILB L4 envía una solicitud a los servidores proxy SOCKS5.
El ILB tiene las reglas de reenvío y realiza la redirección de puertos. De forma predeterminada, un proxy SOCKS5 escucha en el puerto 1080. Sin embargo, si los servidores proxy de SOCKS5 escuchan en un puerto diferente, ese puerto también debe estar abierto para escuchar en el ILB.
Los servidores proxy SOCKS5 reenvían la solicitud a la instancia de Cloud SQL.

Antes de comenzar

Antes de crear un adjunto de servicio de PSC para la situación de ejemplo, realiza las siguientes tareas:

Instala la CLI de gcloud
Habilita la API de Compute Engine y la API de Service Networking para tu proyecto de Google Cloud.
Para que los comandos de la CLI sean menos detallados, puedes configurar los valores de PROJECT_ID, REGION y ZONE con los siguientes comandos:
```
gcloud config set project PROJECT_ID
gcloud config set compute/region REGION
gcloud config set compute/zone ZONE
```
Para los comandos de este instructivo, reemplaza BACKEND_SERVER_PORT por 1080, que es el puerto predeterminado en el que se ejecuta un servidor proxy SOCKS5.
Se recomienda crear una nueva red de VPC y usarla cuando se pruebe esta situación de muestra. Después de probar la situación, puedes borrar la red de VPC y otros recursos.
Debe haber al menos una conexión existente que hayas creado. La conexión puede ser de cualquier tipo. Tener una conexión existente te permite recuperar el ID del proyecto del directorio de servicios desde el entorno de ejecución de Integration Connectors. Se requiere este ID del proyecto para crear el adjunto de servicio de PSC.

Crear un adjunto de servicio de PSC

A fin de crear un adjunto de servicio de PSC para la situación de muestra, realiza las siguientes tareas:

Crea una red de VPC y las subredes necesarias.
1. Crear una red de VPC.
```
gcloud compute networks create VPC_NETWORK \
--project=PROJECT_ID --subnet-mode=custom --mtu=1460 \
--bgp-routing-mode=regional
```
2. Agrega Subnet-1.
```
gcloud compute networks subnets create SUBNET_NAME_1 \
--network=VPC_NETWORK --range=SUBNET_RANGE_1 \
--purpose=PRIVATE_SERVICE_CONNECT
```
  Este comando crea Subnet-1 como una subred de NAT que se usará de forma exclusiva para alojar el adjunto de servicio de PSC. No puedes alojar ningún otro servicio en esta subred de NAT.
3. Agrega Subnet-2.
```
gcloud compute networks subnets create SUBNET_NAME_2 \
--network=VPC_NETWORK --range=SUBNET_RANGE_2
```
Nota: El adjunto de servicio de PSC no puede existir en la misma subred que el balanceador de cargas. Por lo tanto, necesitas dos subredes.
Crear una instancia privada de Cloud SQL
1. Configura el acceso privado a servicios.
  1. Asigna un rango de direcciones IP.
```
gcloud compute addresses create google-managed-services-VPC_NETWORK \
--global --purpose=VPC_PEERING --prefix-length=16 \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK
```
  2. Crea una conexión privada.
```
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=google-managed-services-VPC_NETWORK \
--network=VPC_NETWORK \
--project=PROJECT_ID
```
2. Crea una instancia de Cloud SQL con una IP privada.
```
gcloud beta sql instances create \
INSTANCE_NAME \
--database-version=DATABASE_VERSION \
--cpu=NUMBER_OF_CPUs \
--memory=MEMORY \
--zone=ZONE \
--root-password=ROOT_PASSWORD \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK \
--no-assign-ip \
--allocated-ip-range-name=google-managed-services-VPC_NETWORK
```
  Especifica el DATABASE_VERSION según el tipo de instancia que deseas crear. Puedes crear una instancia de tipo MySQL, PostgreSQL o SQL Server. Para obtener la lista de todas las versiones de bases de datos compatibles, consulta Versión de la base de datos de SQL.
  
  Este comando crea un usuario predeterminado para tu instancia de Cloud SQL. Estos son los usuarios predeterminados que se crearán para las diversas instancias de Cloud SQL *:
  - Cloud SQL para MySQL: root
  - Cloud SQL para SQL Server: sqlserver
  - Cloud SQL para PostgreSQL: postgres
3. Si no quieres usar el usuario predeterminado, crea un usuario nuevo para la instancia de Cloud SQL que acabas de crear (opcional).
```
gcloud sql users create USER --host=% --instance=INSTANCE_NAME \
--password=PASSWORD
```
  Asegúrate de que el usuario tenga todos los permisos necesarios para acceder a la base de datos que crearás en el siguiente paso.
4. Crear una base de datos en la instancia de Cloud SQL recién creada
```
gcloud sql databases create DATABASE_NAME \
--instance=INSTANCE_NAME
```

Configura Cloud NAT.

Crear un router sencillo

gcloud compute routers create NAT_ROUTER_NAME \
    --network=VPC_NETWORK

Configura la traducción de direcciones de red.

gcloud compute routers nats create NAT_GATEWAY_NAME \
    --router=NAT_ROUTER_NAME \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges

Crea instancias de VM de Compute Engine para ejecutar servidores proxy de SOCKS5.
1. Crea la instancia 1 de proxy.
```
gcloud compute instances create PROXY_INSTANCE_1 \
--project=PROJECT_ID \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address
```
Según tus necesidades, puedes crear tantas instancias de VM como sea necesario.

Crea una regla de firewall para permitir el acceso SSH a tus instancias de VM.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_SSH \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:22

Instalar el proxy de SOCKS5

Los pasos detallados para instalar y configurar un servidor proxy SOCKS5 están fuera del alcance de este documento, por lo que puedes instalar el proxy de SOCKS5 que elijas. En los siguientes pasos, se muestra cómo instalar y configurar el servidor proxy Dante SOCKS5.

Establece una conexión SSH a tu instancia de VM.

gcloud compute ssh \
    --tunnel-through-iap \
    PROXY_INSTANCE_1

Instala el servidor proxy Dante SOCKS5.

sudo apt update
sudo apt install dante-server

Verifica la interfaz del servidor.
```
sudo ip a
```
Crear una copia de seguridad de la configuración de Dante
```
sudo mv /etc/danted.conf /etc/danted.conf.bak
```
Crea un nuevo archivo de configuración de Dante.
```
sudo nano /etc/danted.conf
```

Copia la siguiente configuración en el archivo de configuración:

logoutput: /var/log/socks.log
# Bind the server to the 0.0.0.0 IP address to allow traffic
# traffic from the load balancer and the health check probes.
internal: 0.0.0.0 port = 1080
external: ens4
clientmethod: none
socksmethod: none
user.privileged: root
user.notprivileged: nobody
client pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
client block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}
socks pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
socks block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}

Reinicia el servidor de Dante y comprueba el estado.

sudo systemctl restart danted
sudo systemctl status danted

Sal de la instancia de VM.
```
exit
```

Configura un grupo de instancias no administrado.
1. Crea un grupo de instancias no administrado.
```
gcloud compute instance-groups unmanaged create INSTANCE_GROUP_NAME
```
  Nota: En este instructivo, se usa un grupo de instancias no administrado. Puedes crear un grupo de instancias administrado para obtener una mejor confiabilidad.
2. Agrega al grupo las instancias de VM creadas en el paso 3.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME \
--instances=PROXY_INSTANCE_1
```
Crea un sondeo de verificación de estado y permite el tráfico proveniente de este.
1. Crea el sondeo de verificación de estado.
```
gcloud compute health-checks create tcp HEALTH_CHECK_NAME \
--port BACKEND_SERVER_PORT --region=REGION
```
  En este comando, establece BACKEND_SERVER_PORT en 1080, que es el puerto predeterminado en el que se ejecutan los servidores proxy de SOCKS5.
2. Crea una regla de firewall para permitir el tráfico proveniente del sondeo.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME_HEALTHCHECK \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:BACKEND_SERVER_PORT \
--source-ranges=35.191.0.0/16,130.211.0.0/22
```

Crear un balanceador de cargas interno L4 y permitir el tráfico desde el balanceador de cargas

Crea un servicio de backend.

gcloud compute backend-services create BACKEND_SERVICE \
--load-balancing-scheme=internal --protocol=tcp --health-checks=HEALTH_CHECK_NAME \
--health-checks-region=REGION

Agrega un grupo de instancias al servicio de backend.

gcloud compute backend-services add-backend BACKEND_SERVICE \
--instance-group=INSTANCE_GROUP_NAME \
--instance-group-zone=ZONE

Crea una regla de reenvío.

gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
--load-balancing-scheme=internal --network=VPC_NETWORK --subnet=SUBNET_NAME_2 \
--ip-protocol=TCP --ports=BACKEND_SERVER_PORT --backend-service=BACKEND_SERVICE \
--backend-service-region=REGION

Crea una regla de firewall para permitir el tráfico interno del balanceador de cargas al grupo de instancias.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_INTERNAL \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--action=ALLOW --rules=all --source-ranges=SUBNET_RANGE_2

Crea el adjunto de servicio de PSC.
1. Crea una regla de firewall para permitir el tráfico desde el adjunto de servicio de PSC al balanceador de cargas interno creado en el paso anterior.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME_SA \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--allow=tcp:BACKEND_SERVER_PORT --source-ranges=SUBNET_RANGE_1
```
2. Crea un adjunto de servicio con aprobación explícita.
```
gcloud compute service-attachments create SERVICE_ATTACHMENT_NAME \
--producer-forwarding-rule=FORWARDING_RULE_NAME  \
--connection-preference=ACCEPT_MANUAL \
--consumer-accept-list=SERVICE_DIRECTORY_PROJECT_ID=LIMIT \
--nat-subnets=SUBNET_NAME_1
```
  En este comando, LIMIT es el límite de conexiones del proyecto. El límite de conexión es la cantidad de extremos de Private Service Connect del consumidor que se pueden conectar a este servicio. Para comprender cómo obtener el SERVICE_DIRECTORY_PROJECT_ID, consulta Cómo obtener el ID del proyecto del directorio de servicios.
Crea un adjunto de extremo.
El adjunto del extremo es como una interfaz para el adjunto de servicio de PSC. No puedes usar el adjunto de servicio de PSC directamente para configurar la conectividad privada. Solo se puede acceder al adjunto de servicio de PSC a través de un adjunto de extremo. Puedes crear el adjunto de extremo como una dirección IP o como un nombre de host. Después de crear el adjunto de extremo, puedes usarlo cuando configures un conector para conectividad privada. Para obtener más información, consulta Crea un adjunto de extremo.

Nota: Debes usar la dirección IP o el nombre de host del adjunto del extremo como la dirección del proxy SOCKS5 cuando creas la conexión.
Verifica la configuración de PSC.
Puedes verificar la conectividad privada mediante la creación de una conexión de Cloud SQL y la configuración del servidor proxy SOCKS5 como se muestra en este instructivo. Si deseas obtener pasos detallados sobre cómo crear una conexión, consulta la documentación del conector específico (Cloud SQL para MySQL, Cloud SQL para PostgreSQL o Cloud SQL para SQL Server). Cuando crees la conexión, en la sección Destinations (en el paso 5), selecciona Destination type como Host address y, luego, ingresa la dirección IP o el nombre de host del adjunto de extremo para los detalles del servidor proxy SOCKS5. Establece el valor del puerto en 1080, a menos que hayas configurado un puerto diferente para el servidor proxy de SOCKS5. Si la conexión se crea correctamente, el estado de la conexión recién creada será Active en la página Conexiones de la consola de Cloud.

Obtén el ID del proyecto del directorio de servicios

Como práctica recomendada, puedes crear el adjunto de servicio de PSC para que acepte solicitudes solo de los proyectos de Google Cloud especificados. Sin embargo, para ello, necesitas el ID del proyecto del directorio de servicios asociado con tu proyecto de Google Cloud. Para obtener el ID del proyecto del directorio de servicios, puedes usar la API de List Connections como se muestra en el siguiente ejemplo.

Sintaxis

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/CONNECTORS_PROJECT_ID/locations/-/connections"

Reemplaza lo siguiente:

CONNECTORS_PROJECT_ID: El ID del proyecto de Google Cloud en el que creaste la conexión

Ejemplo

En este ejemplo, se obtiene el ID del proyecto del directorio de servicios para el proyecto connectors-test de Google Cloud.

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/connectors-test/locations/-/connections"

Cuando ejecutas este comando en la terminal, se muestra un resultado similar al siguiente:

.....
{
  "connections": [
    {
      "name": "projects/connectors-test/locations/asia-northeast1/connections/big-query-iam-invalid-sa",
      "createTime": "2022-10-07T09:02:31.905048520Z",
      "updateTime": "2022-10-07T09:22:39.993778690Z",
      "connectorVersion": "projects/connectors-test/locations/global/providers/gcp/connectors/bigquery/versions/1",
      "status": {
        "state": "ACTIVE"
      },
      "configVariables": [
        {
          "key": "project_id",
          "stringValue": "connectors-test"
        },
        {
          "key": "dataset_id",
          "stringValue": "testDataset"
        }
      ],
      "authConfig": {},
      "serviceAccount": "564332356444-compute@developer.gserviceaccount.com",
      "serviceDirectory": "projects/abcdefghijk-tp/locations/asia-northeast1/namespaces/connectors/services/runtime",
      "nodeConfig": {
        "minNodeCount": 2,
        "maxNodeCount": 50
      }
    },
....

En el resultado de muestra, para el proyecto connectors-test de Google Cloud, el ID del proyecto del directorio de servicios es abcdefghijk-tp.