Obsługa zdarzeń cyklu życia rozszerzenia

Rozszerzenie może zawierać Cloud Tasks funkcje które są aktywowane, gdy wystąpienie rozszerzenia przechodzi przez dowolną z tych wartości zdarzenia cyklu życia:

• Zainstalowana jest instancja rozszerzenia
• Instancja rozszerzenia jest aktualizowana do nowej wersji
• Zmieniono konfigurację instancji rozszerzenia

Jednym z najważniejszych przypadków użycia tej funkcji jest tworzenie kopii zapasowej danych. Dla: Załóżmy, że tworzysz rozszerzenie generujące podgląd miniatur obrazów przesłanych do zasobnika Cloud Storage. Główne zadanie rozszerzenia wykonywana w funkcji wywoływanej przez zdarzenie onFinalize Cloud Storage. Jednak tylko obrazy przesłane po zainstalowaniu rozszerzenia będą stosowane tylko do tej pory. przetworzono. Poprzez włączenie w rozszerzeniu funkcji uruchamianej przez tag onInstall zdarzenia cyklu życia, możesz też wygenerować podgląd miniatur dowolnego istniejących obrazy, gdy rozszerzenie jest zainstalowane.

Inne przypadki użycia aktywatorów zdarzeń cyklu życia:

• Zautomatyzuj konfigurację po instalacji (tworzenie rekordów bazy danych, indeksowanie itp.)
• Jeśli musisz opublikować zmiany niezgodne wstecznie, przeprowadź automatyczną migrację dane po aktualizacji

Krótkie moduły obsługi zdarzeń cyklu życia

Jeśli zadanie może zostać w całości uruchomione w maksymalnie Cloud Functions czas trwania (9 minut za pomocą interfejsu API pierwszej generacji), możesz zapisać zdarzenie cyklu życia jako pojedynczą funkcję, która wyzwala zdarzenie onDispatch kolejki zadań:

export const myTaskFunction = functions.tasks.taskQueue()
  .onDispatch(async () => {
    // Complete your lifecycle event handling task.
    // ...

    // When processing is complete, report status to the user (see below).
  });

Następnie w pliku extension.yaml rozszerzenia wykonaj te czynności:

1. Zarejestruj funkcję jako zasób rozszerzenia w taskQueueTrigger zestawu właściwości. Jeśli ustawisz taskQueueTrigger na pustą mapę ({}), rozszerzenie udostępni kolejkę Cloud Tasks z użyciem domyślnej ustawienia; Opcjonalnie możesz dostosować te ustawienia.

   resources:
     - name: myTaskFunction
       type: firebaseextensions.v1beta.function
       description: >-
         Describe the task performed when the function is triggered by a lifecycle
         event
       properties:
         location: ${LOCATION}
         taskQueueTrigger: {}
   

2. Zarejestruj funkcję jako moduł obsługi co najmniej 1 zdarzenia cyklu życia:

   resources:
     - ...
   lifecycleEvents:
     onInstall:
       function: myTaskFunction
       processingMessage: Resizing your existing images
     onUpdate:
       function: myOtherTaskFunction
       processingMessage: Setting up your extension
     onConfigure:
       function: myOtherTaskFunction
       processingMessage: Setting up your extension
   
   

   Funkcje możesz zarejestrować dla tych zdarzeń: onInstall, onUpdate i onConfigure. Wszystkie te zdarzenia są opcjonalne.

   Uwaga: wskazana tutaj wiadomość jest automatycznie ustawiana jako stan przetwarzania w konsoli Firebase przy aktywowaniu funkcji. Aby zaktualizować lub wyczyścić stan przetwarzania po zakończeniu Work, wywołaj setProcessingState() zgodnie z opisem w sekcji Stan raportowania .

