Utiliser Remote Config côté serveur avec Cloud Functions et Vertex AI

Ce guide explique comment commencer à utiliser Cloud Functions de deuxième génération Cloud Functions avec Remote Config côté serveur Remote Config pour effectuer des appels côté serveur à l'API Vertex AI GeminiVertex AI Gemini API.

Dans ce tutoriel, vous allez ajouter Remote Config à une fonction de type chatbot qui utilise un modèle Gemini pour répondre aux questions des utilisateurs. Remote Config gérera les entrées Gemini API (y compris un prompt que vous ajouterez aux requêtes utilisateur entrantes), et vous pourrez mettre à jour ces entrées à la demande depuis la console Firebase. Vous utiliserez également le Firebase Local Emulator Suite pour tester et déboguer la fonction, puis, après avoir vérifié qu'elle fonctionne, vous la déploierez et la testerez sur Google Cloud.

Prérequis

Dans ce guide, nous partons du principe que vous savez utiliser JavaScript pour développer des applications.

Configurer un projet Firebase

Si vous n'avez pas encore de projet Firebase :

  1. Connectez-vous à la Firebase console.

  2. Cliquez sur Créer un projet, puis utilisez l'une des options suivantes :

    • Option 1 : Créez un projet Firebase (et son projet sous-jacent Google Cloud automatiquement) en saisissant un nouveau nom de projet à la première étape du workflow "Create project" (Créer un projet).
    • Option 2 : Ajoutez Firebase à un projet Google Cloud existant en sélectionnant le nom de votre projet Google Cloud dans le menu déroulant à la première étape du workflow "Create project" (Créer un projet).

  3. Lorsque vous y êtes invité, vous n'avez pas besoin de configurer Google Analytics pour utiliser cette solution.

  4. Continuez à suivre les instructions à l'écran pour créer votre projet.

Si vous avez déjà un projet Firebase :

Passez à la section Configurer votre environnement de développement.

Configurer votre environnement de développement

Vous aurez besoin d'un environnement Node.js pour écrire des fonctions et de la CLI Firebase pour déployer des fonctions dans l'environnement d'exécution Cloud Functions.

  1. Installez Node.js et npm.

    Pour installer Node.js et npm, nous vous recommandons d'utiliser Node Version Manager.

  2. Installez la Firebase CLI à l'aide de la méthode de votre choix. Par exemple, pour installer la CLI à l'aide de npm, exécutez la commande suivante :

    npm install -g firebase-tools@latest

    Cette commande installe la commande firebase disponible à l'échelle mondiale. Si cette commande échoue, vous devrez peut-être modifier les autorisations npm.

    Pour passer à la dernière version de firebase-tools, réexécutez la même commande.

  3. Installez firebase-functions et firebase-admin, puis utilisez --save pour les enregistrer dans votre fichier package.json :

    npm install firebase-functions@latest firebase-admin@latest --save

Vous êtes maintenant prêt à passer à l'implémentation de cette solution.

Implémentation

Pour créer, tester et déployer vos Cloud Functions de deuxième génération Cloud Functions avec Remote Config et Vertex AI, procédez comme suit :

  1. Activez les API recommandées dans la console.Vertex AIGoogle Cloud
  2. Initialisez votre projet et installez les dépendances Node.
  3. Configurez les autorisations IAM pour votre compte de service Admin SDK et enregistrez votre clé.
  4. Créez la fonction.
  5. Créez un modèle Remote Config spécifique au serveur.
  6. Déployez votre fonction et testez-la dans le Firebase Local Emulator Suite.
  7. Déployez votre fonction sur Google Cloud.

Étape 1 : Activez les API recommandées de Vertex AI dans la console Google Cloud

  1. Ouvrez la Google Cloud console et, lorsque vous y êtes invité, sélectionnez votre projet.
  2. Dans le champ Rechercher en haut de la console, saisissez Vertex AI et attendez que Vertex AI s'affiche dans les résultats.
  3. Sélectionnez Vertex AI. Le tableau de bord Vertex AI s'affiche.

  4. Cliquez sur Activer toutes les API recommandées.

    L'activation de l'API peut prendre quelques instants. Laissez la page active et ouverte jusqu'à la fin de l'activation.

  5. Si la facturation n'est pas activée, vous serez invité à ajouter ou à associer un Cloud Billing compte. Après avoir activé un compte de facturation, revenez au Vertex AI tableau de bord et vérifiez que toutes les API recommandées sont activées.

