Si vous créez une fonction, consultez le guide de démarrage rapide de la console sur Cloud Run.

Configurer la sortie VPC directe pour les fonctions de deuxième génération

La sortie VPC directe vous permet d'acheminer le trafic de votre fonction Cloud Run Functions (2e génération) directement vers votre réseau VPC.

Limites

La sortie VPC directe n'est pas disponible pour les fonctions de première génération.
Vous ne pouvez pas utiliser la sortie VPC directe et les connecteurs d'accès au VPC sans serveur en même temps. Pour en savoir plus, consultez Comparer la sortie VPC directe et les connecteurs VPC.

Avant de commencer

Activez l'API Cloud Functions.
Installez Google Cloud CLI, puis initialisez-la en exécutant gcloud init.
Mettez à jour les composants gcloud vers la version 545.0.0 ou ultérieure :
```
gcloud components update
```
Si vous n'avez pas encore de réseau VPC dans votre projet, créez-en un.
Facultatif : Si votre fonction doit accéder aux API et services Google à l'aide de leurs adresses IP internes, activez l'accès privé à Google sur le sous-réseau que vous utilisez pour la sortie VPC directe.

Configurer les autorisations IAM

Pour autoriser la sortie VPC directe, demandez à votre administrateur d'accorder le rôle Demandeur Cloud Run (roles/run.invoker) au compte de service de votre fonction.

Assurez-vous que Cloud Run a accès au réseau VPC à l'aide de l'une des méthodes suivantes :

Rôle d'agent de service Cloud Run : par défaut, l'agent de service Cloud Run dispose du rôle Agent de service Cloud Run (roles/run.serviceAgent) contenant les autorisations nécessaires.
Autorisations personnalisées : pour un contrôle plus précis, accordez à l'agent de service Cloud Run les autorisations supplémentaires suivantes sur le projet :
- compute.networks.get
- compute.subnetworks.get
- compute.subnetworks.use sur le projet ou le sous-réseau spécifique
- compute.addresses.get
- compute.addresses.list
- compute.addresses.create (obligatoire uniquement pour les sous-réseaux à double pile avec IPv6 externe)
- compute.addresses.delete (obligatoire uniquement pour les sous-réseaux à double pile avec IPv6 externe)
- compute.addresses.createInternal
- compute.addresses.deleteInternal
- compute.regionOperations.get
Rôle d'utilisateur de réseau Compute : si vous n'utilisez pas le rôle d'agent de service Cloud Run par défaut ni les autorisations personnalisées, attribuez le rôle d'utilisateur de réseau Compute (roles/compute.networkUser) sur le compte de service de l'agent de service Cloud Run. Les sous-réseaux avec IPv6 externe nécessitent également le rôle Administrateur d'adresse IP publique Compute (roles/compute.publicIpAdmin).

Par exemple, pour accorder le rôle d'utilisateur du réseau Compute, exécutez la commande suivante :
```
gcloud projects add-iam-policy-binding PROJECT_ID \
--member "serviceAccount:service-PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com" \
--role "roles/compute.networkUser"
```
Remplacez les éléments suivants :
- PROJECT_ID : par l'ID du projet.
- PROJECT_NUMBER : numéro du projet dans lequel vous déployez votre fonction Cloud Run.

Configurer la sortie VPC directe

Configurez la sortie VPC directe pour les fonctions de deuxième génération nouvelles ou existantes.

gcloud

Pour configurer la sortie VPC direct lorsque vous déployez une fonction, utilisez la commande gcloud beta functions deploy avec des indicateurs pour vos paramètres réseau.
```
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
```
Remplacez les éléments suivants :
- FUNCTION_NAME : nom de votre fonction.
- RUNTIME : environnement d'exécution de votre fonction, par exemple nodejs20.
- REGION : région dans laquelle vous déployez votre fonction.
- Facultatif : NETWORK par le nom de votre réseau VPC. Spécifiez un réseau VPC ou un sous-réseau, ou les deux. Si vous ne spécifiez qu'un réseau, le sous-réseau utilise le même nom que le réseau.
- Facultatif : Remplacez SUBNET par le nom de votre sous-réseau. Spécifiez un réseau VPC ou un sous-réseau, ou les deux. Si vous ne spécifiez qu'un réseau, le sous-réseau utilise le même nom que le réseau. Vous pouvez déployer ou exécuter plusieurs fonctions sur le même sous-réseau.
- Facultatif : NETWORK_TAG_NAMES par les noms des tags réseau séparés par une virgule que vous souhaitez associer à une fonction. Chaque fonction peut avoir des tags réseau différents, tels que network-tag-2.
- EGRESS_SETTING par une valeur de paramètre de sortie :
  - all : valeur par défaut. Envoie tout le trafic sortant via le réseau VPC.
  - private-ranges-only : achemine uniquement le trafic destiné à des adresses internes via le réseau VPC.
Facultatif : Pour supprimer tous les paramètres de sortie VPC directe d'une fonction, redéployez la fonction avec les indicateurs --clear-network et --clear-network-tags.

Terraform

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez Commandes Terraform de base.

Pour configurer la sortie VPC directe, utilisez le fournisseur Terraform google-beta.

En partant de l'exemple de sortie VPC directe de Cloud Run Functions (2nd gen), mettez à jour les champs suivants :

service_config.network : nom de votre réseau VPC.
service_config.subnetwork : nom de votre sous-réseau VPC.
service_config.direct_vpc_egress : trafic à envoyer au réseau VPC. VPC_EGRESS_ALL_TRAFFIC envoie tout le trafic sortant via le réseau VPC. VPC_EGRESS_PRIVATE_RANGES_ONLY n'envoie le trafic vers les plages d'adresses IP privées qu'au réseau VPC.

Exemple : Appeler un service interne à partir d'une fonction

Cet exemple montre comment créer un service Cloud Run interne, puis l'appeler à partir d'une fonction Cloud Run Functions (2e génération) qui utilise la sortie VPC directe.

Créer le service de backend interne

Créez un répertoire pour le service de backend et accédez-y :
```
mkdir backend-service
cd backend-service
```

Créez un fichier package.json avec le contenu suivant :

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

Créez un fichier index.js avec le contenu suivant :

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}`);
});

Déployez le service sur Cloud Run avec un équilibreur de charge d'entrée interne :

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

Remplacez REGION par votre région, par exemple us-west1.

Enregistrez l'URL du nouveau service. Vous en aurez besoin dans la section suivante.

Créer et déployer la fonction

Créez un répertoire pour la fonction et accédez-y :
```
cd ..
mkdir dvpc-function
cd dvpc-function
```

Créez un fichier package.json avec le contenu suivant :

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

Créez un fichier index.js avec le contenu suivant. Ce code envoie une requête authentifiée au service de backend interne.

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

Déployez la fonction avec la sortie VPC directe configurée pour acheminer tout le trafic vers votre réseau VPC par défaut :

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

Remplacez les éléments suivants :

REGION : région dans laquelle vous avez déployé le service de backend.
BACKEND_URL : URL du service de backend que vous avez créé.

Une fois la fonction déployée, appelez-la en accédant à son URL. La fonction appelle le service de backend interne et renvoie sa réponse.

Étapes suivantes

En savoir plus sur la sortie VPC directe et l'attribution d'adresses IP
Consultez les conseils de dépannage.
Comparez les méthodes de sortie dans Se connecter à un réseau VPC.
Consultez la documentation de référence sur la commande gcloud beta functions deploy.