Catch up on highlights from Firebase at Google I/O 2023. Learn more

Zarządzaj funkcjami


Możesz wdrażać, usuwać i modyfikować funkcje za pomocą poleceń Firebase CLI lub ustawiając opcje środowiska uruchomieniowego w kodzie źródłowym funkcji.

Wdróż funkcje

Aby wdrożyć funkcje, uruchom to polecenie Firebase CLI:

firebase deploy --only functions

Domyślnie Firebase CLI wdraża jednocześnie wszystkie funkcje w Twoim źródle. Jeśli Twój projekt zawiera więcej niż 5 funkcji, zalecamy użycie flagi --only z określonymi nazwami funkcji, aby wdrożyć tylko te funkcje, które edytowałeś. Wdrażanie określonych funkcji w ten sposób przyspiesza proces wdrażania i pomaga uniknąć przekroczenia limitów wdrożenia. Na przykład:

firebase deploy --only functions:addMessage,functions:makeUppercase

Wdrażając dużą liczbę funkcji, możesz przekroczyć standardowy przydział i otrzymać komunikaty o błędach HTTP 429 lub 500. Aby rozwiązać ten problem, wdrażaj funkcje w grupach po 10 lub mniej.

Zobacz dokumentację Firebase CLI , aby uzyskać pełną listę dostępnych poleceń.

Domyślnie Firebase CLI szuka kodu źródłowego w folderze functions/ . Jeśli wolisz, możesz organizować funkcje w bazach kodu lub wielu zestawach plików.

Usuń funkcje

Możesz usunąć wcześniej wdrożone funkcje w następujący sposób:

  • jawnie w Firebase CLI z functions:delete
  • jawnie w Google Cloud Console .
  • niejawnie , usuwając funkcję ze źródła przed wdrożeniem.

Wszystkie operacje usuwania wymagają potwierdzenia przed usunięciem funkcji z produkcji.

Jawne usuwanie funkcji w Firebase CLI obsługuje wiele argumentów, a także grupy funkcji i umożliwia określenie funkcji działającej w określonym regionie. Możesz także zastąpić monit o potwierdzenie.

# Delete all functions that match the specified name in all regions.
firebase functions:delete myFunction

# Delete a specified function running in a specific region.
firebase functions:delete myFunction --region us-east-1

# Delete more than one function
firebase functions:delete myFunction myOtherFunction

# Delete a specified functions group.
firebase functions:delete groupA

# Bypass the confirmation prompt.
firebase functions:delete myFunction --force

Dzięki niejawnemu usuwaniu funkcji firebase deploy analizuje źródło i usuwa z produkcji wszelkie funkcje, które zostały usunięte z pliku.

Zmodyfikuj nazwę funkcji, region lub wyzwalacz

W przypadku zmiany nazwy lub zmiany regionów lub wyzwalacza dla funkcji obsługujących ruch produkcyjny wykonaj czynności opisane w tej sekcji, aby uniknąć utraty zdarzeń podczas modyfikacji. Zanim wykonasz te kroki, najpierw upewnij się, że twoja funkcja jest idempotentna , ponieważ zarówno nowa, jak i stara wersja twojej funkcji będą działać w tym samym czasie podczas zmiany.

Zmień nazwę funkcji

Aby zmienić nazwę funkcji, utwórz nową wersję funkcji ze zmienioną nazwą w swoim źródle, a następnie uruchom dwa oddzielne polecenia wdrażania. Pierwsze polecenie wdraża nowo nazwaną funkcję, a drugie polecenie usuwa wcześniej wdrożoną wersję. Na przykład, jeśli masz funkcję Node.js o nazwie webhook , którą chcesz zmienić na webhookNew , popraw kod w następujący sposób:

// before
const functions = require('firebase-functions');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions');

exports.webhookNew = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

Następnie uruchom następujące polecenia, aby wdrożyć nową funkcję:

# Deploy new function called webhookNew
firebase deploy --only functions:webhookNew

# Wait until deployment is done; now both webhookNew and webhook are running

# Delete webhook
firebase functions:delete webhook

Zmień region lub regiony funkcji