Étape 2 : Initialisez votre projet et installez les dépendances Node

  1. Ouvrez un terminal sur votre ordinateur et accédez au répertoire dans lequel vous prévoyez de créer votre fonction.

  2. Connectez-vous à Firebase :

    firebase login

  3. Exécutez la commande suivante pour initialiser Cloud Functions for Firebase :

    firebase init functions

  4. Sélectionnez Utiliser un projet existant et spécifiez l'ID de votre projet.

  5. Lorsque vous êtes invité à sélectionner la langue à utiliser, choisissez JavaScript et appuyez sur Entrée.

  6. Pour toutes les autres options, sélectionnez les valeurs par défaut.

    Un répertoire functions est créé dans le répertoire actuel. À l'intérieur, vous trouverez un fichier index.js que vous utiliserez pour créer votre fonction, un répertoire node_modules contenant les dépendances de votre fonction et un fichier package.json contenant les dépendances du package.

  7. Ajoutez les Admin SDK et Vertex AI packages en exécutant les commandes suivantes, en utilisant --save pour vous assurer qu'il est enregistré dans votre package.json fichier :

    cd functions
npm install firebase-admin@latest @google-cloud/vertexai --save

Votre fichier functions/package.json doit maintenant ressembler à ce qui suit, avec les dernières versions spécifiées :

  {
    "name": "functions",
    "description": "Cloud Functions for Firebase",
    "scripts": {
      "serve": "firebase emulators:start --only functions",
      "shell": "firebase functions:shell",
      "start": "npm run shell",
      "deploy": "firebase deploy --only functions",
      "logs": "firebase functions:log"
    },
    "engines": {
      "node": "20"
    },
    "main": "index.js",
    "dependencies": {
      "@google-cloud/vertexai": "^1.1.0",
      "firebase-admin": "^12.1.0",
      "firebase-functions": "^5.0.0"
    },
    "devDependencies": {
      "firebase-functions-test": "^3.1.0"
    },
    "private": true
  }

Notez que si vous utilisez ESLint, vous verrez une strophe qui l'inclut. Assurez-vous également que la version du moteur de nœud correspond à la version installée de Node.js et à la version que vous exécutez finalement sur Google Cloud. Par exemple, si la strophe engines de votre fichier package.json est configurée comme version 18 de Node et que vous utilisez Node.js 20, mettez à jour le fichier pour utiliser la version 20 :

  "engines": {
    "node": "20"
  },

Étape 3 : Configurez les autorisations IAM pour votre compte de service Admin SDK et enregistrez votre clé

Dans cette solution, vous utiliserez le compte de service Firebase Admin SDK pour exécuter votre fonction.

  1. Dans la console Google Cloud, ouvrez la page IAM et administration, puis recherchez le compte de service Admin SDK (nommé firebase-adminsdk).
  2. Sélectionnez le compte, puis cliquez sur Modifier le compte principal. La page "Modifier l'accès" s'affiche.
  3. Cliquez sur Ajouter un autre rôle, puis sélectionnez Remote Config Lecteur.
  4. Cliquez sur Ajouter un autre rôle, puis sélectionnez Développeur de la plate-forme d'IA.
  5. Cliquez sur Ajouter un autre rôle, puis sélectionnez Vertex AI utilisateur.
  6. Cliquez sur Ajouter un autre rôle, puis sélectionnez Demandeur Cloud Run.
  7. Cliquez sur Enregistrer.

Ensuite, exportez les identifiants du compte de service Admin SDK et enregistrez-les dans votre variable d'environnement GOOGLE_APPLICATION_CREDENTIALS.

  1. Dans la Google Cloud console, ouvrez la page Identifiants.
  2. Cliquez sur le Admin SDK compte de service pour ouvrir la page Détails.
  3. Cliquez sur Clés.
  4. Cliquez sur Ajouter une clé > Créer une clé.
  5. Assurez-vous que JSON est sélectionné comme Type de clé, puis cliquez sur Créer.
  6. Téléchargez la clé dans un emplacement sécurisé sur votre ordinateur.

  7. Depuis votre terminal, exportez la clé en tant que variable d'environnement :

    export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/service-account-key.json"

