Genkit z funkcjami Firebase Cloud Functions

Firebase Genkit zawiera wtyczkę, która ułatwia wdrażanie przepływów w Firebase Cloud Functions. Na tej stronie opisujemy proces wdrażania domyślnego przykładowego przepływu w Firebase.

Wdrażanie przepływu jako funkcji w Cloud Functions

  1. Zainstaluj wymagane narzędzia:

    1. Upewnij się, że używasz środowiska Node.js w wersji 20 lub nowszej (aby to sprawdzić, uruchom polecenie node --version).

    2. Zainstaluj interfejs wiersza poleceń Firebase.

  2. Utwórz nowy projekt Firebase za pomocą konsoli Firebase lub wybierz istniejący.

    Przenieś projekt na abonament Blaze, który jest wymagany do wdrażania funkcji w Cloud Functions.

  3. Zaloguj się za pomocą interfejsu wiersza poleceń Firebase:

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

  4. Utwórz nowy katalog projektu:

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

  5. Zainicjuj projekt Firebase z Genkit w folderze:

    cd $PROJECT_ROOT
firebase init genkit
    • Wybierz utworzony wcześniej projekt.
    • Wybierz dostawcę modelu, którego chcesz użyć.

    W pozostałych promptach zaakceptuj wartości domyślne. Narzędzie genkit utworzy przykładowe pliki źródłowe, aby umożliwić Ci rozpoczęcie tworzenia własnych przepływów pracy AI. Jednak w pozostałej części tego samouczka wdrożysz tylko przykładowy przepływ.

  6. Udostępnij swoje dane logowania do interfejsu API funkcji w Cloud Functions. W zależności od wybranego dostawcy modelu wykonaj jedną z tych czynności:

    Gemini (AI od Google)

    1. Upewnij się, że AI od Google jest dostępna w Twoim regionie.

    2. Wygeneruj klucz API dla Gemini API za pomocą Google AI Studio.

    3. Ustaw zmienną środowiskową GOOGLE_GENAI_API_KEY na swój klucz:

      export GOOGLE_GENAI_API_KEY=<your API key>

    4. Edytuj pole src/index.ts i po zakończeniu importowania dodaj te elementy:

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

    Teraz po wdrożeniu tej funkcji Twój klucz interfejsu API będzie przechowywany w usłudze Cloud Secret Manager i dostępny w środowisku Cloud Functions.

    Gemini (Vertex AI)

    1. W konsoli Cloud włącz interfejs Vertex AI API w swoim projekcie Firebase.

    2. Na stronie Uprawnienia sprawdź, czy do domyślnego konta usługi Compute została przypisana rola Użytkownik Vertex AI.

    3. Opcjonalnie: jeśli chcesz uruchamiać przepływ lokalnie, jak w następnym kroku, ustaw dodatkowe zmienne środowiskowe i użyj narzędzia gcloud, aby skonfigurować domyślne dane logowania aplikacji:

      export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
gcloud auth application-default login

    Jedynym obiektem tajnym, który musisz skonfigurować na potrzeby tego samouczka, jest dostawca modelu, ale generalnie musisz wykonać coś podobnego w przypadku każdej usługi, z której korzysta Twój przepływ.

  7. Jeśli będziesz uzyskiwać dostęp do przepływu z aplikacji internetowej (będziesz to robić w następnej sekcji), w parametrze httpsOptions ustaw zasadę CORS:

    export const menuSuggestionFlow = onFlow(
  {
    name: "menuSuggestionFlow",
    // ...
    httpsOptions: {cors: true}, // Add this line.
  },
  async (subject) => {
    // ...
  }
);

    W przypadku aplikacji w wersji produkcyjnej warto zastosować bardziej restrykcyjne zasady, ale tak będzie w tym samouczku.

  8. Opcjonalnie: spróbuj wykonać opisane niżej czynności w interfejsie dewelopera:

    1. Uruchom interfejs:

      cd $PROJECT_ROOT/functions