3. Zalecane: jeśli zadanie przetwarzania nie jest wymagane, aby rozszerzenie do: służbowy, dodaj parametr konfigurowany przez użytkownika , który pozwala użytkownikom zdecydować, czy chcą ją włączyć.

   Na przykład dodaj taki parametr:

   params:
     - param: DO_BACKFILL
       label: Backfill existing images
       description: >
         Should existing, unresized images in the Storage bucket be resized as well?
       type: select
       options:
         - label: Yes
           value: true
         - label: No
           value: false
   

   Jeśli parametr jest ustawiony na false, w Twojej funkcji zwróć uwagę na wcześniejsze wyjście:

   export const myTaskFunction = functions.tasks.taskQueue()
     .onDispatch(async () => {
       if (!process.env.DO_BACKFILL) {
         await runtime.setProcessingState(
           "PROCESSING_COMPLETE",
           "Existing images were not resized."
         );
         return;
       }
       // Complete your lifecycle event handling task.
       // ...
     });
   

Wykonywanie długotrwałych zadań

Jeśli zadanie nie zostanie ukończone w ciągu maksymalnego czasu trwania Cloud Functions, Podzielić zadanie na podzadania i wykonać je po kolei, umieszczając w kolejce z zadaniami z pakietu TaskQueue.enqueue() pakietu Admin SDK. .

Uwaga: nie umieszczaj w kolejce wszystkich podzadań naraz, aby je przetworzyć równoległe. Autoryzacja odbywa się w czasie dodawania do kolejki, więc zadania pod koniec nie będzie można jej przywrócić, jeśli autoryzacja wygaśnie przed rozpoczęciem. Zamiast tego wykonuj podzadania szeregowo, zgodnie z opisem w tej sekcji.

Załóżmy na przykład, że chcesz uzupełnić dane Cloud Firestore. Dostępne opcje podzielić kolekcję dokumentów na fragmenty za pomocą kursorów zapytań. Po przetworzeniu fragmentu przesuń przesunięcie początkowe i umieść w kolejce kolejne funkcję wywołania funkcji, jak pokazano poniżej:

import { getFirestore } from "firebase-admin/firestore";
import { getFunctions } from "firebase-admin/functions";

exports.backfilldata = functions.tasks.taskQueue().onDispatch(async (data) => {
  // When a lifecycle event triggers this function, it doesn't pass any data,
  // so an undefined offset indicates we're on our first invocation and should
  // start at offset 0. On subsequent invocations, we'll pass an explicit
  // offset.
  const offset = data["offset"] ?? 0;

  // Get a batch of documents, beginning at the offset.
  const snapshot = await getFirestore()
    .collection(process.env.COLLECTION_PATH)
    .startAt(offset)
    .limit(DOCS_PER_BACKFILL)
    .get();
  // Process each document in the batch.
  const processed = await Promise.allSettled(
    snapshot.docs.map(async (documentSnapshot) => {
      // Perform the processing.
    })
  );

  // If we processed a full batch, there are probably more documents to
  // process, so enqueue another invocation of this function, specifying
  // the offset to start with.
  //
  // If we processed less than a full batch, we're done.
  if (processed.length == DOCS_PER_BACKFILL) {
    const queue = getFunctions().taskQueue(
      "backfilldata",
      process.env.EXT_INSTANCE_ID
    );
    await queue.enqueue({
      offset: offset + DOCS_PER_BACKFILL,
    });
  } else {
      // Processing is complete. Report status to the user (see below).
  }
});

Dodaj funkcję do extension.yaml w sposób opisany w poprzednia sekcja.

Stan raportowania

Gdy wszystkie funkcje przetwarzania zakończą się poprawnie, , zgłoś stan zadania, korzystając z środowiska wykonawczego rozszerzenia Admin SDK . Użytkownicy mogą sprawdzić ten stan na stronie szczegółów rozszerzenia w Konsola Firebase.

Uwaga: zgłaszaj stan tylko raz za każdym razem, gdy obsługujesz regułę zdarzenia cyklu życia. W zwłaszcza gdy podzielisz zadanie przetwarzania na kilka funkcji nie powinny podawać stanu w przypadku każdego wywołania.

Udane ukończenie i błędy niekrytyczne

Do zgłaszania błędów związanych z ukończeniem i niekrytycznych (błędy, które nie znalazły się w tagu rozszerzenie do stanu, który nie działa), użyj pakietu Admin SDK Metoda działania rozszerzenia setProcessingState():

import { getExtensions } from "firebase-admin/extensions";

// ...

getExtensions().runtime().setProcessingState(processingState, message);

Możesz ustawić te stany:

Stany niekrytyczne
PROCESSING_COMPLETE	Służy do raportowania udanego ukończenia zadania. Przykład: getExtensions().runtime().setProcessingState( "PROCESSING_COMPLETE", `Backfill complete. Successfully processed ${numSuccess} documents.` );
PROCESSING_WARNING	Służy do raportowania częściowego powodzenia. Przykład: getExtensions().runtime().setProcessingState( "PROCESSING_WARNING", `Backfill complete. ${numSuccess} documents processed successfully.` + ` ${numFailed} documents failed to process. ${listOfErrors}.` + ` ${instructionsToFixTheProblem}` );
PROCESSING_FAILED	Służy do zgłaszania błędów, które uniemożliwiają wykonanie zadania, ale nie powodują jego zakończenia pozostawiając rozszerzenie bezużyteczne. Przykład: getExtensions().runtime().setProcessingState( "PROCESSING_FAILED", `Backfill failed. ${errorMsg} ${optionalInstructionsToFixTheProblem}.` ); Aby zgłosić błędy, które pozostają bezużyteczne, wywołaj setFatalError().
NONE	Użyj tej opcji, aby wyczyścić stan zadania. Opcjonalnie możesz użyć tej opcji, aby wyczyścić komunikat o stanie w konsoli (na przykład po odwiedzeniu kilku czas od ustawienia PROCESSING_COMPLETE). Przykład: getExtensions().runtime().setProcessingState("NONE");

Błędy krytyczne

Jeśli wystąpi błąd, który uniemożliwia działanie rozszerzenia, w przypadku jeśli nie udało się wykonać wymaganego zadania konfiguracji, zgłoś błąd krytyczny, setFatalError():

import { getExtensions } from "firebase-admin/extensions";

// ...

getExtensions().runtime().setFatalError(`Post-installation setup failed. ${errorMessage}`);

Dostrajanie kolejki zadań

Jeśli ustawisz właściwość taskQueueTrigger na {}, rozszerzenie będzie udostępnij kolejkę Cloud Tasks z ustawieniami domyślnymi, gdy rozszerzenie została zainstalowana. Możesz też dostroić równoczesność kolejki zadań i ponawiaj próby, podając określone wartości:

resources:
  - name: myTaskFunction
    type: firebaseextensions.v1beta.function
    description: >-
      Perform a task when triggered by a lifecycle event
    properties:
      location: ${LOCATION}
      taskQueueTrigger:
        rateLimits:
          maxConcurrentDispatches: 1000
          maxDispatchesPerSecond: 500
        retryConfig:
          maxAttempts: 100  # Warning: setting this too low can prevent the function from running
          minBackoffSeconds: 0.1
          maxBackoffSeconds: 3600
          maxDoublings: 16
lifecycleEvents:
  onInstall: 
    function: myTaskFunction
    processingMessage: Resizing your existing images
  onUpdate:
    function: myTaskFunction
    processingMessage: Setting up your extension
  onConfigure:
    function: myOtherTaskFunction
    processingMessage: Setting up your extension

Zobacz Konfigurowanie kolejek Cloud Tasks. w dokumentacji Google Cloud, aby dowiedzieć się więcej o tych parametrach.

Nie próbuj określać parametrów kolejki zadań przez przekazywanie ich do usługi taskQueue(). Te ustawienia są ignorowane na rzecz konfiguracji extension.yaml i z ustawieniami domyślnymi konfiguracji.

Na przykład to nie zadziała:

export const myBrokenTaskFunction = functions.tasks
  // DON'T DO THIS IN AN EXTENSION! THESE SETTINGS ARE IGNORED.
  .taskQueue({
    retryConfig: {
      maxAttempts: 5,
      minBackoffSeconds: 60,
    },
    rateLimits: {
      maxConcurrentDispatches: 1000,
      maxDispatchesPerSecond: 10,
    },
  })
  .onDispatch(
    // ...
  );

Jedynym sposobem konfiguracji jest właściwość taskQueueTrigger w tabeli extension.yaml kolejek zadań rozszerzenia.

Przykłady

Oficjalna aplikacja storage-resize-images, firestore-bigquery-export, i firestore-translate-text wszystkie rozszerzenia używają modułów obsługi zdarzeń cyklu życia do uzupełniania danych.