Étape 4 : Créez la fonction

Lors de cette étape, vous allez créer une fonction qui gère les entrées utilisateur et génère des réponses basées sur l'IA. Vous combinerez plusieurs extraits de code pour créer une fonction complète qui initialise les Admin SDK et Vertex AI Gemini API, configure les paramètres par défaut à l'aide de Remote Config, récupère les derniers paramètres Remote Config, traite les entrées utilisateur et renvoie une réponse à l'utilisateur.

  1. Dans votre code, ouvrez functions/index.js dans un éditeur de texte ou un IDE.

  2. Supprimez le contenu existant, puis ajoutez le Admin SDK, Remote Config, et le Vertex AI SDK, et initialisez l'application en collant le code suivant dans le fichier :

    const { onRequest } = require("firebase-functions/https");
const logger = require("firebase-functions/logger");

const { initializeApp } = require("firebase-admin/app");
const { VertexAI } = require('@google-cloud/vertexai');
const { getRemoteConfig } = require("firebase-admin/remote-config");

// Set and check environment variables.
const project = process.env.GCLOUD_PROJECT;

// Initialize Firebase.
const app = initializeApp();
    index.js

  3. Configurez les valeurs par défaut que votre fonction utilisera si elle ne parvient pas à se connecter à le Remote Config serveur. Cette solution configure textModel, generationConfig, safetySettings, textPrompt, et location en tant que Remote Config paramètres qui correspondent aux Remote Config paramètres que vous configurerez plus loin dans ce guide. Pour en savoir plus sur ces paramètres, consultez Client Vertex AI Node.js.

    Vous pouvez également configurer un paramètre pour contrôler si vous accédez ou non à l'Vertex AI Gemini API (dans cet exemple, un paramètre appelé vertex_enabled). Cette configuration peut être utile lors du test de votre fonction. Dans les extraits de code suivants, cette valeur est définie sur false, ce qui empêche l'utilisation de Vertex AI lors du test du déploiement de la fonction de base. Si vous la définissez sur true, l'API Vertex AI Gemini API sera appelée.

    // Define default (fallback) parameter values for Remote Config.
const defaultConfig = {

  // Default values for Vertex AI.
  model_name: "gemini-1.5-flash-002",
  generation_config: [{
    "stopSequences": [], "temperature": 0.7,
    "maxOutputTokens": 64, "topP": 0.1, "topK": 20
  }],
  prompt: "I'm a developer who wants to learn about Firebase and you are a \
    helpful assistant who knows everything there is to know about Firebase!",
  safety_settings: [{
    "category":
      "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT",
    "threshold": "HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE"
  }],
  location: 'us-central1',

  // Disable Vertex AI Gemini API access for testing.
  vertex_enabled: false
};
    index.js

  4. Créez la fonction et configurez côté serveur Remote Config :

    // Export the function.
exports.generateWithVertex = onRequest(async (request, response) => {

  try {

    // Set up Remote Config.
    const rc = getRemoteConfig(app);

    // Get the Remote Config template and assign default values.
    const template = await rc.getServerTemplate({
      defaultConfig: defaultConfig
    });

    // Add the template evaluation to a constant.
    const config = template.evaluate();

    // Obtain values from Remote Config.
    const textModel = config.getString("model_name") ||
        defaultConfig.model_name;
    const textPrompt = config.getString("prompt") || defaultConfig.prompt;
    const generationConfig = config.getString("generation_config") ||
        defaultConfig.generation_config;
    const safetySettings = config.getString("safety_settings") ||
        defaultConfig.safety_settings;
    const location = config.getString("location") ||
        defaultConfig.location;
    const vertexEnabled = config.getBoolean("is_vertex_enabled") ||
        defaultConfig.vertex_enabled;
    index.js

  5. Configurez Vertex AI et ajoutez la logique de chat et de réponse :

      // Allow user input.
  const userInput = request.query.prompt || '';

  // Instantiate Vertex AI.
    const vertex_ai = new VertexAI({ project: project, location: location });
    const generativeModel = vertex_ai.getGenerativeModel({
      model: textModel,
      safety_settings: safetySettings,
      generation_config: generationConfig,
    });

    // Combine prompt from Remote Config with optional user input.
    const chatInput = textPrompt + " " + userInput;

    if (!chatInput) {
      return res.status(400).send('Missing text prompt');
    }
    // If vertexEnabled isn't true, do not send queries to Vertex AI.
    if (vertexEnabled !== true) {
      response.status(200).send({
        message: "Vertex AI call skipped. Vertex is not enabled."
      });
      return;
    }

    logger.log("\nRunning with model ", textModel, ", prompt: ", textPrompt,
      ", generationConfig: ", generationConfig, ", safetySettings: ",
      safetySettings, " in ", location, "\n");

    const result = await generativeModel.generateContentStream(chatInput); 
    response.writeHead(200, { 'Content-Type': 'text/plain' });

    for await (const item of result.stream) {
      const chunk = item.candidates[0].content.parts[0].text;
      logger.log("Received chunk:", chunk);
      response.write(chunk);
    }

    response.end();

  } catch (error) {
    logger.error(error);
    response.status(500).send('Internal server error');
  }
});
    index.js

  6. Enregistrez et fermez le fichier.