Jeśli zmieniasz określone regiony dla funkcji obsługującej ruch produkcyjny, możesz zapobiec utracie zdarzeń, wykonując następujące kroki w podanej kolejności:

  1. Zmień nazwę funkcji i zmień jej region lub regiony zgodnie z potrzebami.
  2. Wdróż funkcję o zmienionej nazwie, co spowoduje tymczasowe uruchomienie tego samego kodu w obu zestawach regionów.
  3. Usuń poprzednią funkcję.

Na przykład, jeśli masz funkcję o nazwie webhook , która znajduje się obecnie w domyślnym regionie funkcji us-central1 i chcesz ją przenieść do asia-northeast1 , musisz najpierw zmodyfikować kod źródłowy, aby zmienić nazwę funkcji i poprawić region .

// before
const functions = require('firebase-functions');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

Następnie wdróż, uruchamiając:

firebase deploy --only functions:webhookAsia

Teraz działają dwie identyczne funkcje: webhook działa w us-central1 , a webhookAsia działa w asia-northeast1 .

Następnie usuń webhook :

firebase functions:delete webhook

Teraz jest tylko jedna funkcja - webhookAsia , która działa w asia-northeast1 .

Zmień typ wyzwalacza funkcji

W miarę rozwoju wdrożenia Cloud Functions for Firebase w miarę upływu czasu może zaistnieć potrzeba zmiany typu wyzwalacza funkcji z różnych powodów. Na przykład możesz chcieć zmienić jeden typ zdarzenia Firebase Realtime Database lub Cloud Firestore na inny typ.

Nie można zmienić typu zdarzenia funkcji, po prostu zmieniając kod źródłowy i uruchamiając firebase deploy . Aby uniknąć błędów, zmień typ wyzwalacza funkcji, wykonując następującą procedurę:

  1. Zmodyfikuj kod źródłowy, aby zawierał nową funkcję z żądanym typem wyzwalacza.
  2. Wdróż funkcję, co spowoduje tymczasowe uruchomienie zarówno starej, jak i nowej funkcji.
  3. Jawnie usuń starą funkcję z produkcji za pomocą Firebase CLI.

Na przykład, jeśli masz funkcję Node.js o nazwie objectChanged , która ma starszy typ zdarzenia onChange i chcesz ją zmienić na onFinalize , najpierw zmień nazwę funkcji i edytuj ją, aby miała typ zdarzenia onFinalize .

// before
const functions = require('firebase-functions');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions');

exports.objectFinalized = functions.storage.object().onFinalize((object) => {
    return console.log('File name is: ', object.name);
});

Następnie uruchom następujące polecenia, aby najpierw utworzyć nową funkcję, zanim usuniesz starą funkcję:

# Create new function objectFinalized
firebase deploy --only functions:objectFinalized

# Wait until deployment is done; now both objectChanged and objectFinalized are running

# Delete objectChanged
firebase functions:delete objectChanged

Ustaw opcje środowiska uruchomieniowego

Cloud Functions for Firebase umożliwia wybór opcji środowiska wykonawczego, takich jak wersja środowiska uruchomieniowego Node.js i limit czasu dla poszczególnych funkcji, alokacja pamięci oraz minimalna/maksymalna liczba wystąpień funkcji.

W ramach najlepszej praktyki te opcje (z wyjątkiem wersji Node.js) powinny być ustawione na obiekcie konfiguracyjnym wewnątrz kodu funkcji. Ten obiekt RuntimeOptions jest źródłem prawdy dla opcji środowiska wykonawczego Twojej funkcji i zastąpi opcje ustawione za pomocą dowolnej innej metody (na przykład za pomocą konsoli Google Cloud lub interfejsu wiersza polecenia gcloud).

Jeśli Twój przepływ pracy programistycznej obejmuje ręczne ustawianie opcji środowiska wykonawczego za pomocą konsoli Google Cloud lub interfejsu wiersza polecenia gcloud i nie chcesz, aby te wartości były zastępowane przy każdym wdrożeniu, ustaw opcję preserveExternalChanges na true . Gdy ta opcja jest ustawiona na true , Firebase scala opcje środowiska uruchomieniowego ustawione w twoim kodzie z ustawieniami aktualnie wdrożonej wersji twojej funkcji z następującym priorytetem:

  1. Opcja jest ustawiona w kodzie funkcji: zastąp zmiany zewnętrzne.
  2. Opcja jest ustawiona na RESET_VALUE w kodzie funkcji: zastąp zmiany zewnętrzne wartością domyślną.
  3. Opcja nie jest ustawiona w kodzie funkcji, ale jest ustawiona w aktualnie wdrożonej funkcji: użyj opcji określonej we wdrożonej funkcji.

