Esempio: connettività privata per un'istanza MySQL

Questa pagina spiega, tramite un esempio, come utilizzare Private Service Connect (PSC) per stabilire una connessione tra il sistema di backend MySQL su una rete privata e il runtime di Integration Connectors.

Considerazioni

Quando crei un collegamento a un servizio PSC, considera i seguenti punti chiave:

Il collegamento al servizio PSC e il bilanciatore del carico devono trovarsi in subnet diverse all'interno dello stesso VPC. In particolare, il collegamento al servizio deve trovarsi in una subnet NAT.
Il software in esecuzione sulle VM di backend deve rispondere sia al traffico con bilanciamento del carico sia ai probe di controllo di integrità inviati all'indirizzo IP di ogni regola di forwarding (il software deve rimanere in ascolto su 0.0.0.0:<port> e non su un indirizzo IP specifico assegnato a un'interfaccia di rete). Per maggiori informazioni, consulta Controllo di integrità.
Configurare le regole del firewall per facilitare il flusso del traffico.
Regole in entrata
- Il traffico dalla subnet del collegamento al servizio PSC deve raggiungere la subnet dell'ILB.
- All'interno della subnet dell'ILB, l'ILB dovrebbe essere in grado di inviare traffico al tuo sistema di backend.
- Il probe di controllo di integrità dovrebbe essere in grado di accedere al sistema di backend. I probe di controllo di integrità di Google Cloud hanno un intervallo IP fisso (35.191.0.0/16, 130.211.0.0/22), pertanto questi IP possono essere autorizzati a inviare traffico al tuo server di backend.
Regole in uscita

Il traffico in uscita è abilitato per impostazione predefinita in un progetto Google Cloud, a meno che non siano configurate regole di negazione specifiche.
Tutti i componenti Google Cloud, come il collegamento al servizio PSC e il bilanciatore del carico, devono trovarsi nella stessa regione.
Il tuo sistema di backend non deve essere aperto alla rete pubblica poiché questo potrebbe costituire un problema per la sicurezza. Tuttavia, assicurati che il tuo sistema di backend accetti il traffico nei seguenti scenari:
- Bilanciatori del carico pass-through (ILB TCP/UDP L4): le richieste dagli IP NAT del collegamento del servizio PSC dovrebbero poter raggiungere il tuo backend. Questi IP NAT vengono generati automaticamente. Pertanto, devi consentire l'intero intervallo IP della subnet NAT in cui si trova il collegamento al servizio. Per maggiori informazioni, consulta Subnet Private Service Connect.
- Bilanciatori del carico basati su proxy/HTTP(s) (L4 proxy ILB, L7 ILB): tutte le nuove richieste provengono dal bilanciatore del carico. Di conseguenza, il backend deve accettare richieste dalla subnet proxy della tua rete VPC. Per ulteriori informazioni, vedi Subnet solo proxy per bilanciatori del carico basati su Envoy.

Esempio

Supponiamo di avere un'istanza MySQL ospitata su Google Cloud in una rete VPC privata e di voler esporre l'istanza MySQL al runtime di Integration Connectors.

L'illustrazione seguente mostra l'aspetto del progetto Google Cloud di esempio dopo la configurazione del collegamento al servizio PSC.

Prima di iniziare

Prima di creare un collegamento a un servizio PSC per lo scenario di esempio, esegui queste attività:

Installa gcloud CLI.
Abilita l'API Compute Engine per il tuo progetto Google Cloud.
Per rendere i comandi dell'interfaccia a riga di comando meno dettagliati, puoi impostare i valori per PROJECT_ID, REGION e ZONE utilizzando i seguenti comandi:
```
gcloud config set project PROJECT_ID
gcloud config set compute/region REGION
gcloud config set compute/zone ZONE
```
Per i comandi in questo tutorial, sostituisci BACKEND_SERVER_PORT con 3306, che è la porta predefinita su cui viene eseguito il server MySQL.
Ti consigliamo di creare una nuova rete VPC e utilizzarla per provare questo scenario di esempio. Dopo aver testato lo scenario, puoi eliminare la rete VPC e altre risorse.
Deve esistere almeno una connessione creata da te. La connessione può essere di qualsiasi tipo. Avere una connessione esistente ti consente di recuperare l'ID progetto della directory dei servizi dal runtime di Integration Connectors. Questo ID progetto è obbligatorio per creare il collegamento al servizio PSC.

