Zarządzaj funkcjami


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

Wdrażaj funkcje

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

firebase deploy --only functions

Domyślnie interfejs CLI Firebase wdraża wszystkie funkcje w źródle w tym samym czasie. Jeśli 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ąć wyczerpania limitów wdrożenia. Na przykład:

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

Podczas wdrażania dużej liczby funkcji możesz przekroczyć standardowy limit i otrzymać komunikaty o błędach HTTP 429 lub 500. Aby rozwiązać ten problem, wdrażaj funkcje w grupach po 10 lub mniej osób.

Pełną listę dostępnych poleceń znajdziesz w dokumentacji Firebase CLI .

Domyślnie interfejs CLI Firebase 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 interfejsie CLI Firebase za pomocą functions:delete
  • bezpośrednio w Google Cloud Console .
  • pośrednio poprzez usunięcie funkcji ze źródła przed wdrożeniem.

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

Jawne usuwanie funkcji w interfejsie CLI Firebase obsługuje wiele argumentów, a także grup funkcji i pozwala określić funkcję działającą 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 usunięciu 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

Jeśli zmieniasz nazwę lub zmieniasz regiony lub wyzwalacz funkcji obsługujących ruch produkcyjny, wykonaj kroki opisane w tej sekcji, aby uniknąć utraty zdarzeń podczas modyfikacji. Zanim wykonasz te kroki, najpierw upewnij się, że Twoja funkcja jest idempotentna , ponieważ podczas zmiany zarówno nowa, jak i stara wersja Twojej funkcji będą działać w tym samym czasie.

Zmień nazwę funkcji

Aby zmienić nazwę funkcji, utwórz nową wersję funkcji o zmienionej nazwie w źródle, a następnie uruchom dwie oddzielne komendy wdrażania. Pierwsze polecenie wdraża nowo nazwaną funkcję, a drugie polecenie usuwa poprzednio 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 według potrzeb.
  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ą migrować 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 i 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ę rozwijania wdrożenia Cloud Functions dla Firebase z różnych powodów może zaistnieć potrzeba zmiany typu wyzwalacza funkcji. 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 poniższą procedurę:

  1. Zmodyfikuj kod źródłowy, aby uwzględnić nową funkcję z żądanym typem wyzwalacza.
  2. Wdróż funkcję, co spowoduje tymczasowe uruchomienie zarówno starych, jak i nowych funkcji.
  3. Jawnie usuń starą funkcję z produkcji za pomocą interfejsu wiersza polecenia Firebase.

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ę, a następnie usunąć starą:

# 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 wykonawczego

Cloud Functions dla Firebase pozwala wybrać opcje środowiska wykonawczego, takie jak wersja środowiska wykonawczego Node.js i limit czasu dla poszczególnych funkcji, alokacja pamięci oraz minimalna/maksymalna liczba wystąpień funkcji.

Zgodnie z najlepszą praktyką opcje te (z wyjątkiem wersji Node.js) powinny być ustawione w obiekcie konfiguracyjnym wewnątrz kodu funkcji. Ten obiekt RuntimeOptions jest źródłem prawdy o opcjach wykonawczych Twojej funkcji i zastąpi opcje ustawione dowolną inną metodą (na przykład za pomocą konsoli Google Cloud lub interfejsu wiersza polecenia gcloud).

Jeśli przepływ prac programistycznych 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 łączy opcje wykonawcze ustawione w 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ępuje 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ż kod nie będzie już pełnym źródłem prawdy dla opcji środowiska uruchomieniowego funkcji. Jeśli z niej korzystasz, sprawdź konsolę Google Cloud lub użyj interfejsu wiersza polecenia gcloud, aby wyświetlić pełną konfigurację funkcji.

Ustaw wersję Node.js

Zestaw SDK Firebase dla Cloud Functions umożliwia wybór środowiska wykonawczego Node.js. Możesz zdecydować się na 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:

Wersję możesz ustawić w polu engines w pliku package.json , który został utworzony w katalogu functions/ podczas inicjalizacji. Na przykład, aby używać tylko wersji 18, edytuj tę linię w package.json :

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

