Beta: Firebase Genkit is in Beta, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Beta period, Firebase Genkit and its documentation will be updated and improved.

Diese Seite wurde von der Cloud Translation API übersetzt.

Abläufe mit Cloud Functions für Firebase bereitstellen

Genkit enthält ein Plug-in, mit dem Sie Ihre Workflows in Cloud Functions for Firebase bereitstellen können. Nach der Bereitstellung sind Flows als HTTPS-Endpunkte verfügbar und können über die Cloud Functions-Clientbibliotheken als aufrufbare Funktionen aufgerufen werden.

Hinweis

Installieren Sie die Firebase CLI.
Sie sollten mit dem Genkit-Konzept von Abläufen und deren Erstellung vertraut sein. In der Anleitung auf dieser Seite wird davon ausgegangen, dass Sie bereits einige Workflows definiert haben, die Sie bereitstellen möchten.
Es ist hilfreich, aber nicht zwingend erforderlich, wenn Sie Cloud Functions für Firebase bereits verwendet haben.

1. Firebase-Projekt einrichten

Wenn Sie noch kein Firebase-Projekt mit eingerichteten TypeScript-Cloud Functions haben, gehen Sie so vor:

Erstellen Sie ein neues Firebase-Projekt in der Firebase Console oder wählen Sie ein vorhandenes Projekt aus.
Führen Sie ein Upgrade des Projekts auf den Blaze-Tarif durch, der für die Bereitstellung von Cloud Functions erforderlich ist.

Melden Sie sich mit der Firebase CLI an:

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

Erstellen Sie ein neues Projektverzeichnis:

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

Initialisieren Sie ein Firebase-Projekt im Verzeichnis:
```
cd $PROJECT_ROOT
firebase init genkit
```
Im Rest dieser Seite wird davon ausgegangen, dass Sie Ihre Funktionen in TypeScript geschrieben haben. Sie können Ihre Genkit-Abläufe aber auch bereitstellen, wenn Sie JavaScript verwenden.

2. Ablaufdefinitionen aktualisieren

Nachdem Sie ein Firebase-Projekt mit Cloud Functions eingerichtet haben, können Sie Ablaufdefinitionen in das functions/src-Verzeichnis des Projekts kopieren oder schreiben und sie in index.ts exportieren.

Damit Ihre Abläufe bereitgestellt werden können, müssen Sie einige kleine Änderungen an der Definition vornehmen. Die grundlegende Logik bleibt gleich, Sie fügen jedoch einige zusätzliche Informationen hinzu, damit die Bereitstellung reibungslos abläuft und die Anwendung nach der Bereitstellung sicherer ist.

Angenommen, Sie haben den folgenden Ablauf:

const generatePoemFlow = ai.defineFlow(
  {
    name: "generatePoem",
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (subject: string) => {
    const { text } = await ai.generate(`Compose a poem about ${subject}.`);
    return text;
  }
);

In den folgenden Abschnitten werden die Änderungen beschrieben, die Sie vornehmen müssen, bevor Sie die App bereitstellen können.

Abläufe mit onFlow definieren

Anstatt den Ablauf mit Genkit.defineFlow() zu definieren, verwenden Sie die onFlow()-Funktion des Firebase-Plug-ins. Mit dieser Funktion wird Ihre Ablauflogik in einen Cloud Functions-Anfragehandler verpackt, ähnlich wie bei onCall.

import { onFlow } from "@genkit-ai/firebase/functions";

export const generatePoem = onFlow(
  ai,
  {
    // ...
  },
  async (subject: string) => {
    // ...
  }
);

Hinweis: onFlow ist keine Methode von Genkit, sondern eine Funktion, die eine Genkit-Instanz als ersten Parameter annimmt. Ansonsten ähnelt die Syntax der von defineFlow.

Autorisierungsrichtlinie definieren

Alle bereitgestellten Workflows, unabhängig davon, ob sie in Firebase bereitgestellt werden, sollten eine Autorisierungsrichtlinie haben. Andernfalls können Ihre potenziell teuren Workflows mit generativer KI von jeder Person aufgerufen werden. Verwenden Sie den Parameter authPolicy in der Ablaufdefinition, um eine Autorisierungsrichtlinie zu definieren:

import { firebaseAuth } from "@genkit-ai/firebase/auth";

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    // ...
    authPolicy: firebaseAuth((user, input) => {
      if (!user.email_verified) {
        throw new Error("Verified email required to run flow");
      }
    }),
  },
  async (subject: string) => {
    // ...
  }
);