Używanie opcji preserveExternalChanges: true nie jest zalecane w większości scenariuszy, ponieważ Twój kod nie będzie już pełnym źródłem prawdy dla opcji środowiska uruchomieniowego dla twoich funkcji. Jeśli go używasz, sprawdź konsolę Google Cloud lub użyj interfejsu wiersza polecenia gcloud, aby wyświetlić pełną konfigurację funkcji.

Ustaw wersję Node.js

Firebase SDK for Cloud Functions 2.0.0 lub nowszy umożliwia wybór środowiska uruchomieniowego Node.js. Możesz wybrać uruchamianie wszystkich funkcji w projekcie wyłącznie w środowisku wykonawczym odpowiadającym jednej z obsługiwanych wersji Node.js:

  • Node.js 20 (wersja zapoznawcza)
  • Node.js 18
  • Node.js 16
  • Node.js 14

Aby ustawić wersję Node.js:

Ustaw wersję w polu engines w pliku package.json , który został utworzony w twoim katalogu functions/ podczas inicjalizacji. Na przykład, aby używać tylko wersji 18, edytuj ten wiersz w package.json :

  "engines": {"node": "18"}

Pole engines jest wymagane; musi określać jedną z obsługiwanych wersji Node.js, aby można było wdrożyć i uruchomić funkcje.

Uaktualnij środowisko uruchomieniowe Node.js

Aby zaktualizować środowisko uruchomieniowe Node.js:

  1. Upewnij się, że Twój projekt jest objęty planem cenowym Blaze .
  2. Upewnij się, że używasz Firebase CLI w wersji 11.18.0 lub nowszej.
  3. Zmień wartość engines w pliku package.json , który został utworzony w twoim katalogu functions/ podczas inicjalizacji. Na przykład, jeśli aktualizujesz z wersji 16 do wersji 18, wpis powinien wyglądać tak: "engines": {"node": "18"}
  4. Opcjonalnie przetestuj zmiany za pomocą pakietu Firebase Local Emulator Suite .
  5. Wdróż ponownie wszystkie funkcje.

Kontroluj zachowanie skalowania

Domyślnie Cloud Functions for Firebase skaluje liczbę uruchomionych instancji na podstawie liczby przychodzących żądań, potencjalnie zmniejszając liczbę instancji do zera w okresach mniejszego ruchu. Jeśli jednak Twoja aplikacja wymaga mniejszych opóźnień i chcesz ograniczyć liczbę zimnych uruchomień, możesz zmienić to domyślne zachowanie, określając minimalną liczbę instancji kontenera, które mają być utrzymywane w cieple i gotowe do obsługi żądań.

Podobnie możesz ustawić maksymalną liczbę, aby ograniczyć skalowanie instancji w odpowiedzi na przychodzące żądania. Użyj tego ustawienia, aby kontrolować koszty lub ograniczyć liczbę połączeń z usługą wspierającą, taką jak baza danych.

Zmniejsz liczbę zimnych startów

Aby ustawić minimalną liczbę wystąpień funkcji w kodzie źródłowym, użyj metody runWith . Ta metoda akceptuje obiekt JSON zgodny z interfejsem RuntimeOptions , który definiuje wartość dla minInstances . Na przykład ta funkcja ustawia co najmniej 5 instancji do utrzymywania ciepła:

exports.getAutocompleteResponse = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      minInstances: 5,
    })
    .https.onCall((data, context) => {
      // Autocomplete a user's search term
    });
index.js

Oto kilka rzeczy, które należy wziąć pod uwagę podczas ustawiania wartości dla minInstances :

  • Jeśli Cloud Functions for Firebase przeskaluje Twoją aplikację powyżej ustawienia minInstances , każda instancja powyżej tego progu będzie miała zimny start.
  • Zimne uruchamianie ma najpoważniejszy wpływ na aplikacje o dużym ruchu. Jeśli Twoja aplikacja ma skokowy ruch i ustawisz wartość minInstances na tyle wysoką, że przy każdym wzroście ruchu zmniejszy się zimny start, zobaczysz znacznie zmniejszone opóźnienie. W przypadku aplikacji ze stałym ruchem zimne uruchamianie prawdopodobnie nie wpłynie znacząco na wydajność.

  • Ustawienie minimalnych wystąpień może mieć sens w środowiskach produkcyjnych, ale zazwyczaj należy ich unikać w środowiskach testowych. Aby skalować do zera w projekcie testowym, ale nadal ograniczać zimne starty w projekcie produkcyjnym, możesz ustawić minInstances na podstawie zmiennej środowiskowej FIREBASE_CONFIG :

    // Get Firebase project id from `FIREBASE_CONFIG` environment variable