genkit start

    2. W interfejsie programisty (http://localhost:4000/) uruchom ten proces:

      1. Kliknij menusuggestionFlow.

      2. Na karcie Input JSON (Dane wejściowe) podaj temat modelu:

        "AI app developers"

      3. Na karcie Auth JSON (Plik JSON uwierzytelniania) podaj symulowany obiekt auth:

        {
  "uid": 0,
  "email_verified": true
}

      4. Kliknij Uruchom.

  9. Jeśli na razie wszystko działa zgodnie z oczekiwaniami, możesz wdrożyć ten proces:

    cd $PROJECT_ROOT
firebase deploy --only functions

Udało Ci się wdrożyć przepływ jako funkcję w Cloud Functions. Ze względu na zasadę autoryzacji przepływu nie będziesz jednak mieć dostępu do wdrożonego punktu końcowego przy użyciu tokena curl lub podobnego. Przejdź do następnej sekcji, aby dowiedzieć się, jak bezpiecznie uzyskać dostęp do procesu.

Wypróbuj wdrożony proces

Bardzo ważne jest, aby każdy wdrażany przepływ ustawiał zasadę autoryzacji. Bez tego potencjalnie kosztowne procesy generatywnej AI mogłyby być wywoływane przez wszystkich.

Domyślny przykładowy przepływ ma zasadę autoryzacji podobną do tej:

firebaseAuth((user) => {
  if (!user.email_verified) {
    throw new Error('Verified email required to run flow');
  }
});

Ta zasada używa pomocnika firebaseAuth(), aby zezwalać na dostęp tylko zarejestrowanym użytkownikom aplikacji ze zweryfikowanymi adresami e-mail. Po stronie klienta ustaw nagłówek Authorization: Bearer na token identyfikatora Firebase, który spełnia Twoją zasadę. Pakiety SDK klienta Cloud Functions udostępniają metody wywoływanych funkcji, które automatyzują ten proces.

Aby wypróbować punkt końcowy przepływu, możesz wdrożyć tę przykładową aplikację internetową, która jest minimalna:

  1. W sekcji Ustawienia projektu w konsoli Firebase dodaj nową aplikację internetową i wybierz opcję skonfigurowania Hostingu.

  2. W sekcji Uwierzytelnianie w konsoli Firebase włącz dostawcę Google, którego użyjesz w tym przykładzie.

  3. W katalogu projektu skonfiguruj Hosting Firebase, w którym wdrożysz przykładową aplikację:

    cd $PROJECT_ROOT
firebase init hosting

    Zaakceptuj wartości domyślne dla wszystkich promptów.

  4. Zastąp public/index.html tym:

    <!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="suggestMenuItem">Suggest a menu theme</button>
      <p id="menuItem"></p>
    </div>
    <script type="module">
      import { initializeApp } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-app.js';
      import {
        getAuth,
        onAuthStateChanged,
        GoogleAuthProvider,
        signInWithPopup,
      } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-auth.js';
      import {
        getFunctions,
        httpsCallable,
      } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-functions.js';

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

      async function generateMenuItem() {
        const menuSuggestionFlow = httpsCallable(
          getFunctions(),
          'menuSuggestionFlow'
        );
        const subject = document.querySelector('#subject').value;
        const response = await menuSuggestionFlow(subject);
        document.querySelector('#menuItem').innerText = response.data;
      }

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

      document
        .querySelector('#signinBtn')
        .addEventListener('click', signIn);
      document
        .querySelector('#suggestMenuItem')
        .addEventListener('click', generateMenuItem);

      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>

  5. Wdróż aplikację internetową i funkcję w Cloud Functions:

    cd $PROJECT_ROOT
firebase deploy

Otwórz aplikację internetową, klikając adres URL wygenerowany w poleceniu deploy. Aplikacja wymaga zalogowania się na konto Google, po których możesz inicjować żądania punktów końcowych.

Programowanie z użyciem Pakietu emulatorów lokalnych Firebase

Firebase zapewnia zestaw emulatorów do lokalnego programowania, których możesz używać z Genkit.

Aby używać Genkit z Pakietem emulatorów Firebase, uruchom emulatory Firebase w ten sposób:

GENKIT_ENV=dev firebase emulators:start --inspect-functions

Spowoduje to uruchomienie kodu w emulatorze oraz uruchomienie platformy Genkit w trybie programistycznym, co spowoduje uruchomienie i udostępnienie interfejsu Genkit Exploreion API (ale nie interfejsu deweloperskiego).

Następnie uruchom interfejs Genkit Dev z opcją --attach, aby połączyć go z kodem działającym w emulatorze Firebase:

genkit start --attach http://localhost:3100 --port 4001

Aby wyświetlić ślady z Firestore w interfejsie deweloperskim, możesz przejść na kartę Inspekcja i przełączyć się na przełącznik „Dev/Prod” (Dev/Prod). Po przełączeniu na tryb „prod” ślady z firestore będą wczytywane.