Richiamare un endpoint privato conforme ai Controlli di servizio VPC

Puoi scegliere come target un endpoint privato per le chiamate HTTP dall'esecuzione del flusso di lavoro utilizzando il registro di servizi di Service Directory con Workflows. Creando un endpoint privato all'interno di una rete Virtual Private Cloud (VPC), l'endpoint può essere conforme ai Controlli di servizio VPC.

I Controlli di servizio VPC forniscono un ulteriore livello di difesa della sicurezza indipendente da Identity and Access Management (IAM). Mentre IAM consente il controllo degli accessi basato sull'identità granulare, i Controlli di servizio VPC offrono una maggiore sicurezza perimetrale basata sul contesto, compreso il controllo del traffico in uscita dei dati lungo il perimetro.

Service Directory è un registro di servizi che archivia informazioni sui servizi di rete registrati, tra cui nomi, posizioni e attributi. Indipendentemente dall'infrastruttura, puoi registrare automaticamente i servizi e acquisire i loro dettagli. Ciò consente di scoprire, pubblicare e connettere servizi su larga scala per tutti gli endpoint di servizio.
Una rete VPC fornisce connettività per le istanze di macchine virtuali (VM) e consente di creare endpoint privati all'interno della rete VPC utilizzando indirizzi IP interni. Le chiamate HTTP a una risorsa di rete VPC vengono inviate tramite una rete privata e vengono applicati i Controlli di servizio IAM e VPC.
Controlli di servizio VPC è una funzionalità di Google Cloud che ti consente di configurare un perimetro di servizio e creare un confine per il trasferimento di dati. Puoi utilizzare Controlli di servizio VPC con Workflows per proteggere i servizi e ridurre il rischio di esfiltrazione di dati.

Questo documento mostra come registrare una VM in una rete VPC come endpoint di Service Directory. In questo modo puoi fornire al tuo flusso di lavoro un nome di servizio Service Directory. L'esecuzione del flusso di lavoro utilizza le informazioni recuperate dal registro dei servizi per inviare la richiesta HTTP appropriata, senza uscire verso una rete pubblica.

Questo diagramma offre una panoramica:

Invio di una richiesta HTTP a un numero di porta su un'istanza VM utilizzando le informazioni di Service Directory

A livello generale, devi:

Concedi le autorizzazioni all'agente di servizio Cloud Workflows in modo che possa visualizzare le risorse Service Directory e accedere alle reti VPC utilizzando Service Directory.
Crea una rete VPC per fornire la funzionalità di networking.
Crea una regola firewall VPC in modo da poter consentire o negare il traffico da o verso le istanze VM nella tua rete VPC.
Crea un'istanza VM nella rete VPC. Un'istanza VM di Compute Engine è una macchina virtuale ospitata sull'infrastruttura di Google. I termini Istanza Compute Engine, Istanza VM e VM sono sinonimi e sono usati in modo intercambiabile.
Esegui il deployment di un'applicazione sulla VM. Puoi eseguire un'app sulla tua istanza VM e confermare che il traffico venga gestito come previsto.
Configura Service Directory in modo che l'esecuzione del flusso di lavoro possa richiamare un endpoint di Service Directory.
Crea ed esegui il deployment del tuo flusso di lavoro. Il valore private_service_name nel flusso di lavoro specifica l'endpoint di Service Directory che hai registrato nel passaggio precedente.

Concedi le autorizzazioni all'agente di servizio Cloud Workflows

Alcuni servizi Google Cloud dispongono di account di servizio gestiti da Google che consentono ai servizi di accedere alle tue risorse. Questi account di servizio sono noti come agenti di servizio. Se un'API richiede un agente di servizio, Google lo crea dopo che hai attivato e utilizzato l'API.

Quando esegui il deployment di un flusso di lavoro per la prima volta, l'agente di servizio Cloud Workflows viene creato automaticamente con il seguente formato:

service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com