Bei dieser Richtlinie wird der firebaseAuth()-Hilfsprogramm verwendet, um nur registrierten Nutzern Ihrer App mit bestätigten E-Mail-Adressen Zugriff zu gewähren. Auf der Clientseite müssen Sie den Authorization: Bearer-Header auf ein Firebase-ID-Token festlegen, das Ihren Richtlinien entspricht. Die Cloud Functions-Client SDKs bieten aufrufbare Funktionsmethoden, die dies automatisieren. Ein Beispiel finden Sie im Abschnitt Bereitgestellten Ablauf testen.

API-Anmeldedaten für bereitgestellte Abläufe verfügbar machen

Nach der Bereitstellung müssen sich Ihre Workflows bei allen Remote-Diensten authentifizieren können, auf die sie angewiesen sind. Für die meisten Abläufe sind mindestens Anmeldedaten für den Zugriff auf den verwendeten Modell-API-Dienst erforderlich.

Führen Sie in diesem Beispiel je nach ausgewähltem Modellanbieter einen der folgenden Schritte aus:

Gemini (Google AI)

Prüfen Sie, ob Google AI in Ihrer Region verfügbar ist.
Erstellen Sie einen API-Schlüssel für die Gemini API mit Google AI Studio.
So speichern Sie Ihren API-Schlüssel in Cloud Secret Manager:
```
firebase functions:secrets:set GOOGLE_GENAI_API_KEY
```
Dieser Schritt ist wichtig, um zu verhindern, dass Ihr API-Schlüssel versehentlich weitergegeben wird, wodurch Zugriff auf einen potenziell befristeten Dienst gewährt wird.

Weitere Informationen zum Verwalten von Secrets finden Sie unter Sensible Konfigurationsinformationen speichern und abrufen.

Bearbeiten Sie src/index.ts und fügen Sie nach den vorhandenen Importen Folgendes hinzu:

import {defineSecret} from "firebase-functions/params";
const googleAIapiKey = defineSecret("GOOGLE_GENAI_API_KEY");

Geben Sie dann in der Ablaufdefinition an, dass die Cloud-Funktion Zugriff auf diesen geheimen Wert benötigt:

export const generatePoem = onFlow(
  {
    name: "generatePoem",
    // ...
    httpsOptions: {
      secrets: [googleAIapiKey],  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);

Wenn Sie diese Funktion jetzt bereitstellen, wird Ihr API-Schlüssel in Cloud Secret Manager gespeichert und ist über die Cloud Functions-Umgebung verfügbar.

Gemini (Vertex AI)

Aktivieren Sie in der Cloud Console die Vertex AI API für Ihr Firebase-Projekt.
Achten Sie darauf, dass dem Standarddienstkonto für Compute auf der Seite IAM die Rolle Vertex AI-Nutzer zugewiesen ist.

Für diese Anleitung müssen Sie nur ein Secret für den Modellanbieter einrichten. Im Allgemeinen müssen Sie jedoch für jeden Dienst, den Ihr Flow verwendet, etwas Ähnliches tun.

CORS-Richtlinie festlegen

Wenn Sie über eine Webanwendung auf Ihren Ablauf zugreifen (wie im Abschnitt Bereitgestellten Ablauf testen beschrieben), legen Sie im Parameter httpsOptions eine CORS-Richtlinie fest:

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    // ...
    httpsOptions: {
      cors: '*',
    },
  },
  async (subject: string) => {
    // ...
  }
);

Für Produktions-Apps sollten Sie wahrscheinlich eine restriktivere Richtlinie verwenden, aber für diese Anleitung reicht diese aus.

Vollständiges Beispiel

Nachdem Sie alle oben beschriebenen Änderungen vorgenommen haben, sollte Ihr implementierbarer Ablauf in etwa so aussehen:

const googleAIapiKey = defineSecret("GOOGLE_GENAI_API_KEY");

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    inputSchema: z.string(),
    outputSchema: z.string(),
    authPolicy: firebaseAuth((user, input) => {
      if (!user.email_verified) {
        throw new Error("Verified email required to run flow");
      }
    }),
    httpsOptions: {
      secrets: [googleAIapiKey],
      cors: '*',
    },
  },
  async (subject: string) => {
    const { text } = await ai.generate(`Compose a poem about ${subject}.`);
    return text;
  }
);

3. Abläufe in Firebase bereitstellen

Nachdem Sie Workflows mit onFlow definiert haben, können Sie sie wie andere Cloud Functions bereitstellen:

cd $PROJECT_ROOT
firebase deploy --only functions

Sie haben den Ablauf jetzt als Cloud-Funktion bereitgestellt. Aufgrund der Autorisierungsrichtlinie des Ablaufs können Sie jedoch nicht mit curl oder ähnlichen URLs auf den bereitgestellten Endpunkt zugreifen. Im nächsten Abschnitt erfahren Sie, wie Sie sicher auf den Fluss zugreifen.