Creazione di un collegamento a un servizio PSC

Per creare un collegamento a un servizio PSC per lo scenario di esempio, esegui queste attività:

Crea una rete VPC e le subnet richieste.
1. Creare una rete VPC.
```
gcloud compute networks create VPC_NETWORK --project=PROJECT_NAME --subnet-mode=custom --mtu=1460 --bgp-routing-mode=regional
```
2. Aggiungi subnet-1.
```
gcloud compute networks subnets create SUBNET_NAME_1 --network=VPC_NETWORK --range=SUBNET_RANGE_1 --purpose=PRIVATE_SERVICE_CONNECT
```
  Questo comando crea Subnet-1 come subnet NAT che verrà utilizzata esclusivamente per ospitare il collegamento al servizio PSC. Non puoi ospitare altri servizi in questa subnet NAT.
3. Aggiungi subnet-2.
```
gcloud compute networks subnets create SUBNET_NAME_2 --network=VPC_NETWORK --range=SUBNET_RANGE_2
```
Nota: il collegamento al servizio PSC non può esistere nella stessa subnet del bilanciatore del carico. Di conseguenza, sono necessarie due subnet.
Creare un'istanza VM.

Per creare un'istanza VM nel VPC appena creato, esegui questo 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
```
Questo comando crea un'istanza VM con il nome mysql-test.

Nota: per garantire la conformità alle best practice per la sicurezza, l'opzione --no-address crea l'istanza senza un indirizzo IP esterno. Tuttavia, se l'istanza deve accedere ai repository di pacchetti pubblici durante l'installazione di MySQL, devi consentire l'accesso a internet configurando Cloud NAT per gestire la traduzione degli indirizzi di rete.

Configura Cloud NAT.

Crea un router semplice.

gcloud compute routers create NAT_ROUTER_NAME \
    --network=VPC_NETWORK

Configura la Network Address Translation.

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

SSH alla tua istanza VM.

Crea una regola firewall per consentire l'accesso tramite SSH.

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

SSH alla tua istanza VM.

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

Installa il server MySQL. Per istruzioni dettagliate, consulta Installare MySQL.

Connettiti all'istanza MySQL e crea dati di esempio.

Connettersi a MySQL utilizzando il client MySQL.
```
sudo mysql -u root -p
```
Crea un nuovo utente e concedi l'accesso per connetterti da qualsiasi indirizzo host.
```
CREATE USER 'test-user'@'%' IDENTIFIED BY 'test-pass';
GRANT ALL PRIVILEGES ON * . * TO 'test-user'@'%';
FLUSH PRIVILEGES;
```
Questo comando crea un utente con nome utente test-user e password come test-pass.

Crea un database con i dati di esempio.

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');

Esci dal client MySQL.
```
mysql> exit
```
Esci dall'istanza VM.
```
exit
```

Configura un gruppo di istanze non gestite.
1. Creare un gruppo di istanze non gestite.
```
gcloud compute instance-groups unmanaged create INSTANCE_GROUP_NAME
```
  Nota: questo tutorial utilizza un gruppo di istanze non gestite. Puoi creare un gruppo di istanze gestite per una maggiore affidabilità.
2. Aggiungi al gruppo l'istanza VM creata nel passaggio 2.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME --instances=mysql-test
```
Crea un probe per il controllo di integrità e consenti il traffico proveniente dal probe.
1. Creare il probe di controllo di integrità.
```
gcloud compute health-checks create tcp HEALTH_CHECK_NAME --port BACKEND_SERVER_PORT --region=REGION
```
  In questo comando, imposta BACKEND_SERVER_PORT su 3306, che è la porta predefinita su cui viene eseguito il server MySQL.