const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId;

exports.renderProfilePage = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      // in production only. Default to 0 for test projects.
      minInstances: envProjectId === "my-production-project" ? 5 : 0,
    })
    .https.onRequest((req, res) => {
      // render some html
    });
    index.js

Ogranicz maksymalną liczbę wystąpień funkcji

Aby ustawić maksymalną liczbę instancji w kodzie źródłowym funkcji, użyj metody runWith . Ta metoda akceptuje obiekt JSON zgodny z interfejsem RuntimeOptions , który definiuje wartości dla maxInstances . Na przykład ta funkcja ustawia limit 100 instancji, aby nie przeciążyć hipotetycznej starszej bazy danych:

exports.mirrorOrdersToLegacyDatabase = functions
    .runWith({
      // Legacy database only supports 100 simultaneous connections
      maxInstances: 100,
    })
    .firestore.document("orders/{orderId}")
    .onWrite((change, context) => {
      // Connect to legacy database
    });
index.js

Jeśli funkcja HTTP zostanie przeskalowana do limitu maxInstances , nowe żądania są umieszczane w kolejce przez 30 sekund, a następnie odrzucane z kodem odpowiedzi 429 Too Many Requests , jeśli do tego czasu żadne wystąpienie nie jest dostępne.

Aby dowiedzieć się więcej o najlepszych praktykach korzystania z ustawień maksymalnej liczby wystąpień, zapoznaj się z tymi najlepszymi praktykami dotyczącymi korzystania maxInstances .

Ustaw limit czasu i alokację pamięci

W niektórych przypadkach twoje funkcje mogą mieć specjalne wymagania dotyczące długiego limitu czasu lub dużej alokacji pamięci. Możesz ustawić te wartości w Google Cloud Console lub w kodzie źródłowym funkcji (tylko Firebase).

Aby ustawić alokację pamięci i limit czasu w kodzie źródłowym funkcji, użyj parametru runWith wprowadzonego w Firebase SDK for Cloud Functions 2.0.0. Ta opcja środowiska wykonawczego akceptuje obiekt JSON zgodny z interfejsem RuntimeOptions , który definiuje wartości timeoutSeconds i memory . Na przykład ta funkcja przechowywania wykorzystuje 1 GB pamięci i przekracza limit czasu po 300 sekundach:

exports.convertLargeFile = functions
    .runWith({
      // Ensure the function has enough memory and time
      // to process large files
      timeoutSeconds: 300,
      memory: "1GB",
    })
    .storage.object()
    .onFinalize((object) => {
      // Do some complicated things that take a lot of memory and time
    });
index.js

Maksymalna wartość timeoutSeconds to 540 lub 9 minut. Ilość pamięci przydzielonej funkcji odpowiada procesorowi przydzielonemu dla funkcji, jak wyszczególniono na tej liście prawidłowych wartości memory :

  • 128MB — 200 MHz
  • 256MB — 400 MHz
  • 512MB — 800 MHz
  • 1GB — 1,4 GHz
  • 2GB — 2,4 GHz
  • 4GB — 4,8 GHz
  • 8GB — 4,8 GHz

Aby ustawić alokację pamięci i limit czasu w Google Cloud Console:

  1. W Google Google Cloud Console wybierz Cloud Functions z lewego menu.
  2. Wybierz funkcję, klikając jej nazwę na liście funkcji.
  3. Kliknij ikonę Edytuj w górnym menu.
  4. Wybierz alokację pamięci z menu rozwijanego oznaczonego Alokacja pamięci .
  5. Kliknij Więcej , aby wyświetlić opcje zaawansowane, i wprowadź liczbę sekund w polu tekstowym Limit czasu .
  6. Kliknij Zapisz , aby zaktualizować funkcję.