Appeler des flux Genkit à partir de votre application

Cloud Functions for Firebase dispose d'une méthode onCallGenkit qui vous permet de créer une fonction appelable avec une action Genkit (un flux). Ces fonctions peuvent être appelées avec genkit/beta/client ou les SDK clients Cloud Functions, qui ajoutent automatiquement les informations d'authentification.

Avant de commencer

  • Vous devez connaître le concept de flux de Genkit et savoir comment les écrire. Les instructions de cette page partent du principe que vous avez déjà défini des flux que vous souhaitez déployer.
  • Il est utile, mais pas obligatoire, si vous avez déjà utilisé Cloud Functions for Firebase.

Configurer un projet Firebase

  1. Créez un projet Firebase à l'aide de la console Firebase ou choisissez-en un existant.

  2. Mettez à niveau le projet vers la formule Blaze, qui est requise pour le déploiement en production de Cloud Functions.

  3. Installez la CLI Firebase.

  4. Connectez-vous avec la CLI Firebase :

    firebase login
firebase login --reauth # alternative, if necessary
firebase login --no-localhost # if running in a remote shell

  5. Créez un répertoire de projet :

    export PROJECT_ROOT=~/tmp/genkit-firebase-project1
mkdir -p $PROJECT_ROOT

  6. Initialisez un projet Firebase dans le répertoire :

    cd $PROJECT_ROOT
firebase init functions

Le reste de cette page suppose que vous avez choisi d'écrire vos fonctions en JavaScript.

Encapsulez le flux dans onCallGenkit

Une fois que vous avez configuré un projet Firebase avec Cloud Functions, vous pouvez copier ou écrire des définitions de flux dans le répertoire functions du projet. Voici un exemple de flux pour illustrer ce point :

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const jokeTeller = ai.defineFlow({
  name: "jokeTeller",
  inputSchema: z.string().nullable(),
  outputSchema: z.string(),
  streamSchema: z.string(),
}, async (jokeType = "knock-knock", {sendChunk}) => {
  const prompt = `Tell me a ${jokeType} joke.`;

  // Call the `generateStream()` method to
  // receive the `stream` async iterable.
  const {stream, response: aiResponse} = ai.generateStream(prompt);

  // Send new words of the generative AI response
  // to the client as they are generated.
  for await (const chunk of stream) {
    sendChunk(chunk.text);
  }

  // Return the full generative AI response
  // to clients that may not support streaming.
  return (await aiResponse).text;
},
);
index.js

Pour déployer un flux comme celui-ci, encapsulez-le avec onCallGenkit, disponible dans firebase-functions/https. Cette méthode d'assistance possède toutes les fonctionnalités des fonctions appelables et prend automatiquement en charge les réponses de streaming et JSON.

const {onCallGenkit} = require("firebase-functions/v2/https");
 
exports.tellJoke = onCallGenkit({
  // Bind the Gemini API key secret parameter to the function.
  secrets: [apiKey],
},
// Pass in the genkit flow.
jokeTeller,
);
index.js

Mettre les identifiants de l'API à la disposition des flux déployés

Une fois vos flux déployés, ils doivent pouvoir s'authentifier auprès des services à distance dont ils dépendent. La plupart des flux ont besoin d'identifiants pour accéder au service d'API de modèle qu'ils utilisent.

Pour cet exemple, effectuez l'une des opérations suivantes, en fonction du fournisseur de modèle que vous avez choisi :

Gemini (IA de Google)

  1. Assurez-vous que l'IA de Google est disponible dans votre région.

  2. Générez une clé API pour l'API Gemini à l'aide de Google AI Studio.

  3. Stockez votre clé API dans Cloud Secret Manager :

    firebase functions:secrets:set GOOGLE_GENAI_API_KEY

    Cette étape est importante pour éviter de divulguer accidentellement votre clé API, qui donne accès à un service potentiellement payant.

    Pour en savoir plus sur la gestion des secrets, consultez Stocker des informations de configuration sensibles et y accéder.

  4. Modifiez src/index.js et ajoutez les éléments suivants après les importations existantes :

    const {defineSecret} = require("firebase-functions/params");
     
    // Store the Gemini API key in Cloud Secret Manager.