Puoi creare manualmente l'account di servizio in un progetto senza flussi di lavoro con questo comando:
```
gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID progetto Google Cloud.
Per visualizzare le risorse di Service Directory, concedi il ruolo Visualizzatore Service Directory (servicedirectory.viewer) sul progetto all'agente di servizio Workflows:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.viewer
```
Sostituisci PROJECT_NUMBER con il numero del tuo progetto Google Cloud. Puoi trovare il numero del progetto nella pagina Ti diamo il benvenuto della console Google Cloud o eseguendo questo comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
Per accedere alle reti VPC utilizzando Service Directory, concedi il ruolo Servizio autorizzato Private Service Connect (roles/servicedirectory.pscAuthorizedService) nel progetto all'agente di servizio Workflows:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.pscAuthorizedService
```

Crea una rete VPC

Una rete VPC è una versione virtuale di una rete fisica implementata all'interno della rete di produzione di Google. Fornisce connettività per le istanze VM di Compute Engine.

Puoi creare una rete VPC in modalità automatica o personalizzata. Ogni nuova rete creata deve avere un nome univoco all'interno dello stesso progetto.

Ad esempio, il comando seguente crea una rete VPC in modalità automatica:

gcloud compute networks create NETWORK_NAME \
    --subnet-mode=auto

Sostituisci NETWORK_NAME con un nome per la rete VPC.

Per maggiori informazioni, consulta Creare e gestire le reti VPC.

Crea una regola firewall VPC

Le regole firewall VPC consentono o negano il traffico da o verso le istanze VM in una rete VPC in base a numero di porta, tag o protocollo.

Le regole firewall VPC sono definite a livello di rete e si applicano solo alla rete in cui vengono create. Tuttavia, il nome scelto per una regola deve essere univoco per il progetto.

Ad esempio, il seguente comando crea una regola firewall per una rete VPC specificata e consente il traffico in entrata da qualsiasi indirizzo IPv4, 0.0.0.0/0. Il valore del flag --rules di all rende la regola applicabile a tutti i protocolli e a tutte le porte di destinazione.

gcloud compute firewall-rules create RULE_NAME \
    --network=projects/PROJECT_ID/global/networks/NETWORK_NAME \
    --direction=INGRESS \
    --action=ALLOW \
    --source-ranges=0.0.0.0/0 \
    --rules=all

Sostituisci RULE_NAME con un nome per la regola firewall.

Per maggiori informazioni, consulta Utilizzare le regole firewall VPC.

Crea un'istanza VM nella rete VPC

Le istanze VM includono cluster Google Kubernetes Engine (GKE), istanze dell'ambiente flessibile di App Engine e altri prodotti Google Cloud basati sulle VM di Compute Engine. Per supportare l'accesso alla rete privata, una risorsa di rete VPC può essere un'istanza VM, un indirizzo IP Cloud Interconnect o un bilanciatore del carico interno di livello 4.

Le istanze di Compute Engine possono eseguire immagini pubbliche per Linux e Windows Server fornite da Google, oltre a immagini personalizzate private che puoi creare o importare dai tuoi sistemi esistenti. Puoi anche eseguire il deployment di container Docker.

Puoi scegliere le proprietà delle macchine delle tue istanze, come il numero di CPU virtuali e la quantità di memoria, utilizzando un insieme di tipi di macchine predefinite o creando tipi di macchine personalizzate.

Ad esempio, il seguente comando crea un'istanza VM Linux da un'immagine pubblica con un'interfaccia di rete collegata alla rete VPC creata in precedenza.

Crea e avvia un'istanza VM:

gcloud compute instances create VM_NAME \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --machine-type=e2-micro \
    --network-interface network=projects/PROJECT_ID/global/networks/NETWORK_NAME

Sostituisci VM_NAME con un nome per la VM.

Se ti viene chiesto di confermare la zona per l'istanza, digita y.

Dopo aver creato l'istanza VM, prendi nota dell'indirizzo INTERNAL_IP che viene restituito.
Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Nella colonna Nome, fai clic sul nome dell'istanza VM appropriata.
Se la VM è in esecuzione, fai clic su Arresta per arrestarla.
Per modificare la VM, fai clic su Modifica.
Nella sezione Networking > Firewall, per consentire il traffico HTTP o HTTPS verso la VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

Per questo esempio, seleziona la casella di controllo Consenti traffico HTTP.

Compute Engine aggiunge un tag di rete alla VM che associa la regola firewall alla VM. Crea quindi la corrispondente regola firewall in entrata che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS).
Per salvare le modifiche, fai clic su Salva.
Per riavviare la VM, fai clic su Avvia/Riprendi.

Per maggiori informazioni, consulta Creare e avviare un'istanza VM.

Esegui il deployment di un'applicazione sulla VM

Per testare la configurazione di rete e verificare che il traffico venga gestito come previsto, puoi eseguire il deployment di una semplice app sulla tua VM che rimane in ascolto su una porta.

Ad esempio, i comandi seguenti creano un servizio web Node.js in ascolto sulla porta 3000.

Stabilisci una connessione SSH alla tua istanza VM.
Aggiorna i repository dei pacchetti:
```
sudo apt update
```
Installa NVM, Node.js e npm.

Per ulteriori informazioni, consulta Configurazione di un ambiente di sviluppo Node.js.

Crea in modo interattivo un file package.json:

npm init

Ad esempio:

{
"name": "test",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "hello"
},
"author": "",
"license": "ISC"
}

Installa Express, un framework di applicazioni web per Node.js:
```
npm install express
```
Scrivi il codice dell'app di test:
```
vim app.js
```
L'esempio seguente crea un'app che risponde alle richieste GET al percorso principale (/) con il testo "Hello, world!".
```
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.status(200).send('Hello, world!').end();
});

