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 un Cloud Functions for Firebase Client SDK, qui ajoute automatiquement des informations d'authentification.

Avant de commencer

  • Vous devez connaître le concept de Genkit flux 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, d'avoir déjà utilisé Cloud Functions for Firebase avant.

Configurer un projet Firebase

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

  2. Passez au forfait Blaze avec paiement à l'usage, qui est requis pour le Cloud Functions déploiement en production.

  3. Installez la Firebase CLI.

  4. Connectez-vous à la Firebase CLI :

    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 part du principe que vous avez choisi d'écrire vos fonctions en JavaScript.

Encapsuler le flux dans onCallGenkit

Une fois que vous avez configuré un projet Firebase et initialisé Cloud Functions dans celui-ci, vous pouvez copier ou écrire des définitions de flux dans le functions répertoire du projet. Voici un exemple de flux pour illustrer cela :

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

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/https");
 
exports.tellJoke = onCallGenkit({
  // Bind the Gemini API key secret parameter to the function.
  secrets: [apiKey],
},
// Pass in the genkit flow.
jokeTeller,
);

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

Une fois déployés, vos flux doivent pouvoir s'authentifier auprès des services à distance sur lesquels ils s'appuient. La plupart des flux ont au minimum 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. Générez une clé API pour Gemini Developer API à l'aide de Google AI Studio.

  2. Stockez votre clé API dans Google 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 facturé.

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

  3. Modifiez src/index.js et ajoutez le code suivant 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");

    Ensuite, dans la définition de la fonction appelable, déclarez que la fonction doit avoir accès à cette valeur secrète :

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

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

Gemini (Vertex AI)

  1. Dans la console Google 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 Engine par défaut.

Le seul secret que vous devez configurer pour ce tutoriel concerne le fournisseur de modèle, mais en général, vous devez procéder de manière similaire pour chaque service utilisé par votre flux.

(Facultatif) Ajouter l'application de Firebase App Check

Firebase App Check utilise l'attestation native pour vérifier que notre API n'est appelée que par votre application. La méthode onCallGenkit prend en charge l'App Check application 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 le partage des ressources entre origines multiples (CORS)

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

Par défaut, les fonctions appelables sont configurées pour autoriser les requêtes provenant de toutes les origines. Pour autoriser certaines requêtes entre origines, mais pas toutes, transmettez une liste de domaines spécifiques ou d'expressions régulières à autoriser. Exemple :

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

Exemple complet

Une fois toutes les modifications décrites dans ce guide effectuées, votre flux déployable se présentera comme dans l'exemple suivant :

const {onCallGenkit} = require("firebase-functions/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,
);

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