Esempio: connettività privata per un'istanza Cloud SQL

In questa pagina viene spiegato come utilizzare Private Service Connect (PSC) per stabilire una connessione tra l'istanza Cloud SQL abilitata per Private Service Access (PSA) e il runtime di Integration Connectors. L'istanza Cloud SQL può essere uno dei seguenti tipi:

Considerazioni

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

Il collegamento al servizio PSC e il bilanciatore del carico vengono creati in subnet diverse all'interno dello stesso VPC. In particolare, il collegamento al servizio viene sempre creato in una subnet NAT.
I server proxy SOCKS5 devono essere associati all'indirizzo IP 0.0.0.0:<port> perché è richiesto per il traffico in entrata dal bilanciatore del carico e dai probe di controllo di integrità. Per maggiori informazioni, consulta Controllo di integrità.
Il traffico proveniente dal bilanciatore del carico e dal probe di controllo di integrità deve essere inviato alla stessa porta.
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 di ILB, ILB dovrebbe essere in grado di inviare traffico ai server proxy SOCKS5.
- Il probe di controllo di integrità dovrebbe essere in grado di accedere ai server proxy SOCKS5. 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 ai server proxy SOCKS.
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 i server proxy SOCKS5 accettino il traffico nei seguenti scenari:
- Bilanciatori del carico pass-through (L4 TCP/UDP ILB): le richieste dagli IP NAT del collegamento del servizio PSC dovrebbero poter raggiungere i server proxy SOCKS5. 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. Pertanto, i server proxy SOCKS5 devono accettare richieste dalla subnet proxy della tua rete VPC. Per ulteriori informazioni, vedi Subnet solo proxy per bilanciatori del carico basati su Envoy.

configura PSC per un'istanza Cloud SQL

Integration Connectors utilizza il proxy di autenticazione Cloud SQL per connettersi a un'istanza Cloud SQL. Il proxy di autenticazione Cloud SQL supporta il concatenamento tramite un proxy SOCKS5, che consente di inoltrare il traffico criptato dal proxy di autenticazione Cloud SQL all'istanza Cloud SQL di destinazione. Quindi, hai bisogno di server proxy SOCKS5 per connetterti a un'istanza Cloud SQL privata.

Il seguente diagramma mostra l'aspetto del tuo progetto Google Cloud dopo la configurazione del collegamento al servizio PSC per la configurazione di un'istanza Cloud SQL di esempio.

In questo esempio, i server proxy SOCKS5 sono esposti tramite il collegamento a un servizio in modo che PSC possa connettersi in modo sicuro a un'istanza Cloud SQL. I server proxy SOCKS hanno accesso a un'istanza Cloud SQL tramite l' accesso privato ai servizi. I server proxy SOCKS5 si trovano in un gruppo di istanze Compute Engine non gestito e puoi decidere il numero di istanze proxy in base al traffico in entrata previsto.

Qual è il flusso del traffico nell'esempio?

Integration Connectors invia una richiesta al collegamento a un servizio.
Il collegamento al servizio inoltra la richiesta a un ILB L4.
L4 ILB invia una richiesta ai server proxy SOCKS5.
L'ILB ha le regole di forwarding ed esegue il port forwarding. Per impostazione predefinita, un proxy SOCKS5 rimane in ascolto sulla porta 1080. Tuttavia, se i server proxy SOCKS5 sono in ascolto su una porta diversa, anche quella porta deve essere aperta per l'ascolto sull'ILB.
I server proxy SOCKS5 inoltrano la richiesta all'istanza Cloud SQL.

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 e l'API Service Networking 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 1080, che è la porta predefinita su cui viene eseguito un server proxy SOCKS5.
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_ID --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 Cloud SQL privata.
1. Configurare l'accesso privato ai servizi.
  1. Alloca un intervallo di indirizzi 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. Creare una connessione privata.
```
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=google-managed-services-VPC_NETWORK \
--network=VPC_NETWORK \
--project=PROJECT_ID
```
2. Crea un' istanza Cloud SQL con un IP privato.
```
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
```
  Specifica DATABASE_VERSION in base al tipo di istanza che vuoi creare. Puoi creare un'istanza di tipo MySQL, PostgreSQL o SQL Server. Per l'elenco di tutte le versioni del database supportate, vedi Versione database SQL.
  
  Questo comando crea un utente predefinito per la tua istanza Cloud SQL. Di seguito sono riportati gli utenti predefiniti che verranno creati per le varie istanze Cloud SQL *:
  - Cloud SQL per MySQL - root
  - Cloud SQL per SQL Server - sqlserver
  - Cloud SQL per PostgreSQL - postgres
3. (Facoltativo) Se non vuoi utilizzare l'utente predefinito, crea un nuovo utente per l'istanza Cloud SQL appena creata.
```
gcloud sql users create USER --host=% --instance=INSTANCE_NAME \
--password=PASSWORD
```
  Assicurati che l'utente disponga di tutte le autorizzazioni necessarie per accedere al database che creerai nel passaggio successivo.
4. Creare un database nell'istanza Cloud SQL appena creata.
```
gcloud sql databases create DATABASE_NAME \
--instance=INSTANCE_NAME
```

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

Crea istanze VM di Compute Engine per l'esecuzione di server proxy SOCKS5.
1. Crea l'istanza proxy 1.
```
gcloud compute instances create PROXY_INSTANCE_1 \
--project=PROJECT_ID \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address
```
In base alle tue esigenze, puoi creare tutte le istanze VM necessarie.

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

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

Installa il proxy SOCKS5.

I passaggi dettagliati per installare e configurare un server proxy SOCKS5 non rientrano nell'ambito di questo documento e puoi installare qualsiasi proxy SOCKS5 di tua scelta. I passaggi seguenti mostrano come installare e configurare il server proxy Dante SOCKS5.

SSH alla tua istanza VM.

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

Installa il server proxy Dante SOCKS5.

sudo apt update
sudo apt install dante-server

Controlla l'interfaccia del server.
```
sudo ip a
```

Crea il backup della configurazione Dante.

sudo mv /etc/danted.conf /etc/danted.conf.bak

Crea un nuovo file di configurazione Dante.
```
sudo nano /etc/danted.conf
```

Copia la seguente configurazione nel file di configurazione:

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
}

Riavvia il server Dante e controlla lo stato.

sudo systemctl restart danted
sudo systemctl status danted

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 le istanze VM create nel passaggio 3.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME \
--instances=PROXY_INSTANCE_1
```
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 1080, che è la porta predefinita su cui vengono eseguiti i server proxy SOCKS5.
2. Crea una regola firewall per consentire il traffico dal probe.
```
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
```

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 FIREWALL_RULE_NAME_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 FIREWALL_RULE_NAME_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.

Nota: quando crei la connessione, devi utilizzare l'indirizzo IP o il nome host del collegamento dell'endpoint come indirizzo del proxy SOCKS5.
Verifica la configurazione di PSC.
Puoi verificare la connettività privata creando una connessione Cloud SQL e configurando il server proxy SOCKS5 come mostrato in questo tutorial. Per la procedura dettagliata sulla creazione di una connessione, consulta la documentazione specifica del connettore (Cloud SQL per MySQL, Cloud SQL per PostgreSQL o Cloud SQL per SQL Server). Quando crei la connessione, nella sezione Destinations (nel passaggio 5), seleziona Destination type come Host address, quindi inserisci l'indirizzo IP o il nome host del collegamento dell'endpoint per i dettagli del server proxy SOCKS5. Imposta il valore della porta su 1080, a meno che tu non abbia configurato una porta diversa per il server proxy SOCKS5. 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.