app.listen(3000, () => {
  console.log('Sample app listening on port 3000.');
});
```
Prendi nota della porta su cui l'app è in ascolto. È necessario utilizzare lo stesso numero di porta durante la configurazione dell'endpoint per il servizio Service Directory.
Verifica che l'app sia in ascolto sulla porta 3000:
```
node app.js
```

Compute Engine offre un'ampia gamma di opzioni di deployment. Per saperne di più, consulta Scegliere una strategia di deployment di Compute Engine per il carico di lavoro.

Configura Service Directory

Per supportare il richiamo di un endpoint privato dall'esecuzione di un flusso di lavoro, devi configurare uno spazio dei nomi di Service Directory, registrare un servizio nello spazio dei nomi e aggiungere un endpoint al servizio.

Ad esempio, i comandi seguenti creano uno spazio dei nomi, un servizio e un endpoint che specificano la rete VPC e l'indirizzo IP interno dell'istanza VM.

Crea uno spazio dei nomi:
```
gcloud service-directory namespaces create NAMESPACE \
    --location=REGION
```
Sostituisci quanto segue:
- NAMESPACE: l'ID dello spazio dei nomi o l'identificatore completo per lo spazio dei nomi.
- REGION: la regione Google Cloud che contiene lo spazio dei nomi, ad esempio us-central1.

Crea un servizio:

gcloud service-directory services create SERVICE \
    --namespace=NAMESPACE \
    --location=REGION

Sostituisci SERVICE con il nome del servizio che stai creando.

Configurare un endpoint.

Nota: assicurati di configurare un solo endpoint per servizio Service Directory. Se è configurato più di un endpoint, Workflows sceglie arbitrariamente un endpoint.
```
gcloud service-directory endpoints create ENDPOINT \
    --namespace=NAMESPACE \
    --service=SERVICE \
    --network=projects/PROJECT_NUMBER/locations/global/networks/NETWORK_NAME \
    --port=PORT_NUMBER \
    --address=IP_ADDRESS \
    --location=REGION