Optional: Bereitstellen Ablauf testen

Um Ihren Ablaufendpunkt zu testen, können Sie die folgende minimale Beispiel-Web-App bereitstellen:

Fügen Sie in der Firebase Console im Bereich Projekteinstellungen eine neue Webanwendung hinzu und wählen Sie die Option zum Einrichten von Hosting aus.
Aktivieren Sie in der Firebase Console im Abschnitt Authentifizierung den Anbieter Google, den Sie in diesem Beispiel verwenden.
Richten Sie in Ihrem Projektverzeichnis Firebase Hosting ein, wo Sie die Beispiel-App bereitstellen:
```
cd $PROJECT_ROOT
firebase init hosting
```
Übernehmen Sie die Standardeinstellungen für alle Prompts.

Ersetzen Sie public/index.html durch Folgendes:

<!DOCTYPE html>
<html>
  <head>
    <title>Genkit demo</title>
  </head>
  <body>
    <div id="signin" hidden>
      <button id="signinBtn">Sign in with Google</button>
    </div>
    <div id="callGenkit" hidden>
      Subject: <input type="text" id="subject" />
      <button id="generatePoem">Compose a poem on this subject</button>
      <p id="generatedPoem"></p>
    </div>
    <script type="module">
      import { initializeApp } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-app.js";
      import {
        getAuth,
        onAuthStateChanged,
        GoogleAuthProvider,
        signInWithPopup,
      } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-auth.js";
      import {
        getFunctions,
        httpsCallable,
      } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-functions.js";

      const firebaseConfig = await fetch("/__/firebase/init.json");
      initializeApp(await firebaseConfig.json());

      async function generatePoem() {
        const poemFlow = httpsCallable(getFunctions(), "generatePoem");
        const subject = document.querySelector("#subject").value;
        const response = await poemFlow(subject);
        document.querySelector("#generatedPoem").innerText = response.data;
      }

      function signIn() {
        signInWithPopup(getAuth(), new GoogleAuthProvider());
      }

      document.querySelector("#signinBtn").addEventListener("click", signIn);
      document
        .querySelector("#generatePoem")
        .addEventListener("click", generatePoem);

      const signinEl = document.querySelector("#signin");
      const genkitEl = document.querySelector("#callGenkit");

      onAuthStateChanged(getAuth(), (user) => {
        if (!user) {
          signinEl.hidden = false;
          genkitEl.hidden = true;
        } else {
          signinEl.hidden = true;
          genkitEl.hidden = false;
        }
      });
    </script>
  </body>
</html>

Webanwendung und Cloud Functions-Funktion bereitstellen:
```
cd $PROJECT_ROOT
firebase deploy
```

Öffnen Sie die Webanwendung, indem Sie die URL aufrufen, die mit dem Befehl deploy ausgegeben wurde. Sie müssen sich in der App mit einem Google-Konto anmelden, um Endpunktanfragen starten zu können.

Optional: Abläufe in der Entwickler-UI ausführen

Sie können mit onFlow definierte Abläufe in der Entwickler-UI genau so ausführen wie mit defineFlow definierte Abläufe. Sie müssen also nicht zwischen Bereitstellung und Entwicklung wechseln.

cd $PROJECT_ROOT/functions
npx genkit start -- npx tsx --watch src/index.ts

oder

cd $PROJECT_ROOT/functions
npm run genkit:start

Sie können jetzt die URL aufrufen, die mit dem Befehl genkit start ausgegeben wurde.

Optional: Entwicklung mit der Firebase Local Emulator Suite

Firebase bietet eine Suite von Emulatoren für die lokale Entwicklung, die Sie mit Genkit verwenden können.

Wenn Sie die Genkit-Entwickleroberfläche mit der Firebase Emulator Suite verwenden möchten, starten Sie die Firebase-Emulatoren so:

npx genkit start -- firebase emulators:start --inspect-functions

Dadurch wird Ihr Code im Emulator und das Genkit-Framework im Entwicklungsmodus ausgeführt. Dadurch wird die Genkit-Reflexions-API gestartet und freigegeben, aber nicht die Dev-UI.

Wenn Sie sich in der Dev-Benutzeroberfläche Firestore-Spuren ansehen möchten, rufen Sie den Tab „Inspect“ (Prüfen) auf und stellen Sie den Schalter „Dev/Prod“ (Entwicklung/Produktion) auf „Dev“ (Entwicklung). Wenn „prod“ ausgewählt ist, werden Traces aus Firestore geladen.