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.

Ta strona została przetłumaczona przez Cloud Translation API.

Genkit z Cloud Functions dla Firebase

Firebase Genkit zawiera wtyczkę, która ułatwia wdrażanie przepływów w Firebase Cloud Functions. Na tej stronie omówiono na przykład proces wdrożenia domyślnego przykładowego przepływu w Firebase.

Wdrażanie przepływu jako funkcji w Cloud Functions

Zainstaluj wymagane narzędzia:
1. Upewnij się, że używasz środowiska Node.js w wersji 20 lub nowszej (uruchom node --version do zaznacz).
2. Zainstaluj interfejs wiersza poleceń Firebase.
Utwórz nowy projekt Firebase za pomocą konsoli Firebase lub wybierz istniejący.

Przenieś projekt na abonament Blaze, który jest wymagany do wdrożenia Cloud Funkcje.

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

Utwórz nowy katalog projektu:

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

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 kilka przykładowych plików źródłowych, które pomogą Ci utworzyć własne przepływy pracy AI. Jednak w pozostałej części tego samouczka wdrożysz tylko przykładowy przepływ.
Udostępnij swoje dane logowania do interfejsu API funkcji w Cloud Functions. Wykonaj jedną z tych czynności: w zależności od wybranego dostawcy modelu:
Gemini (AI od Google)
1. Upewnij się, że AI od Google jest dostępna w Twoim regionie.
2. Wygeneruj klucz interfejsu API dla platformy Gemini API za pomocą Google AI Studio.
3. Przechowuj klucz interfejsu API w usłudze Cloud Secret Manager:
```
firebase functions:secrets:set GOOGLE_GENAI_API_KEY
```
  Ten krok jest ważny, aby zapobiec przypadkowemu ujawnieniu klucza interfejsu API. Daje on dostęp do usługi potencjalnie z pomiarem użycia danych.
  
  Zapoznaj się z sekcją Przechowywanie poufnych informacji o konfiguracji i uzyskiwanie do nich dostępu. .
4. Edytuj pole src/index.ts i po zakończeniu importowania dodaj te elementy:
```
import {defineSecret} from "firebase-functions/params";
const googleAIapiKey = defineSecret("GOOGLE_GENAI_API_KEY");
```
  Następnie w definicji przepływu zadeklaruj, że funkcja w Cloud Functions dostęp do tej wartości obiektu tajnego:
```
export const menuSuggestionFlow = onFlow(
  {
    name: "menuSuggestionFlow",
    // ...
    httpsOptions: {
      secrets: [googleAIapiKey],  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);
```
Teraz po wdrożeniu tej funkcji Twój klucz interfejsu API będzie przechowywany w Usługa Cloud Secret Manager; dostępna z poziomu Cloud Functions dla środowiska.
Gemini (Vertex AI)
1. W konsoli Google Cloud Włączanie interfejsu Vertex AI API do swojego projektu Firebase.
2. W Uprawnieniach sprawdź, czy przyznano domyślne konto usługi Compute. rolę Użytkownik Vertex AI.
Jedynym obiektem tajnym, który musisz skonfigurować na potrzeby tego samouczka, jest model ale z reguły należy zrobić coś podobnego w przypadku każdej usługi używane przez przepływ.
Jeśli będziesz uzyskiwać dostęp do procesu z aplikacji internetowej (będziesz to robić w sekcji następnej sekcji) w parametrze httpsOptions ustaw zasadę CORS:
```
export const menuSuggestionFlow = onFlow(
  {
    name: "menuSuggestionFlow",
    // ...
    httpsOptions: {
      cors: true,  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);
```
Prawdopodobnie zalecane byłyby bardziej restrykcyjne zasady w przypadku aplikacji w wersji produkcyjnej, w tym samouczku.
Opcjonalnie: spróbuj wykonać opisane niżej czynności w interfejsie dewelopera:
1. Udostępnij dane logowania do interfejsu API lokalnie. Wykonaj jedną z tych czynności: w zależności od wybranego dostawcy modelu:
  Gemini (AI od Google)
  Ustaw zmienną środowiskową GOOGLE_GENAI_API_KEY na swój klucz:
```
export GOOGLE_GENAI_API_KEY=<your API key>
```
  Gemini (Vertex AI)
  Ustaw kilka dodatkowych zmiennych środowiskowych i użyj Narzędzie gcloud do konfiguracji domyślne dane uwierzytelniające aplikacji lokalnie:
```
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
gcloud auth application-default login
```
2. Uruchom interfejs:
```
cd $PROJECT_ROOT/functions
genkit start
```
3. 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 Wykonaj.
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. Nie można jednak: dostęp do wdrożonego punktu końcowego za pomocą: curl lub podobnej, ze względu na zasadą autoryzacji. Przejdź do następnej sekcji, aby dowiedzieć się, jak bezpiecznie przejść do procesu.

Wypróbuj wdrożony proces

Bardzo ważne jest, aby każdy wdrażany przepływ ustawiał zasadę autoryzacji. Bez po pierwsze, potencjalnie kosztowne procesy generatywnej AI do dowolnych osób.

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 użytkowników aplikacji ze zweryfikowanymi adresami e-mail. Po stronie klienta musisz ustaw nagłówek Authorization: Bearer na token identyfikatora Firebase, który spełnia warunki zasady. Pakiety SDK klienta Cloud Functions funkcja wywoływana które automatyzują ten proces.

Aby wypróbować punkt końcowy przepływu, możesz wdrożyć poniższe, minimalistyczne przykłady w internecie. aplikacja:

W Ustawienia projektu konsoli Firebase, dodaj nową aplikację internetową, zaznacz opcję skonfiguruj też Hosting.
W Uwierzytelnianie konsoli Firebase, włącz dostawcę Google – którego użyjemy w tym przykładzie.
W katalogu projektu skonfiguruj Hosting Firebase, w którym wdrożysz usługę przykładową aplikację:
```
cd $PROJECT_ROOT
firebase init hosting
```
Zaakceptuj wartości domyślne dla wszystkich promptów.

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>

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órym można zainicjować żądań 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ść do karty Inspekcja i przełączyć przełącznik „Dev/Prod” na „Dev/Prod” Po przełączeniu na tryb „prod” będzie on wczytywał ślady z firestore.