```
Sostituisci quanto segue:
- ENDPOINT: il nome dell'endpoint che stai creando.
- PORT_NUMBER: la porta su cui è in esecuzione l'endpoint, ad esempio 3000.
- IP_ADDRESS: l'indirizzo IPv6 o IPv4 dell'endpoint; si tratta dell'indirizzo IP interno che hai annotato in precedenza.

Per ulteriori informazioni, consulta Configurare Service Directory e Configurare l'accesso alla rete privata.

Crea ed esegui il deployment del flusso di lavoro

La chiamata o il richiamo di un endpoint privato da Workflows avviene tramite una richiesta HTTP. I metodi di richiesta HTTP più comuni hanno una scorciatoia di chiamata (come http.get e http.post), ma puoi effettuare qualsiasi tipo di richiesta HTTP impostando il campo call su http.request e specificando il tipo di richiesta utilizzando il campo method. Per ulteriori informazioni, consulta l'articolo Effettuare una richiesta HTTP.

Crea un file di codice sorgente per il tuo flusso di lavoro:
```
touch call-private-endpoint.JSON_OR_YAML
```
Sostituisci JSON_OR_YAML con yaml o json a seconda del formato del tuo flusso di lavoro.

In un editor di testo, copia il seguente flusso di lavoro (che in questo caso utilizza un protocollo HTTP per il valore url) nel file di codice sorgente:

YAML

main:
  steps:
    - checkHttp:
        call: http.get
        args:
          url: http://IP_ADDRESS
          private_service_name: "projects/PROJECT_ID/locations/REGION/namespaces/NAMESPACE/services/SERVICE"
        result: res
    - ret:
        return: ${res}

JSON

{
  "main": {
    "steps": [
      {
        "checkHttp": {
          "call": "http.get",
          "args": {
            "url": "http://IP_ADDRESS",
            "private_service_name": "projects/PROJECT_ID/locations/REGION/namespaces/NAMESPACE/services/SERVICE"
          },
          "result": "res"
        }
      },
      {
        "ret": {
          "return": "${res}"
        }
      }
    ]
  }
}

Il valore private_service_name deve essere una stringa che specifica il nome di un servizio Service Directory registrato nel seguente formato:

projects/PROJECT_ID/locations/LOCATION/namespaces/NAMESPACE_NAME/services/SERVICE_NAME

Esegui il deployment del flusso di lavoro. A scopo di test, puoi collegare l'account di servizio predefinito di Compute Engine al flusso di lavoro per rappresentarne l'identità:
```
gcloud workflows deploy call-private-endpoint \
    --source=call-private-endpoint.JSON_OR_YAML \
    --location=REGION \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
Attenzione: ti consigliamo di utilizzare l'account di servizio predefinito di Compute Engine solo a scopo di test. Per gli ambienti di produzione, consigliamo vivamente di creare un nuovo account di servizio e di concedergli uno o più ruoli IAM che contengono le autorizzazioni minime richieste e seguono il principio del privilegio minimo.

Esegui il flusso di lavoro:

gcloud workflows run call-private-endpoint \
    --location=REGION

Dovresti vedere un risultato simile al seguente:

argument: 'null'
duration: 0.650784403s
endTime: '2023-06-09T18:19:52.570690079Z'
name: projects/968807934019/locations/us-central1/workflows/call-private-endpoint/executions/4aac88d3-0b54-419b-b364-b6eb973cc932
result: '{"body":"Hello, world!","code":200,"headers":{"Connection":"keep-alive","Content-Length":"21","Content-Type":"text/html;
charset=utf-8","Date":"Fri, 09 Jun 2023 18:19:52 GMT","Etag":"W/\"15-NFaeBgdti+9S7zm5kAdSuGJQm6Q\"","Keep-Alive":"timeout=5","X-Powered-By":"Express"}}'
startTime: '2023-06-09T18:19:51.919905676Z'
state: SUCCEEDED