Se usó la API de Cloud Translation para traducir esta página.

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 el acceso a servicios privados (PSA) y el entorno de ejecución de Integration Connectors. Tu instancia de Cloud SQL puede Debe ser cualquiera de los siguientes tipos:

Consideraciones

Cuando crees un archivo 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 subredes diferentes 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>, ya que esto es obligatorio para el tráfico entrante del 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 del sondeo de verificación de estado debe enviarse al mismo puerto.
Configura 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, este 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. El 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 sea específico se configuren las reglas de denegación.
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 SOCKS5 acepten el tráfico en las siguientes situaciones:
- Balanceadores de cargas de transferencia (ILB de TCP/UDP L4): Solicitudes del servicio de PSC las direcciones IP de NAT del adjunto deben poder llegar a sus servidores proxy SOCKS5. Estas IP con NAT son generados automáticamente. Por lo tanto, debes permitir todo el rango de IP de la subred NAT en el que reside tu adjunto de servicio. Para obtener más información, consulta Subredes de Private Service Connect.
- Balanceadores de cargas HTTP(S) o basados en proxy (balanceador de cargas de proxy de L4, balanceador de cargas de L7): Todas las solicitudes nuevas provienen del balanceador de cargas. Por lo tanto, tus servidores proxy SOCKS5 deben aceptar solicitudes del subred de 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 mediante un proxy de SOCKS5, que te permite reenviar el tráfico encriptado del proxy de Cloud SQL Auth a la instancia de Cloud SQL de destino, Por lo tanto, necesitas servidores proxy SOCKS5 para conectarte a una instancia privada de Cloud SQL.

En el siguiente diagrama, se muestra cómo se verá tu proyecto de Google Cloud después de que se configure el archivo adjunto del servicio de PSC para una configuración de instancia de Cloud SQL de ejemplo.

En este ejemplo, los servidores proxy SOCKS5 se exponen a través de un adjunto de servicio para que PSC puede conectarse de forma segura a una instancia de Cloud SQL. Los servidores proxy 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?

Los conectores de integración envían una solicitud a un archivo adjunto de servicio.
El archivo adjunto del servicio reenvía la solicitud a un ILB de L4.
El ILB de 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 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 tus 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 pruebes esta situación de ejemplo. 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 los conectores de integración. Este ID del proyecto es necesario para crear el adjunto de servicio de PSC.

Crea un adjunto de servicio de PSC

Para crear un archivo adjunto de servicio de PSC para la situación de ejemplo, 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 NAT que se usará de forma exclusiva para lo siguiente: 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.
Crea una instancia privada de Cloud SQL.
1. Configura el acceso privado a los 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 ver la lista de todas las bases de datos admitidas, consulta Versión de la base de datos de SQL.
  
  Este comando crea un usuario predeterminado para tu instancia de Cloud SQL. A continuación, se muestran 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 uno 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 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.

Crea un router simple.

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

Crear instancias de VM de Compute Engine para ejecutar servidores proxy SOCKS5
1. Crea la instancia de proxy 1.
```
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 SSH en 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 SOCKS5

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

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

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

Instala el servidor proxy SOCKS5 de Dante.

sudo apt update
sudo apt install dante-server

Verifica la interfaz del servidor.
```
sudo ip a
```
Crea 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 Dante y verifica 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. Crear 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 mejorar la confiabilidad.
2. Agrega al grupo las instancias de VM que creaste 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 del sondeo.

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 SOCKS5.

Crea una regla de firewall para permitir el tráfico desde el 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

Crea un balanceador de cargas interno L4 y permite 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 el 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 del 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 conexión del proyecto. El límite de conexiones es la cantidad de usuarios Extremos de Private Service Connect que pueden conectarse 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 archivo adjunto de extremo.
Puedes pensar en el adjunto de extremo como una interfaz para el adjunto de servicio de PSC. No puedes usa 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. Y puedes crear el adjunto de extremo como una dirección IP o un nombre de host. Después de crear el adjunto de extremo, puedes usarla 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 de extremo como la dirección del proxy SOCKS5 cuando crees la conexión.
Verifica la configuración de PSC.
Para verificar la conectividad privada, crea una conexión de Cloud SQL y configura el servidor proxy SOCKS5 como se muestra en este instructivo. Si deseas conocer los pasos detallados para crear una conexión, consulta la documentación (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 el Destination type como Host address y, luego, ingresar la dirección IP o el nombre de host del adjunto de extremo del Detalles del servidor proxy SOCKS5. Establece el valor del puerto en 1080, a menos que hayas configurado un puerto diferente para el servidor proxy SOCKS5. Si la creación de la conexión se realiza 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 archivo adjunto del servicio de PSC de modo que acepte solicitudes solo de los proyectos de Google Cloud especificados. Sin embargo, para hacerlo, necesitarás el ID del proyecto del directorio de servicios asociado a 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 a continuación 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 de tu 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"

Si ejecutas este comando en la terminal, se mostrará 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.