Exemple: Connectivité privée pour une instance MySQL

À travers un exemple, cette page explique comment utiliser Private Service Connect (PSC) pour établir une connexion entre votre système backend MySQL qui se trouve sur un réseau privé et l'environnement d'exécution Integration Connectors.

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 doivent se trouver dans des sous-réseaux différents au sein du même VPC. Plus précisément, le rattachement de service doit se trouver dans un sous-réseau NAT.
Les logiciels exécutés sur vos VM de backend doivent répondre à la fois au trafic à équilibrage de charge et aux vérifications d'état envoyées à l'adresse IP de chaque règle de transfert (le logiciel doit écouter sur 0.0.0.0:<port> et non sur une adresse IP spécifique attribuée à une interface réseau). Pour en savoir plus, consultez la section Vérification de l'état.
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, celui-ci doit pouvoir envoyer du trafic vers votre système backend.
- La vérification de l'état doit pouvoir accéder à votre système backend. 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 à votre serveur backend.
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 votre système backend accepte 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 votre backend. 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, votre backend doit 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.

Exemple

Supposons que vous disposez d'une instance MySQL hébergée sur Google Cloud dans un réseau VPC privé et que vous souhaitez exposer cette instance MySQL à l'environnement d'exécution Integration Connectors.

L'illustration suivante montre à quoi ressemblera l'exemple de projet Google Cloud une fois le rattachement de service PSC configuré.

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 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 3306, qui est le port par défaut sur lequel le serveur MySQL 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_NAME --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éez une instance de VM.

Pour créer une instance de VM dans le VPC que vous venez de créer, exécutez la commande suivante:
```
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
```
Cette commande crée une instance de VM nommée mysql-test.

Remarque:Conformément aux bonnes pratiques de sécurité, l'option --no-address crée l'instance sans adresse IP externe. Toutefois, si votre instance doit accéder aux dépôts de packages publics lors de l'installation de MySQL, vous devez autoriser l'accès à Internet en configurant Cloud NAT pour gérer la traduction d'adresse réseau.

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

Connectez-vous en SSH à votre instance de VM.

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

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

Connectez-vous en SSH à votre instance de VM.

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

Installer le serveur MySQL Pour obtenir des instructions détaillées, consultez Installer MySQL.
Se connecter à l'instance MySQL et créer des exemples de données
1. Connectez-vous à MySQL en utilisant le client MySQL.
```
sudo mysql -u root -p
```
2. Créez un utilisateur et accordez-lui l'accès pour se connecter depuis n'importe quelle adresse hôte.
```
CREATE USER 'test-user'@'%' IDENTIFIED BY 'test-pass';
GRANT ALL PRIVILEGES ON * . * TO 'test-user'@'%';
FLUSH PRIVILEGES;
```
  Cette commande crée un utilisateur avec le nom d'utilisateur test-user et le mot de passe test-pass.
3. Créer une base de données avec les exemples de données
```
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. Quittez le client MySQL.
```
mysql> exit
```
5. 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 l'instance de VM créée à l'étape 2 au groupe.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME --instances=mysql-test
```
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 3306, qui est le port par défaut sur lequel le serveur MySQL s'exécute.
2. Créez une règle de pare-feu pour autoriser le trafic provenant de la vérification.
```
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
```

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 VPC_NETWORK-allow-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 VPC_NETWORK-allow-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.
Vérifiez la configuration de PSC. Vous pouvez vérifier la connectivité du rattachement de service PSC en créant une connexion MySQL à la base de données test-db que vous avez créée pour ce tutoriel. Pour connaître la procédure détaillée permettant de créer une connexion MySQL, consultez Créer une connexion MySQL. Lors de la création de la connexion, dans la section Destinations (voir l'étape 5 de la section Créer une connexion MySQL), sélectionnez la Destination type comme Hostname, puis saisissez le nom d'hôte ou l'adresse IP du point de terminaison approprié. 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.

Rattachement de service PSC pour les autres systèmes backend

Vous pouvez suivre les étapes de l'exemple précédent afin de configurer un rattachement de service PSC pour d'autres systèmes backend. Vous devrez toutefois modifier les étapes 5 et 6 de façon à utiliser le système backend souhaité. Après avoir installé votre système backend dans l'instance de VM, ajoutez-le au groupe d'instances et suivez les étapes restantes telles quelles.