Configura l'uscita VPC diretta per le funzioni di 2ª generazione

L'uscita VPC diretta consente di instradare il traffico dalla funzione Cloud Run Functions (2ª generazione.) direttamente alla rete VPC.

Limitazioni

  • L'uscita VPC diretta non è disponibile per le funzioni di 1ª generazione.
  • Non puoi utilizzare contemporaneamente i connettori di accesso VPC serverless e l'uscita VPC diretto. Per maggiori dettagli, consulta Confronto tra l'uscita VPC diretta e i connettori VPC.

Prima di iniziare

  • Abilita l'API Cloud Functions.
  • Installa Google Cloud CLI, quindi inizializzala eseguendo gcloud init.

  • Aggiorna i componenti di gcloud alla versione 545.0.0 o successive: 

    gcloud components update

  • Se non hai ancora una rete VPC nel tuo progetto, creane una.

  • (Facoltativo) Se la tua funzione deve accedere ad API e servizi Google utilizzando i relativi indirizzi IP interni, abilita l'accesso privato Google nella subnet che utilizzi per l'uscita VPC diretta.

Configurare le autorizzazioni IAM

Per autorizzare l'uscita VPC diretta, chiedi all'amministratore di concedere il ruolo Invoker Cloud Run (roles/run.invoker) al account di servizio della tua funzione.

Assicurati che Cloud Run abbia accesso alla rete VPC utilizzando uno dei seguenti metodi:

  • Ruolo service agent Cloud Run: per impostazione predefinita, il service agent Cloud Run dispone del ruolo service agent Cloud Run (roles/run.serviceAgent) che contiene le autorizzazioni necessarie.

  • Autorizzazioni personalizzate: per un controllo più granulare, concedi al service agent Cloud Run le seguenti autorizzazioni aggiuntive sul progetto:

    • compute.networks.get
    • compute.subnetworks.get
    • compute.subnetworks.use sul progetto o sulla subnet specifica
    • compute.addresses.get
    • compute.addresses.list
    • compute.addresses.create (obbligatorio solo per le subnet a doppio stack con IPv6 esterno)
    • compute.addresses.delete (obbligatorio solo per le subnet a doppio stack con IPv6 esterno)
    • compute.addresses.createInternal
    • compute.addresses.deleteInternal
    • compute.regionOperations.get

  • Ruolo Utente di rete Compute: se non utilizzi il ruolo Service Agent Cloud Run predefinito o le autorizzazioni personalizzate, concedi il ruolo Utente di rete Compute (roles/compute.networkUser) al account di servizio Service Agent Cloud Run. Le subnet con IPv6 esterno richiedono anche il ruolo Compute Public IP Admin (roles/compute.publicIpAdmin).

    Ad esempio, per concedere il ruolo Utente di rete Compute, esegui questo comando:

    gcloud projects add-iam-policy-binding PROJECT_ID \
--member "serviceAccount:service-PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com" \
--role "roles/compute.networkUser"

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto.
    • PROJECT_NUMBER: il numero del progetto in cui esegui il deployment della funzione Cloud Run.

Configura l'uscita VPC diretto

Configura l'uscita VPC diretto per le funzioni di 2ª generazione nuove o esistenti.

gcloud

  1. Per configurare l'uscita VPC diretto quando esegui il deployment di una funzione, utilizza il comando gcloud beta functions deploy con i flag per le impostazioni di rete.

    gcloud beta functions deploy FUNCTION_NAME \
    --source . \
    --runtime RUNTIME \
    --trigger-http \
    --region REGION \
    --network=NETWORK \
    --subnet=SUBNET \
    --network-tags=NETWORK_TAG_NAMES \
    --direct-vpc-egress=EGRESS_SETTING

    Sostituisci quanto segue:

    • FUNCTION_NAME: il nome della funzione.
    • RUNTIME: il runtime della funzione, ad esempio nodejs20.
    • REGION: la regione in cui esegui il deployment della funzione.
    • (Facoltativo) NETWORK con il nome della tua rete VPC. Specifica una rete VPC o una subnet oppure entrambe. Se specifichi solo una rete, la subnet utilizza lo stesso nome della rete.
    • (Facoltativo) SUBNET con il nome della subnet. Specifica una rete VPC o una subnet oppure entrambe. Se specifichi solo una rete, la subnet utilizza lo stesso nome della rete. Puoi eseguire il deployment o l'esecuzione di più funzioni nella stessa subnet.
    • (Facoltativo) NETWORK_TAG_NAMES con i nomi separati da virgole dei tag di rete che vuoi associare a una funzione. Ogni funzione può avere tag di rete diversi, ad esempio network-tag-2.
    • EGRESS_SETTING con un valore di impostazione del traffico in uscita:
      • all: predefinito. Invia tutto il traffico in uscita attraverso la rete VPC.
      • private-ranges-only: Invia solo il traffico agli indirizzi interni tramite la rete VPC.

  2. (Facoltativo) Per rimuovere tutte le impostazioni di uscita VPC diretta da una funzione, esegui nuovamente il deployment della funzione con i flag --clear-network e --clear-network-tags.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Per configurare l'uscita VPC diretto, utilizza il provider Terraform google-beta.

