Exemple: Connectivité privée pour une instance Cloud SQL

Cette page explique, à l'aide d'un exemple, comment utiliser Private Service Connect (PSC) pour établir une connexion entre votre instance Cloud SQL activée pour l'accès privé aux services et l'environnement d'exécution Integration Connectors. Votre instance Cloud SQL peut être de l'un des types suivants:

Points à prendre en compte

Lorsque vous créez un rattachement de service PSC, tenez compte des points clés suivants:

Le rattachement de service PSC et l'équilibreur de charge sont créés dans des sous-réseaux différents au sein du même VPC. Plus précisément, le rattachement de service est toujours créé dans un sous-réseau NAT.
Les serveurs proxy SOCKS5 doivent être liés à l'adresse IP 0.0.0.0:<port>, car cette opération est requise pour le trafic entrant provenant de l'équilibreur de charge et des vérifications d'état. Pour en savoir plus, consultez la section Vérification de l'état.
Le trafic provenant de l'équilibreur de charge et de la vérification de l'état doit être envoyé vers le même port.
Configurer les règles de pare-feu pour faciliter le flux de trafic
Règles d'entrée
- Le trafic provenant du sous-réseau du rattachement de service PSC doit atteindre le sous-réseau de l'ILB.
- Au sein de ce sous-réseau, l'ILB doit pouvoir envoyer du trafic vers les serveurs proxy SOCKS5.
- La vérification de l'état doit pouvoir accéder aux serveurs proxy SOCKS5. Les vérifications d'état Google Cloud ont une plage d'adresses IP fixe (35.191.0.0/16, 130.211.0.0/22). Ces adresses IP peuvent donc être autorisées à envoyer du trafic aux serveurs proxy SOCKS.
Règles de sortie

Le trafic de sortie est activé par défaut dans un projet Google Cloud, sauf si des règles de refus spécifiques sont configurées.
Tous vos composants Google Cloud, tels que le rattachement de service PSC et l'équilibreur de charge, doivent se trouver dans la même région.
Votre système backend ne doit pas être ouvert au réseau public, car cela peut poser un problème de sécurité. Assurez-vous toutefois que vos serveurs proxy SOCKS5 acceptent le trafic dans les cas suivants :
- Équilibreurs de charge passthrough (ILB TCP/UDP L4) : les requêtes provenant des adresses IP NAT du rattachement de service PSC doivent pouvoir atteindre vos serveurs proxy SOCKS5. Ces adresses IP NAT sont générées automatiquement. Par conséquent, vous devez autoriser l'intégralité de la plage d'adresses IP du sous-réseau NAT dans laquelle réside votre rattachement de service. Pour en savoir plus, consultez la section Sous-réseaux Private Service Connect.
- Équilibreurs de charge basés sur un proxy/HTTP(s) (équilibreur de charge interne du proxy L4, ILB L7) : toutes les nouvelles requêtes proviennent de l'équilibreur de charge. Par conséquent, vos serveurs proxy SOCKS5 doivent accepter les requêtes provenant du sous-réseau proxy de votre réseau VPC. Pour en savoir plus, consultez la page Sous-réseaux proxy réservés aux équilibreurs de charge Envoy.

Configurer PSC pour une instance Cloud SQL

Integration Connectors utilise le proxy d'authentification Cloud SQL pour se connecter à une instance Cloud SQL. Le proxy d'authentification Cloud SQL est compatible avec le chaînage via un proxy SOCKS5, ce qui vous permet de transférer le trafic chiffré à partir du proxy d'authentification Cloud SQL vers l'instance Cloud SQL de destination. Vous avez donc besoin des serveurs proxy SOCKS5 pour vous connecter à une instance Cloud SQL privée.

Le schéma suivant montre l'aspect de votre projet Google Cloud une fois le rattachement de service PSC configuré pour un exemple de configuration d'instance Cloud SQL.

Dans cet exemple, les serveurs proxy SOCKS5 sont exposés via un rattachement de service afin que PSC puisse se connecter de manière sécurisée à une instance Cloud SQL. Les serveurs proxy SOCKS ont accès à une instance Cloud SQL via l' accès privé aux services. Les serveurs proxy SOCKS5 appartiennent à un groupe d'instances Compute Engine non géré. Vous pouvez décider du nombre d'instances de proxy en fonction du trafic entrant attendu.

Comment le trafic s'écoule dans cet exemple ?

Integration Connectors envoie une requête à un rattachement de service.
Le rattachement de service transfère la requête à un ILB L4.
L'ILB L4 envoie une requête aux serveurs proxy SOCKS5.
L'ILB dispose des règles de transfert et effectue un transfert de port. Par défaut, un proxy SOCKS5 écoute sur le port 1080. Toutefois, si les serveurs proxy SOCKS5 écoutent sur un port différent, ce port doit également être ouvert pour l'écoute sur l'ILB.
Les serveurs proxy SOCKS5 transfèrent la requête à l'instance Cloud SQL.

Avant de commencer

Avant de créer un rattachement de service PSC pour l'exemple de scénario, procédez comme suit:

Installer gcloud CLI
Activez l'API Compute Engine et l'API Service Networking pour votre projet Google Cloud.
Pour que vos commandes CLI soient moins détaillées, vous pouvez définir les valeurs des champs PROJECT_ID, REGION et ZONE à l'aide des commandes suivantes:
```
gcloud config set project PROJECT_ID
gcloud config set compute/region REGION
gcloud config set compute/zone ZONE
```
Pour les commandes de ce tutoriel, remplacez BACKEND_SERVER_PORT par 1080, qui est le port par défaut sur lequel un serveur proxy SOCKS5 s'exécute.
Il est recommandé de créer un réseau VPC et de l'utiliser lorsque vous essayez cet exemple de scénario. Après avoir testé le scénario, vous pouvez supprimer le réseau VPC et d'autres ressources.
Vous devez avoir créé au moins une connexion. La connexion peut être de n'importe quel type. Disposer d'une connexion vous permet d'extraire l'ID de projet du répertoire de service à partir de l'environnement d'exécution Integration Connectors. Cet ID de projet est requis pour créer le rattachement de service PSC.

Créer un rattachement de service PSC

Pour créer un rattachement de service PSC pour l'exemple de scénario, procédez comme suit:

Créez un réseau VPC et les sous-réseaux requis.
1. Créez un réseau VPC.
```
gcloud compute networks create VPC_NETWORK \
--project=PROJECT_ID --subnet-mode=custom --mtu=1460 \
--bgp-routing-mode=regional
```
2. Ajoutez Subnet-1.
```
gcloud compute networks subnets create SUBNET_NAME_1 \
--network=VPC_NETWORK --range=SUBNET_RANGE_1 \
--purpose=PRIVATE_SERVICE_CONNECT
```
  Cette commande crée Subnet-1 en tant que sous-réseau NAT qui sera utilisé exclusivement pour héberger le rattachement de service PSC. Vous ne pouvez héberger aucun autre service dans ce sous-réseau NAT.
3. Ajoutez Subnet-2.
```
gcloud compute networks subnets create SUBNET_NAME_2 \
--network=VPC_NETWORK --range=SUBNET_RANGE_2
```
Remarque : Le rattachement de service PSC ne peut pas exister dans le même sous-réseau que l'équilibreur de charge. Vous avez donc besoin de deux sous-réseaux.
Créer une instance Cloud SQL privée
1. Configurez l'accès aux services privés.
  1. Allouez une plage d'adresses 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. Créez une connexion privée.
```
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=google-managed-services-VPC_NETWORK \
--network=VPC_NETWORK \
--project=PROJECT_ID
```
2. Créez une instance Cloud SQL avec une adresse IP privée.
```
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
```
  Spécifiez le DATABASE_VERSION en fonction du type d'instance que vous souhaitez créer. Vous pouvez créer une instance de type MySQL, PostgreSQL ou SQL Server. Pour obtenir la liste de toutes les versions de base de données compatibles, consultez Version de la base de données SQL.
  
  Cette commande crée un utilisateur par défaut pour votre instance Cloud SQL. Voici les utilisateurs par défaut qui seront créés pour les différentes instances Cloud SQL* :
  - Cloud SQL pour MySQL : root
  - Cloud SQL pour SQL Server : sqlserver
  - Cloud SQL pour PostgreSQL – postgres
3. (Facultatif) Si vous ne souhaitez pas utiliser l'utilisateur par défaut, créez un utilisateur pour l'instance Cloud SQL que vous venez de créer.
```
gcloud sql users create USER --host=% --instance=INSTANCE_NAME \
--password=PASSWORD
```
  Assurez-vous que l'utilisateur dispose de toutes les autorisations requises pour accéder à la base de données que vous allez créer à l'étape suivante.
4. Créez une base de données dans l'instance Cloud SQL que vous venez de créer.
```
gcloud sql databases create DATABASE_NAME \
--instance=INSTANCE_NAME
```

Configurez Cloud NAT.

Créez un routeur simple.

gcloud compute routers create NAT_ROUTER_NAME \
    --network=VPC_NETWORK

Configurez la traduction d'adresse réseau.

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

Créer des instances de VM Compute Engine pour exécuter des serveurs proxy SOCKS5
1. Créez l'instance de proxy 1.
```
gcloud compute instances create PROXY_INSTANCE_1 \
--project=PROJECT_ID \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address
```
Selon vos besoins, vous pouvez créer autant d'instances de VM que nécessaire.

Créez une règle de pare-feu pour autoriser l'accès SSH à vos instances de VM.

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

Installez le proxy SOCKS5.

Les étapes détaillées d'installation et de configuration d'un serveur proxy SOCKS5 sortent du cadre de ce document. Vous pouvez installer n'importe quel proxy SOCKS5 de votre choix. Les étapes suivantes expliquent comment installer et configurer le serveur proxy Dante SOCKS5.

Connectez-vous en SSH à votre instance de VM.

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

Installez le serveur proxy Dante SOCKS5.

sudo apt update
sudo apt install dante-server