2. Crea una regola firewall per consentire il traffico dal probe.
```
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
```

Crea un bilanciatore del carico interno L4 e consenti il traffico proveniente dal bilanciatore del carico.

Creare un servizio di backend.

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

Aggiungi il gruppo di istanze al servizio di backend.

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

Crea una regola di forwarding.

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 regola firewall per consentire il traffico interno dal bilanciatore del carico al gruppo di istanze.

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 il collegamento al servizio PSC.
1. Crea una regola firewall per consentire il traffico dal collegamento del servizio PSC al bilanciatore del carico interno creato nel passaggio precedente.
```
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 il collegamento al servizio con approvazione esplicita.
```
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
```
  In questo comando, LIMIT è il limite di connessioni per il progetto. Il limite di connessioni corrisponde al numero di endpoint Private Service Connect del consumer che possono connettersi a questo servizio. Per capire come ottenere SERVICE_DIRECTORY_PROJECT_ID, consulta Recuperare l'ID progetto della directory dei servizi.
Creare un collegamento dell'endpoint.
Puoi considerare il collegamento dell'endpoint come un'interfaccia per il collegamento al servizio PSC. Non puoi utilizzare direttamente il collegamento al servizio PSC per configurare la connettività privata. È possibile accedere al collegamento al servizio PSC solo tramite un collegamento endpoint. Infine, puoi creare il collegamento dell'endpoint come indirizzo IP o come nome host. Dopo aver creato il collegamento dell'endpoint, puoi utilizzarlo quando configuri un connettore per la connettività privata. Per maggiori informazioni, consulta Creare un collegamento dell'endpoint.
Verifica la configurazione di PSC. Puoi verificare la connettività del collegamento al servizio PSC creando una connessione MySQL al database test-db che hai creato per questo tutorial. Per la procedura dettagliata sulla creazione di una connessione MySQL, consulta Creare una connessione MySQL. Quando crei la connessione, nella sezione Destinations (vedi il passaggio 5 in Creare una connessione MySQL), seleziona Destination type come Hostname, quindi inserisci l'indirizzo IP o il nome host dell'endpoint appropriato. Se la creazione della connessione ha esito positivo, lo stato della connessione appena creata sarà Active nella pagina Connessioni della console Cloud.

Recupera l'ID progetto della directory dei servizi

Come best practice, puoi creare il collegamento al servizio PSC in modo che accetti solo le richieste dai progetti Google Cloud specificati. Tuttavia, per farlo, ti serve l'ID della directory dei servizi associata al tuo progetto Google Cloud. Per ottenere l'ID progetto della directory dei servizi, puoi utilizzare l'API List Connections come mostrato nell'esempio seguente.

Sintassi

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"

Sostituisci quanto segue:

CONNECTORS_PROJECT_ID: l'ID del progetto Google Cloud in cui hai creato la connessione.

Esempio

Questo esempio recupera l'ID della directory dei servizi per il progetto 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'esecuzione di questo comando nel terminale visualizza un output simile al seguente:

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

Nell'output di esempio, per il progetto Google Cloud connectors-test, l'ID progetto della directory dei servizi è abcdefghijk-tp.

Collegamento al servizio PSC per altri sistemi di backend

Puoi seguire i passaggi nell'esempio precedente per configurare il collegamento a un servizio PSC per altri sistemi di backend. Tuttavia, dovrai modificare i passaggi 5 e 6 per adattarli al sistema di backend desiderato. Dopo aver installato il sistema di backend nell'istanza VM, aggiungi il sistema di backend al gruppo di istanze e segui i passaggi rimanenti così com'è.