const apiKey = defineSecret("GOOGLE_GENAI_API_KEY");
    index.js

    Ensuite, dans la définition de la fonction appelable, déclarez que la fonction a besoin d'accéder à cette valeur secrète :

    // Bind the Gemini API key secret parameter to the function.
secrets: [apiKey],
    index.js

Désormais, lorsque vous déployez cette fonction, votre clé API est stockée dans Cloud Secret Manager et est disponible à partir de l'environnement Cloud Functions.

Gemini (Vertex AI)

  1. Dans la console Cloud, activez l'API Vertex AI pour votre projet Firebase.

  2. Sur la page IAM, assurez-vous que le rôle Utilisateur Vertex AI est attribué au compte de service Compute par défaut.

Le seul secret que vous devez configurer pour ce tutoriel concerne le fournisseur de modèles. Toutefois, en général, vous devez effectuer une opération similaire pour chaque service utilisé par votre flux.

(Facultatif) Ajouter l'application App Check

Firebase App Check utilise l'attestation native pour vérifier que votre API n'est appelée que par votre application. onCallGenkit est compatible avec l'application App Check de manière déclarative.

export const generatePoem = onCallGenkit({
  enforceAppCheck: true,
  // Optional. Makes App Check tokens only usable once. This adds extra security
  // at the expense of slowing down your app to generate a token for every API
  // call
  consumeAppCheckToken: true,
}, generatePoemFlow);

Configurer CORS (partage des ressources entre origines multiples)

Utilisez l'option cors pour contrôler les origines pouvant accéder à votre fonction.

Par défaut, les fonctions appelables sont configurées avec CORS pour autoriser les requêtes provenant de toutes les origines. Pour autoriser certaines requêtes d'origine croisée, mais pas toutes, transmettez une liste de domaines spécifiques ou d'expressions régulières qui doivent être autorisés. Exemple :

export const tellJoke = onCallGenkit({
  cors: 'mydomain.com',
}, jokeTeller);

Exemple complet

Une fois toutes les modifications décrites ci-dessus effectuées, votre flux déployable ressemblera à l'exemple suivant :

const {onCallGenkit} = require("firebase-functions/v2/https");
const {defineSecret} = require("firebase-functions/params");

// Dependencies for Genkit.
const {gemini15Flash, googleAI} = require("@genkit-ai/googleai");
const {genkit, z} = require("genkit");

// Store the Gemini API key in Cloud Secret Manager.
const apiKey = defineSecret("GOOGLE_GENAI_API_KEY");

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const jokeTeller = ai.defineFlow({
  name: "jokeTeller",
  inputSchema: z.string().nullable(),
  outputSchema: z.string(),
  streamSchema: z.string(),
}, async (jokeType = "knock-knock", {sendChunk}) => {
  const prompt = `Tell me a ${jokeType} joke.`;

  // Call the `generateStream()` method to
  // receive the `stream` async iterable.
  const {stream, response: aiResponse} = ai.generateStream(prompt);

  // Send new words of the generative AI response
  // to the client as they are generated.
  for await (const chunk of stream) {
    sendChunk(chunk.text);
  }

  // Return the full generative AI response
  // to clients that may not support streaming.
  return (await aiResponse).text;
},
);

exports.tellJoke = onCallGenkit({
  // Bind the Gemini API key secret parameter to the function.
  secrets: [apiKey],
},
// Pass in the genkit flow.
jokeTeller,
);
index.js

Déployer des flux sur Firebase

Une fois que vous avez défini des flux à l'aide de onCallGenkit, vous pouvez les déployer comme vous le feriez pour d'autres fonctions :

cd $PROJECT_ROOT
firebase deploy --only functions