Jeśli używasz menedżera pakietów Yarn lub masz inne specyficzne wymagania dotyczące pola engines , możesz zamiast tego ustawić środowisko wykonawcze pakietu SDK Firebase dla Cloud Functions w firebase.json :

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

Interfejs wiersza polecenia używa wartości ustawionej w firebase.json zamiast dowolnej wartości lub zakresu ustawionego osobno w package.json .

Uaktualnij środowisko wykonawcze Node.js

Aby zaktualizować środowisko wykonawcze 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 katalogu functions/ podczas inicjalizacji. Na przykład, jeśli aktualizujesz wersję 16 do wersji 18, wpis powinien wyglądać następująco: "engines": {"node": "18"}
  4. Opcjonalnie przetestuj zmiany, korzystając z pakietu Firebase Local Emulator Suite .
  5. Wdróż ponownie wszystkie funkcje.

Kontroluj zachowanie skalowania

Domyślnie Cloud Functions dla Firebase skaluje liczbę uruchomionych instancji na podstawie liczby przychodzących żądań, potencjalnie zmniejszając liczbę instancji do zera w okresach zmniejszonego ruchu. Jeśli jednak Twoja aplikacja wymaga zmniejszonych opóźnień i chcesz ograniczyć liczbę zimnych startów, możesz zmienić to domyślne zachowanie, określając minimalną liczbę instancji kontenerów, 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ą podstawową, taką jak baza danych.

Zmniejsz liczbę zimnych startów

Aby ustawić minimalną liczbę wystąpień funkcji w kodzie źródłowym, należy użyć metody runWith . Ta metoda akceptuje obiekt JSON zgodny z interfejsem RuntimeOptions , który definiuje wartość minInstances . Na przykład ta funkcja ustawia co najmniej 5 instancji 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ę przy ustawianiu wartości minInstances :

  • Jeśli Cloud Functions dla Firebase przeskaluje aplikację powyżej ustawienia minInstances , nastąpi zimny start dla każdej instancji powyżej tego progu.
  • Zimny ​​​​start ma najpoważniejszy wpływ na aplikacje o dużym ruchu. Jeśli w Twojej aplikacji występuje gwałtowny ruch i ustawisz wartość minInstances na tyle wysoką, że zimne uruchamianie będzie zmniejszane przy każdym wzroście ruchu, zauważysz znacznie zmniejszone opóźnienia. W przypadku aplikacji o stałym ruchu zimne uruchamianie prawdopodobnie nie wpłynie znacząco na wydajność.

  • Ustawienie minimalnej liczby instancji może mieć sens w środowiskach produkcyjnych, ale zwykle należy go unikać w środowiskach testowych. Aby skalować do zera w projekcie testowym, ale nadal ograniczać zimne starty w projekcie produkcyjnym, możesz ustawić minInstances w oparciu o zmienną środowiskową 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ę wystąpień 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ążać 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 będą umieszczane w kolejce przez 30 sekund, a następnie odrzucane z kodem odpowiedzi 429 Too Many Requests , jeśli do tego czasu żadna instancja nie będzie dostępna.

Aby dowiedzieć się więcej na temat najlepszych praktyk dotyczących korzystania z ustawień maksymalnej liczby instancji, zapoznaj się z tymi najlepszymi praktykami dotyczącymi korzystania maxInstances .

Ustaw limit czasu i alokację pamięci

W niektórych przypadkach 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 pakiecie Firebase SDK dla 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 kończy się 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 , czyli 9 minut. Ilość pamięci przyznanej funkcji odpowiada procesorowi przydzielonemu dla tej funkcji, jak szczegółowo opisano na poniższej 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 o nazwie Przydzielona pamięć .
  5. Kliknij przycisk Więcej , aby wyświetlić opcje zaawansowane, i wprowadź liczbę sekund w polu tekstowym Limit czasu .
  6. Kliknij Zapisz , aby zaktualizować funkcję.