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 des 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, d'avoir 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.

Encapsuler 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 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;
},
);
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 à la fois le streaming et les réponses 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

Rendre les identifiants de l'API disponibles pour les flux déployés

Une fois déployés, vos flux doivent disposer d'un moyen de s'authentifier auprès des services distants 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. 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 permet d'accéder à un service potentiellement limité.

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

  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 doit avoir accès à cette valeur secrète:

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

Désormais, lorsque vous déploierez cette fonction, votre clé API sera stockée dans Cloud Secret Manager et disponible depuis 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 compte de service Compute par défaut se voit attribuer le rôle Utilisateur Vertex AI.

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

(Facultatif) Ajouter l'application de la vérification des applications

Firebase App Check utilise l'attestation native pour vérifier que votre API n'est appelée que par votre application. onCallGenkit prend en charge l'application de la vérification des applications 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 pouvant accéder à votre fonction.

Par défaut, le protocole CORS est configuré pour autoriser les requêtes provenant de toutes les origines dans les fonctions appelables. Pour autoriser certaines requêtes inter-origines, mais pas toutes, transmettez une liste de domaines ou d'expressions régulières spécifiques à autoriser. 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 se présentera comme suit:

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