Autoryzacja i integralność

Przy tworzeniu aplikacji dostępnych publicznie należy koniecznie danych przechowywanych w systemie. W przypadku LLM należy zachować szczególną ostrożność, niezbędne do zagwarantowania, że model uzyskuje dostęp tylko do danych, do których powinien. Wywołania narzędzi mają prawidłowy zakres dla użytkownika wywołującego LLM, a przepływ jest wywoływany wyłącznie przez zweryfikowane aplikacje klienckie.

Firebase Genkit udostępnia mechanizmy do zarządzania zasadami autoryzacji i kontekstach. W przypadku przepływów działających w Cloud Functions dla Firebase programiści muszą musi przedstawić zasady uwierzytelniania lub jednoznacznie potwierdzić brak jeden. W przypadku przepływów niezwiązanych z funkcjami uwierzytelnianiem można też ustawiać i zarządzać, ale wymaga ono ale w przypadku bardziej ręcznej integracji.

Podstawowa autoryzacja przepływu

Wszystkie przepływy mogą definiować authPolicy w swojej konfiguracji. Zasada uwierzytelniania to funkcja, która sprawdza, czy określone kryteria (zdefiniowane przez Ciebie) są spełnione, i w przypadku niepowodzenia testu zgłasza wyjątek. Jeśli to pole jest ustawione, jest wykonywane przed wywołaniem przepływu:

import { defineFlow, runFlow } from '@genkit-ai/flow';

export const selfSummaryFlow = defineFlow(
  {
    name: 'selfSummaryFlow',
    inputSchema: z.object({uid: z.string()}),
    outputSchema: z.string(),
    authPolicy: (auth, input) => {
      if (!auth) {
        throw new Error('Authorization required.');
      }
      if (input.uid !== auth.uid) {
        throw new Error('You may only summarize your own profile data.');
      }
    }
  },
  async (input) => { ... });

Podczas wykonywania tego procesu musisz podać obiekt uwierzytelniania za pomocą withLocalAuthContext. W przeciwnym razie zostanie wyświetlony błąd:

// Error: Authorization required.
await runFlow(selfSummaryFlow, { uid: 'abc-def' });

// Error: You may only summarize your own profile data.
await runFlow(
  selfSummaryFlow,
  { uid: 'abc-def' },
  {
    withLocalAuthContext: { uid: 'hij-klm' },
  }
);

// Success
await runFlow(
  selfSummaryFlow,
  { uid: 'abc-def' },
  {
    withLocalAuthContext: { uid: 'abc-def' },
  }
);

W przypadku uruchomienia z interfejsem programistycznym Genkit możesz przekazać obiekt Auth przez wpisz kod JSON w polu „Auth JSON” karta: {"uid": "abc-def"}.

Kontekst uwierzytelniania możesz też pobrać w dowolnym momencie procesu. przez wywołanie metody getFlowAuth(), również w funkcjach wywoływanych przez przepływ:

import { getFlowAuth, defineFlow } from '@genkit-ai/flow';

async function readDatabase(uid: string) {
  if (getFlowAuth().admin) {
    // Do something special if the user is an admin:
    ...
  } else {
    // Otherwise, use the `uid` variable to retrieve the relevant document
    ...
  }
}

export const selfSummaryFlow = defineFlow(
  {
    name: 'selfSummaryFlow',
    inputSchema: z.object({uid: z.string()}),
    outputSchema: z.string(),
    authPolicy: ...
  },
  async (input) => {
    ...
    await readDatabase(input.uid);
  });

Podczas testowania przepływów za pomocą narzędzi dla programistów Genkit możesz określić to uwierzytelnianie w interfejsie użytkownika lub w wierszu poleceń z flagą --auth:

genkit flow:run selfSummaryFlow '{"uid": "abc-def"}' --auth '{"uid": "abc-def"}'

Integracja Cloud Functions dla Firebase

Wtyczka Firebase zapewnia wygodną integrację z Uwierzytelnianiem Firebase / Google z Cloud Identity Platform oraz wbudowaną obsługą Sprawdzania aplikacji Firebase.

Autoryzacja

Opakowanie onFlow() dostarczane przez wtyczkę Firebase działa natywnie z tagiem Cloud Functions dla Firebase pakietów SDK klientów. W przypadku korzystania z pakietu SDK nagłówek Uwierzytelniania Firebase będzie automatycznie uwzględniany jako o ile klient aplikacji również używa Pakiet SDK Firebase Auth. Uwierzytelniania Firebase możesz używać do ochrony przepływów zdefiniowanych w onFlow():

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