Vérifiez l'interface du serveur.
```
sudo ip a
```
Créez une sauvegarde de la configuration de Dante.
```
sudo mv /etc/danted.conf /etc/danted.conf.bak
```
Créez un fichier de configuration Dante.
```
sudo nano /etc/danted.conf
```

Copiez la configuration suivante dans le fichier de configuration:

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
}

Redémarrez le serveur Dante et vérifiez l'état.

sudo systemctl restart danted
sudo systemctl status danted

Quittez l'instance de VM.
```
exit
```

Configurez un groupe d'instances non géré.
1. Créez un groupe d'instances non géré.
```
gcloud compute instance-groups unmanaged create INSTANCE_GROUP_NAME
```
  Remarque:Ce tutoriel utilise un groupe d'instances non géré. Vous pouvez créer un groupe d'instances géré pour plus de fiabilité.
2. Ajoutez les instances de VM créées à l'étape 3 au groupe.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME \
--instances=PROXY_INSTANCE_1
```
Créez une vérification de l'état et autorisez le trafic provenant de cette vérification.
1. Créez la vérification de l'état.
```
gcloud compute health-checks create tcp HEALTH_CHECK_NAME \
--port BACKEND_SERVER_PORT --region=REGION
```
  Dans cette commande, définissez BACKEND_SERVER_PORT sur 1080 (port par défaut sur lequel les serveurs proxy SOCKS5 s'exécutent).
2. Créez une règle de pare-feu pour autoriser le trafic provenant de la vérification.
```
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
```

Créez un équilibreur de charge interne L4 et autorisez le trafic provenant de l'équilibreur de charge.

Créez un service de backend.

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

Ajoutez un groupe d'instances au service de backend.

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

Créez une règle de transfert.

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

Créez une règle de pare-feu pour autoriser le trafic interne de l'équilibreur de charge vers le groupe d'instances.

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

Créez le rattachement de service PSC.
1. Créez une règle de pare-feu pour autoriser le trafic provenant du rattachement de service PSC vers l'équilibreur de charge interne créé à l'étape précédente.
```
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. Créez un rattachement de service avec approbation explicite.
```
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
```
  Dans cette commande, LIMIT correspond à la limite de connexion pour le projet. La limite de connexion correspond au nombre de points de terminaison Private Service Connect pouvant se connecter à ce service. Pour savoir comment obtenir le SERVICE_DIRECTORY_PROJECT_ID, consultez Obtenir l'ID de projet de l'annuaire de services.
Créez un rattachement de point de terminaison.
Vous pouvez considérer le rattachement de point de terminaison comme une interface vers le rattachement de service PSC. Vous ne pouvez pas utiliser le rattachement de service PSC directement pour configurer une connectivité privée. Le rattachement de service PSC n'est accessible que via un rattachement de point de terminaison. Vous pouvez également créer le rattachement de point de terminaison en tant qu'adresse IP ou en tant que nom d'hôte. Une fois le rattachement de point de terminaison créé, vous pouvez l'utiliser pour configurer un connecteur pour une connectivité privée. Pour en savoir plus, consultez la section Créer un rattachement de point de terminaison.

Remarque:Vous devez utiliser l'adresse IP ou le nom d'hôte du rattachement de point de terminaison comme adresse du proxy SOCKS5 lors de la création de la connexion.
Vérifiez la configuration de PSC.
Vous pouvez vérifier la connectivité privée en créant une connexion Cloud SQL et en configurant le serveur proxy SOCKS5, comme indiqué dans ce tutoriel. Pour connaître la procédure détaillée de création d'une connexion, consultez la documentation du connecteur spécifique (Cloud SQL pour MySQL, Cloud SQL pour PostgreSQL ou Cloud SQL pour SQL Server). Lors de la création de la connexion, dans la section Destinations (étape 5), sélectionnez Host address (Destination type), puis saisissez l'adresse IP ou le nom d'hôte du rattachement de point de terminaison pour les détails du serveur proxy SOCKS5. Définissez la valeur du port sur 1080, sauf si vous avez configuré un autre port pour le serveur proxy SOCKS5. Si la connexion aboutit, son état passe à Active sur la page Connexions de la console Cloud.

Obtenir l'ID de projet de l'annuaire de services

Nous vous recommandons de créer le rattachement de service PSC de sorte qu'il n'accepte que les requêtes provenant des projets Google Cloud spécifiés. Toutefois, pour ce faire, vous avez besoin de l'ID de projet du répertoire de service associé à votre projet Google Cloud. Pour obtenir l'ID de projet de l'annuaire de services, vous pouvez utiliser l'API List Connections comme indiqué dans l'exemple suivant.

Syntaxe

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"

Remplacez les éléments suivants :

CONNECTORS_PROJECT_ID: ID du projet Google Cloud dans lequel vous avez créé votre connexion.

Exemple

Cet exemple obtient l'ID de projet du répertoire de service pour le projet Google Cloud connectors-test.

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"

L'exécution de cette commande sur le terminal affiche un résultat semblable à celui-ci:

.....
{
  "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
      }
    },
....

Dans l'exemple de résultat, pour le projet Google Cloud connectors-test, l'ID du répertoire de service est abcdefghijk-tp.