Utilizzando l'esempio di uscita VPC diretto di Cloud Run Functions (2ª generazione.) come punto di partenza, aggiorna i seguenti campi:

  • service_config.network: il nome della tua rete VPC.
  • service_config.subnetwork: il nome della tua subnet VPC.
  • service_config.direct_vpc_egress: il traffico da inviare alla rete VPC. VPC_EGRESS_ALL_TRAFFIC invia tutto il traffico in uscita attraverso la rete VPC. VPC_EGRESS_PRIVATE_RANGES_ONLY invia il traffico solo agli intervalli di indirizzi IP privati alla rete VPC.

Esempio: chiamare un servizio interno da una funzione

Questo esempio mostra come creare un servizio Cloud Run interno e poi chiamarlo da una funzione Cloud Run Functions (2ª generazione.) che utilizza l'uscita VPC diretto.

Crea il servizio di backend interno

  1. Crea una nuova directory per il servizio di backend e passa a questa directory:

    mkdir backend-service
cd backend-service

  2. Crea un file package.json con il seguente contenuto:

    {
    "name": "backend-service",
    "version": "1.0.0",
    "description": "",
    "scripts": {
        "start": "node index.js"
    },
    "dependencies": {
        "express": "^4.18.1"
    }
}

  3. Crea un file index.js con il seguente contenuto:

    const express = require('express');
const app = express();

app.get('/', (req, res) => {
    res.send("hello world");
});

const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
    console.log(`helloworld: listening on port ${port}`);
});

  4. Esegui il deployment del servizio in Cloud Run con l'ingresso interno:

    gcloud run deploy backend \
    --source . \
    --no-allow-unauthenticated \
    --region=REGION \
    --ingress internal

    Sostituisci REGION con la tua regione, ad esempio us-west1.

  5. Salva l'URL del nuovo servizio. Ti servirà nella prossima sezione.

Crea ed esegui il deployment della funzione

  1. Crea una nuova directory per la funzione e accedi alla directory:

    cd ..
mkdir dvpc-function
cd dvpc-function

  2. Crea un file package.json con il seguente contenuto:

    {
  "name": "sample-http",
  "version": "0.0.1",
  "dependencies": {
    "axios": "0.21.1",
    "@google-cloud/functions-framework": "^3.0.0"
  }
}

  3. Crea un file index.js con il seguente contenuto. Questo codice effettua una richiesta autenticata al servizio di backend interno.

    const axios = require('axios');
const functions = require('@google-cloud/functions-framework');

const callVPCService = async (req, res) => {
  const backendUrl = process.env.BACKEND_URL;

  if (!backendUrl) {
    console.error('BACKEND_URL environment variable not set.');
    res.status(500).send('BACKEND_URL not configured.');
    return;
  }

  try {
    const metadataServerURL = 'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=';
    const tokenUrl = metadataServerURL + backendUrl;

    const tokenResponse = await axios.get(tokenUrl, {
      headers: {
        'Metadata-Flavor': 'Google',
      },
    });
    const token = tokenResponse.data;

    const response = await axios.get(backendUrl, {
      headers: {
        Authorization: `bearer ${token}`,
      },
});

res.status(200).send(`Response from backend: ${response.data}`);
  } catch (error) {
    console.error(`Error calling backend service: ${error.message}`);
    res.status(500).send(`Error calling backend: ${error.message}`);
  }
};

functions.http('callVPCService', callVPCService);

  4. Esegui il deployment della funzione con il traffico in uscita VPC diretto configurato per instradare tutto il traffico alla tua rete VPC predefinita:

    gcloud beta functions deploy my-2ndgen-function \
  --source . \
  --runtime nodejs20 \
  --trigger-http \
  --entry-point callVPCService \
  --network=default \
  --subnet=default \
  --direct-vpc-egress=all \
  --region=REGION \
  --allow-unauthenticated \
  --set-env-vars BACKEND_URL=BACKEND_URL

    Sostituisci quanto segue:

    • REGION: la regione in cui hai eseguito il deployment del servizio di backend.
    • BACKEND_URL: l'URL del servizio di backend che hai creato.

  5. Dopo il deployment della funzione, richiamala visitando il relativo URL. La funzione chiama il servizio di backend interno e restituisce la relativa risposta.

Passaggi successivi