Cette page a été traduite par l'API Cloud Translation.

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

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

Remarques

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 différents sous-réseaux 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 est requis pour le trafic entrant provenant de l'équilibreur de charge et des vérifications d'état. Pour en savoir plus, consultez Vérification de l'état.
Le trafic provenant de l'équilibreur de charge et de la sonde de vérification de l'état doit être envoyé au 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.
- Dans le sous-réseau de l'ILB, l'ILB doit pouvoir envoyer du trafic aux serveurs proxy SOCKS5.
- La vérification d'état doit pouvoir accéder aux serveurs proxy SOCKS5. Les sondes de vérification d'état Google Cloud ont une plage d'adresses IP fixe (35.191.0.0/16, 130.211.0.0/22). Par conséquent, ces adresses IP peuvent ê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 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 des problèmes de sécurité. Toutefois, Assurez-vous que vos serveurs proxy SOCKS5 acceptent le trafic dans les cas suivants:
- Équilibreurs de charge passthrough (ILB TCP/UDP de couche 4) : les requêtes provenant des adresses NAT de l'attachement de service PSC doivent pouvoir atteindre vos serveurs proxy SOCKS5. Ces adresses IP NAT sont générées automatiquement. Vous devez donc autoriser l'intégralité de la plage d'adresses IP du sous-réseau NAT 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) (ILB 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 section Sous-réseaux proxy réservés aux équilibreurs de charge basés sur Envoy.

Configurer PSC pour une instance Cloud SQL

Les connecteurs d'intégration utilisent le proxy d'authentification Cloud SQL pour se connecter à une instance Cloud SQL. Le proxy d'authentification Cloud SQL prend en charge le chaînage via un proxy SOCKS5, ce qui vous permet de transférer le trafic chiffré du proxy d'authentification Cloud SQL vers l'instance Cloud SQL de destination. Vous avez donc besoin de serveurs proxy SOCKS5 pour vous connecter à une instance Cloud SQL privée.

Le schéma suivant montre l'aspect de votre projet Google Cloud après l'exécution Le rattachement de service PSC est 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 à instance Cloud SQL via la Accès privé aux services Les serveurs proxy SOCKS5 se trouvent dans un groupe d'instances Compute Engine non géré. Vous pouvez déterminer le nombre d'instances de proxy en fonction du trafic entrant prévu.

Comment le trafic circule-t-il dans l'exemple ?

Les connecteurs d'intégration envoient une requête à une pièce jointe 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 utilise l'équilibreur de charge 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 autre port, ce port doit également être ouvert pour l'écoute sur l'ILB.
Les serveurs proxy SOCKS5 transmettent la requête à l'instance Cloud SQL.

Avant de commencer

Avant de créer une pièce jointe de service PSC pour l'exemple de scénario, effectuez les tâches suivantes :

Installer gcloud CLI
activer l'API Compute Engine ; et l'API Service Networking pour votre projet Google Cloud.
Pour rendre vos commandes CLI moins détaillées, vous pouvez définir les valeurs de 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 s'exécute un serveur proxy SOCKS5.
Nous vous recommandons 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. Avoir une connexion existante vous permet de récupérer l'ID de projet de l'annuaire de services à 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 le sous-réseau 1 (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 pas héberger d'autre service dans ce sous-réseau NAT.
3. Ajoutez le sous-réseau 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 sur le même sous-réseau que l'équilibreur de charge. Vous avez donc besoin de deux sous-réseaux.
Créez 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éer un 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 l'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 bases de données compatibles consultez la page Version de la base de données SQL.
  
  Cette commande crée un utilisateur par défaut pour votre instance Cloud SQL. Vous trouverez ci-dessous 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 à laquelle 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
```
En fonction de vos besoins, vous pouvez créer autant d'instances de VM que nécessaire.

Créez une règle de pare-feu autorisant 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 ne sont pas incluses dans ce document. Vous pouvez installer le proxy SOCKS5 de votre choix. Les étapes suivantes montrent 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 SOCKS5 Dante.

sudo apt update
sudo apt install dante-server

Vérifiez l'interface du serveur.
```
sudo ip a
```
Créez une sauvegarde de la configuration 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 améliorer la 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 qui en découle.

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, qui est le port par défaut sur lequel les serveurs proxy SOCKS5 s'exécutent.

Créez une règle de pare-feu pour autoriser le trafic provenant de la sonde.

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 le 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 de l'attachement 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 une 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 est la limite de connexions pour le projet. La limite de connexion est le nombre de points de terminaison client Private Service Connect pouvant se connecter à ce service. Pour savoir comment obtenir l'SERVICE_DIRECTORY_PROJECT_ID, consultez Obtenir l'ID de projet du répertoire de services.
Créez un rattachement de point de terminaison.
Vous pouvez considérer le rattachement de point de terminaison comme une interface du rattachement de service PSC. Vous ne pouvez pas utiliser directement le rattachement de service PSC pour configurer la connectivité privée. Rattachement de service PSC n'est accessible que via un rattachement de point de terminaison. Vous pouvez aussi créer le rattachement de point de terminaison soit en tant qu’adresse IP ou en tant que nom d’hôte. Après avoir créé le rattachement de point de terminaison, vous pouvez lorsque vous configurez un connecteur pour une connectivité privée. Pour en savoir plus, consultez Créez un rattachement de point de terminaison.

Remarque : Vous devez utiliser l'adresse IP ou le nom d'hôte de l'attachement du point de terminaison comme adresse du proxy SOCKS5 lorsque vous créez la connexion.
Vérifiez la configuration de PSC.
Vous pouvez vérifier la connectivité privée en créant une connexion Cloud SQL et la configuration du serveur proxy SOCKS5, comme illustré dans ce tutoriel. Pour connaître la procédure détaillée de création d'une connexion, consultez les (Cloud SQL pour MySQL, Cloud SQL pour PostgreSQL, ou Cloud SQL pour SQL Server). Lorsque vous créez la connexion, dans la section Destinations (à l'étape 5), sélectionnez Destination type comme Host address, 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 port différent pour le serveur proxy SOCKS5. Si la création de la connexion aboutit, l'état de la connexion nouvellement créée est Active sur la page Connexions de la console Cloud.

Obtenir l'ID du projet du répertoire 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 services associé à votre projet Google Cloud. Pour obtenir l'ID de projet de l'annuaire de services, vous pouvez utiliser l'API List Connections, comme illustré ci-dessous à titre d'exemple.

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 services 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 projet du répertoire de service est abcdefghijk-tp.