export const selfSummaryFlow = onFlow({
    name: "selfSummaryFlow",
    inputSchema: z.string(),
    outputSchema: z.string(),
    authPolicy: firebaseAuth((user) => {
      if (!user.email_verified && !user.admin) {
        throw new Error("Email not verified");
      }
    }),
  }, (subject) => {...})

Podczas korzystania z wtyczki Uwierzytelnianie Firebase interfejs user będzie zwracany jako DecodedIdToken. W każdej chwili możesz pobrać ten obiekt przy użyciu getFlowAuth(), jak zaznaczono powyżej. Uruchamiając ten proces w trakcie programowania, przekażesz obiekt użytkownika w ten sam sposób:

genkit flow:run selfSummaryFlow '{"uid": "abc-def"}' --auth '{"admin": true}'

Domyślnie wtyczka Firebase Auth wymaga, aby nagłówek uwierzytelniania był wysyłany przez klienta, ale w przypadkach, gdy chcesz zezwolić na nieuwierzytelniony dostęp, używając specjalnych obsługi uwierzytelnionych użytkowników (np. w celu zwiększenia sprzedaży), możesz skonfiguruj zasadę w następujący sposób:

authPolicy: firebaseAuth((user) => {
  if (user && !user.email_verified) {
    throw new Error("Logged in users must have verified emails");
  }
}, {required: false}),

Gdy udostępniasz funkcję w Cloud Functions w szerszym internecie, ważne jest użycie jakiegoś rodzaju mechanizmu autoryzacji do ochrony danych i danych klientów. Mimo to zdarzają się sytuacje, w których aby wdrożyć funkcję w Cloud Functions bez testów autoryzacji opartych na kodzie (na przykład funkcja nie jest wywoływana przez świat, ale jest chroniona przez Cloud IAM). Gdy używasz onFlow(), pole authPolicy jest zawsze wymagane, ale możesz poinformować bibliotekę, że przechodzisz testy autoryzacji, korzystając z Funkcja noAuth():

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

export const selfSummaryFlow = onFlow({
    name: "selfSummaryFlow",
    inputSchema: z.string(),
    outputSchema: z.string(),
    // WARNING: Only do this if you have some other gatekeeping in place, like
    // Cloud IAM!
    authPolicy: noAuth(),
  }, (subject) => {...})

Uczciwość klienta

Samo uwierzytelnianie pomaga w ochronie aplikacji. Jest to też musisz mieć pewność, że tylko aplikacje klienckie wywołują Twoje funkcje. Wtyczka Firebase do genkit zapewnia najwyższej klasy obsługę Sprawdzanie aplikacji Firebase. Po prostu dodaj te opcje konfiguracji w: onFlow():

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

export const selfSummaryFlow = onFlow({
    name: "selfSummaryFlow",
    inputSchema: z.string(),
    outputSchema: z.string(),

    // These two fields for app check. The consumeAppCheckToken option is for
    // replay protection, and requires additional client configuration. See the
    // App Check docs.
    enforceAppCheck: true,
    consumeAppCheckToken: true,

    authPolicy: ...,
  }, (subject) => {...})

Autoryzacja HTTP spoza Firebase

Podczas wdrażania przepływów w kontekście serwera poza Cloud Functions w Firebase, musisz mieć możliwość skonfigurowania własnych mechanizmów sprawdzania autoryzacji w porównaniu z procesami natywnymi. Dostępne są dwie opcje:

1. Możesz używać dowolnej platformy serwera i przekazać kontekst uwierzytelniania za pomocą runFlow(), jak zaznaczono powyżej.

2. Użyj wbudowanego narzędzia startFlowsServer() i udostępnij ekspresowe oprogramowanie pośredniczące w konfiguracja przepływu:

   export const selfSummaryFlow = defineFlow(
   {
     name: 'selfSummaryFlow',
     inputSchema: z.object({uid: z.string()}),
     outputSchema: z.string(),
     middleware: [
       (req, res, next) => {
         const token = req.headers['authorization'];
         const user = yourVerificationLibrary(token);
   
         // This is what will get passed to your authPolicy
         req.auth = user;
         next();
       }
     ],
     authPolicy: (auth, input) => {
       if (!auth) {
         throw new Error('Authorization required.');
       }
       if (input.uid !== auth.uid) {
         throw new Error('You may only summarize your own profile data.');
       }
     }
   },
   async (input) => { ... });
   
   startFlowsServer();  // This will register the middleware
   

   Więcej informacji o korzystaniu z usługi Express znajdziesz w artykule Cloud Run. za instrukcje.

Pamiętaj, że jeśli wybierzesz (1), opcja konfiguracji middleware będzie mogą zostać zignorowane przez: runFlow().