Ejemplo: Conectividad privada para una instancia de MySQL

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 el sistema de backend MySQL, que se encuentra en una red privada, y el entorno de ejecución de Integration Connectors.

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 deben estar en diferentes subredes dentro de la misma VPC. Específicamente, el adjunto de servicio debe estar en una subred NAT.
El software que se ejecuta en las VM de backend debe responder al tráfico con balanceo de cargas y a los sondeos de verificación de estado enviados a la dirección IP de cada regla de reenvío (el software debe escuchar en 0.0.0.0:<port> y no en una dirección IP específica asignada a una interfaz de red). Para obtener más información, consulta Verificación de estado.
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 tu sistema de backend.
- El sondeo de verificación de estado debería poder acceder a tu sistema de backend. 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 tu servidor de backend.
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 tu sistema de backend acepte tráfico en las siguientes situaciones:
- Balanceadores de cargas de transferencia (ILB L4 TCP/UDP): Las solicitudes de las IP de NAT del adjunto de servicio de PSC deben poder llegar a tu backend. 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, tu backend debe aceptar solicitudes de la 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.

Ejemplo

Considera si tienes una instancia de MySQL alojada en Google Cloud en una red de VPC privada y deseas exponer la instancia de MySQL al entorno de ejecución de Integration Connectors.

En la siguiente ilustración, se muestra cómo se verá el proyecto de Google Cloud de muestra después de configurar el adjunto de servicio de PSC.

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 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 3306, que es el puerto predeterminado en el que se ejecuta el servidor MySQL.
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_NAME --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.
Cree una instancia de VM:

Para crear una instancia de VM en la VPC recién creada, ejecuta el siguiente comando:
```
gcloud compute instances create \
--image-family debian-10 \
--image-project debian-cloud \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address \
mysql-test
```
Este comando crea una instancia de VM con el nombre mysql-test.

Nota: Para cumplir con las prácticas recomendadas de seguridad, la opción --no-address crea la instancia sin una dirección IP externa. Sin embargo, si la instancia necesita acceder a los repositorios de paquetes públicos durante la instalación de MySQL, debes permitir el acceso a Internet mediante la configuración de Cloud NAT para administrar la traducción de direcciones de red.

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

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

Crea una regla de firewall para permitir SSH.

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

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

gcloud compute ssh \
    --tunnel-through-iap \
    mysql-test

Instala el servidor MySQL. Para obtener instrucciones detalladas, consulta Instala MySQL.
Conéctate a la instancia de MySQL y crea datos de muestra.
1. Conéctate a MySQL mediante el cliente MySQL.
```
sudo mysql -u root -p
```
2. Crea un usuario nuevo y otorga acceso para conectarte desde cualquier dirección de host.
```
CREATE USER 'test-user'@'%' IDENTIFIED BY 'test-pass';
GRANT ALL PRIVILEGES ON * . * TO 'test-user'@'%';
FLUSH PRIVILEGES;
```
  Con este comando, se crea un usuario con el nombre de usuario test-user y la contraseña test-pass.
3. Crear una base de datos junto con los datos de muestra
```
CREATE DATABASE test-db;
USE test-db;
CREATE TABLE Singers (SingerId int, FirstName varchar(255), LastName varchar(255));
INSERT INTO Singers (SingerId, FirstName, LastName) VALUES (1, 'Marc', 'Richards');
```
4. Sal del cliente MySQL.
```
mysql> exit
```
5. 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 la instancia de VM creada en el paso 2.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME --instances=mysql-test
```
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 3306, que es el puerto predeterminado en el que se ejecuta el servidor MySQL.
2. Crea una regla de firewall para permitir el tráfico proveniente del sondeo.
```
gcloud compute firewall-rules create VPC_NETWORK-allow-health-check --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 VPC_NETWORK-allow-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 VPC_NETWORK-allow-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.
Verifica la configuración de PSC. Para verificar la conectividad del adjunto de servicio de PSC, crea una conexión MySQL en la base de datos test-db que creaste para este instructivo. Si deseas conocer los pasos detallados para crear una conexión de MySQL, consulta Crea una conexión de MySQL. Cuando crees la conexión, en la sección Destinations (consulta el paso 5 en Crea una conexión de MySQL), selecciona Destination type como Hostname y, luego, ingresa la dirección IP del extremo o el nombre de host adecuados. 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.

Adjunto de servicio de PSC para otros sistemas de backend

Puedes seguir los pasos del ejemplo anterior para configurar un adjunto de servicio de PSC para otros sistemas de backend. Sin embargo, deberás modificar los pasos 5 y 6 para integrar el sistema de backend deseado. Después de instalar el sistema de backend en la instancia de VM, agrégalo al grupo de instancias y sigue los pasos restantes tal como está.