Étape 5 : Créez un modèle spécifique au serveur Remote Config

Ensuite, créez un modèle Remote Config côté serveur et configurez les paramètres et les valeurs à utiliser dans votre fonction. Pour créer un modèle spécifique au serveur Remote Config :

  1. Ouvrez la console Firebase, puis dans le menu de navigation, développez Exécuter et sélectionnez Remote Config.

  2. Sélectionnez Serveur dans le sélecteur Client/Serveur en haut de la page Remote Config.

    • Si vous utilisez Remote Config ou des modèles de serveur pour la première fois, cliquez sur Créer une configuration. Le volet Créer votre premier paramètre côté serveur s'affiche.
    • Si vous avez déjà utilisé des modèles de serveur Remote Config, cliquez sur Ajouter un paramètre.

  3. Définissez les paramètres Remote Config suivants :

    Nom du paramètre Description Type Valeur par défaut
    model_name Nom du modèle
    Pour obtenir des listes à jour des noms de modèles à utiliser dans votre code, consultez Versions et cycle de vie des modèles ou Noms de modèles disponibles.     		Chaîne gemini-2.0-flash
    prompt Prompt à ajouter à la requête de l'utilisateur. Chaîne I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!
    generation_config Paramètres à envoyer au modèle. JSON [{"stopSequences": ["I hope this helps"],"temperature": 0.7,"maxOutputTokens": 512, "topP": 0.1,"topK": 20}]
    safety_settings Paramètres de sécurité pour Vertex AI. JSON [{"category": "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "HarmBlockThreshold.BLOCK_LOW_AND_ABOVE"}]
    location Emplacement où exécuter le service et le modèle Vertex AI. Chaîne us-central1
    is_vertex_enabled Paramètre facultatif qui contrôle si les requêtes sont envoyées à Vertex AI. Booléen true

  4. Une fois que vous avez terminé d'ajouter des paramètres, vérifiez-les et assurez-vous que leurs types de données sont corrects, puis cliquez sur Publier les modifications.

Étape 6 : Déployez votre fonction et testez-la dans le Firebase Local Emulator Suite

Vous êtes maintenant prêt à déployer et à tester votre fonction en local avec le Firebase Local Emulator Suite.

  1. Assurez-vous d'avoir défini GOOGLE_APPLICATION_CREDENTIALS comme variable d'environnement, comme décrit dans Étape 3 : Configurez les autorisations IAM pour votre compte de service et enregistrez votre clé.Admin SDK Ensuite, à partir du répertoire parent de votre répertoire functions, déployez votre fonction dans l'émulateur Firebase :

    firebase emulators:start --project PROJECT_ID --only functions
    .

  2. Ouvrez la page des journaux de l'émulateur. Cela devrait indiquer que votre fonction a été chargée.

  3. Accédez à votre fonction en exécutant la commande suivante, où PROJECT_ID correspond à l'ID de votre projet et LOCATION à la région dans laquelle vous avez déployé la fonction (par exemple, us-central1) :

    curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex

  4. Attendez une réponse, puis revenez à la page des journaux de l'émulateur Firebase ou à votre console et recherchez les erreurs ou les avertissements.

  5. Essayez d'envoyer des entrées utilisateur, en notant que, comme is_vertex_enabled est configuré dans votre Remote Config modèle de serveur, cela devrait accéder au Gemini modèle via l' Vertex AI Gemini API et que cela peut entraîner des frais :

    curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20cats

  6. Apportez des modifications à votre modèle de serveur Remote Config dans la console Firebase, puis accédez à nouveau à votre fonction pour observer les modifications.

Étape 7 : Déployez votre fonction sur Google Cloud

Une fois que vous avez testé et vérifié votre fonction, vous êtes prêt à la déployer sur Google Cloud et à tester la fonction en direct.

Déployer la fonction

Déployez votre fonction à l'aide de la Firebase CLI :

firebase deploy --only functions

Bloquer l'accès non authentifié à la fonction

Lorsque les fonctions sont déployées à l'aide de Firebase, les appels non authentifiés sont autorisés par défaut si la règle de votre organisation ne les limite pas. Pendant les tests et avant de sécuriser avec App Check, nous vous recommandons de bloquer l'accès non authentifié.

Pour bloquer l'accès non authentifié à la fonction :

  1. Dans la console Google Cloud, ouvrez Cloud Run.

  2. Cliquez sur generateWithVertex, puis sur l'onglet Sécurité.

  3. Activez Exiger une authentification , puis cliquez sur Enregistrer.

Configurez votre compte utilisateur pour qu'il utilise les identifiants du compte de service Admin SDK

Étant donné que le compte de service Admin SDK dispose de tous les rôles et autorisations nécessaires pour exécuter la fonction et interagir avec Remote Config et l'API Vertex AI Gemini API, vous devez l'utiliser pour exécuter votre fonction. Pour ce faire, vous devez pouvoir créer des jetons pour le compte à partir de votre compte utilisateur.

Les étapes suivantes décrivent comment configurer votre compte utilisateur et la fonction pour qu'ils s'exécutent avec les Admin SDK privilèges du compte de service.

  1. Dans la console Google Cloud, activez l' API IAM Service Account Credentials.
  2. Attribuez à votre compte utilisateur le rôle Créateur de jetons du compte de service : dans la Google Cloud console, ouvrez IAM et administration > IAM, sélectionnez votre compte utilisateur, puis cliquez sur Modifier le compte principal > Ajouter un autre rôle.

  3. Sélectionnez Créateur de jetons du compte de service, puis cliquez sur Enregistrer.

    Pour en savoir plus sur l'emprunt d'identité d'un compte de service, consultez la section Emprunter l'identité d'un compte de service dans la documentation Google Cloud.

  4. Ouvrez la console Google Cloud Cloud Functions page et cliquez sur la fonction generateWithVertex dans la liste Fonctions.

  5. Sélectionnez Déclencheur > Modifier , puis développez Paramètres d'exécution, de compilation, de connexion et de sécurité.

  6. Dans l'onglet Exécution, remplacez le Compte de service d'exécution par le Compte Admin SDK.

  7. Cliquez sur Suivant, puis sur Déployer.

Configurer gcloud CLI

Pour exécuter et tester votre fonction de manière sécurisée à partir de la ligne de commande, vous devez vous authentifier auprès du Cloud Functions service et obtenir un jeton d'authentification valide.

Pour activer la génération de jetons, installez et configurez gcloud CLI :

  1. Si elle n'est pas déjà installée sur votre ordinateur, installez gcloud CLI comme décrit dans Installer gcloud CLI.

  2. Obtenez les identifiants d'accès pour votre compte Google Cloud :

    gcloud auth login

  3. Définissez l'ID de votre projet dans gcloud :

    gcloud config set project PROJECT_ID

Tester votre fonction

Vous êtes maintenant prêt à tester votre fonction dans Google Cloud. Pour tester la fonction, exécutez la commande suivante :

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex \
  -H "Authorization: bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json"

Réessayez avec des données fournies par l'utilisateur :

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20dogs \
 -H "Authorization: bearer $(gcloud auth print-identity-token)" \
 -H "Content-Type: application/json"

Vous pouvez maintenant apporter des modifications à votre Remote Config modèle de serveur, publier ces modifications et tester différentes options.

Étapes suivantes