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żanie funkcji

Aby wdrożyć funkcje, uruchom to polecenie interfejsu wiersza poleceń Firebase:

firebase deploy --only functions

Domyślnie interfejs wiersza poleceń Firebase wdraża wszystkie funkcje wewnątrz w tym samym czasie. Jeśli Twój projekt zawiera więcej niż 5 funkcji, zalecamy użycie flagi --only z konkretnymi nazwami funkcji wdrażanie tylko tych funkcji, edytowany przez Ciebie. Wdrażanie określonych funkcji przyspieszy to proces wdrażania i pozwala uniknąć problemów limity wdrożenia. Przykład:

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

W przypadku wdrażania dużej liczby funkcji może zostać przekroczona standardowy limit i otrzymywanie komunikatów o błędach HTTP 429 lub 500. Do rozwiązania W tym celu wdróż funkcje w grupach liczących nie więcej niż 10 osób.

Pełną listę dostępnych funkcji znajdziesz w dokumentacji interfejsu wiersza poleceń Firebase. poleceń.

Domyślnie interfejs wiersza poleceń Firebase szuka w folderze functions/ kodu źródłowego. Jeśli wolisz, możesz uporządkować funkcje w bazach kodu lub w wielu zbiorach plików.

Usuwanie funkcji

Wcześniej wdrożone funkcje możesz usunąć na 2 sposoby:

• jawnie w interfejsie wiersza poleceń Firebase z użyciem functions:delete
• w kontekście w konsoli Google Cloud.
• domyślnie, usuwając funkcję ze źródła przed wdrożeniem.

Wszystkie operacje usuwania pojawi się prośba o potwierdzenie przed usunięciem funkcji z środowiska produkcyjnego.

Bezpośrednie usuwanie funkcji w interfejsie wiersza poleceń Firebase obsługuje wiele argumentów , a także funkcje grup i pozwala określić funkcję działającą w konkretnym regionie. Możesz też zignorować prośbę 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

W przypadku niejawnego usuwania funkcji firebase deploy analizuje źródło i usuwa z produkcji wszystkie funkcje, które zostały usunięte z pliku.

Zmodyfikuj nazwę funkcji, region lub aktywator

Jeśli zmieniasz nazwy lub regiony albo aktywatory funkcji, które są obsługi ruchu produkcyjnego, wykonaj czynności opisane w tej sekcji, aby uniknąć utraty zdarzeń podczas modyfikacji. Zanim wykonasz te czynności, upewnij się, że Twoje funkcja jest idempotent, ponieważ zarówno nowa, jak i stara wersja Twojej funkcji będą uruchamiane w w tym samym czasie zmiany.

Zmienianie nazwy funkcji

Aby zmienić nazwę funkcji, utwórz w źródle nową wersję funkcji ze zmienioną nazwą a potem uruchomić 2 osobne polecenia wdrożeniowe. Pierwsze polecenie wdraża z nowo nazwaną funkcją, a drugie polecenie usuwa wcześniej wdrożoną funkcję wersji. Jeśli na przykład masz webhooka aktywowanego przez HTTP, zmień nazwę, wprowadź zmiany w kodzie w następujący sposób:

// before
const {onRequest}  = require('firebase-functions/v2/https');

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

// after
const {onRequest}  = require('firebase-functions/v2/https');

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

# before
from firebase_functions import https_fn

@https_fn.on_request()
def webhook(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

# after
from firebase_functions import https_fn

@https_fn.on_request()
def webhook_new(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

Następnie uruchom te polecenia, aby wdrożyć nową funkcję:

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

# Wait until deployment is done; now both functions are running

# Delete webhook
firebase functions:delete webhook

Zmień region lub regiony funkcji

Jeśli zmieniasz określone regiony dla obsługującej ruch produkcyjny, możesz zapobiec utracie zdarzeń przez wykonując te kroki w kolejności:

1. Zmień nazwę funkcji oraz odpowiednio zmień jej region lub regiony.
2. Wdróż funkcję ze zmienioną nazwą, co spowoduje tymczasowe uruchamianie tego samego kodu w obu zestawach regionów.
3. Usuń poprzednią funkcję.

Jeśli na przykład masz funkcję wyzwalaną przez Cloud Firestore który obecnie znajduje się w domyślny region funkcji us-central1 i chcesz go przenieść do asia-northeast1, musisz najpierw zmodyfikować kod źródłowy, aby zmienić nazwę i zmieniać region.

// before
exports.firestoreTrigger = onDocumentCreated(
  "my-collection/{docId}",
  (event) => {},
);

// after
exports.firestoreTriggerAsia = onDocumentCreated(
  {
    document: "my-collection/{docId}",
    region: "asia-northeast1",
  },
  (event) => {},
);

# Before
@firestore_fn.on_document_created("my-collection/{docId}")
def firestore_trigger(event):
    pass

# After
@firestore_fn.on_document_created("my-collection/{docId}",
                                  region="asia-northeast1")
def firestore_trigger_asia(event):
    pass

Następnie wdróż konfigurację, uruchamiając polecenie:

firebase deploy --only functions:firestoreTriggerAsia

Uruchomione są teraz dwie identyczne funkcje: firestoreTrigger działa w us-central1 i firestoreTriggerAsia są uruchomione w: asia-northeast1.

Następnie usuń firestoreTrigger:

firebase functions:delete firestoreTrigger

Teraz istnieje tylko jedna funkcja – firestoreTriggerAsia, która działa w asia-northeast1

Zmień typ aktywatora funkcji

W miarę rozwijania przez Ciebie wdrożenia Cloud Functions dla Firebase możesz mieć musisz zmienić typ aktywatora funkcji z różnych powodów. Przykład: możesz zmienić jeden typ Bazy danych czasu rzeczywistego Firebase lub Zdarzenie Cloud Firestore na inny typ.

Nie można zmienić typu zdarzenia funkcji przez zmianę parametru z kodem źródłowym i uruchomionym programem firebase deploy. Aby uniknąć błędów: zmień typ aktywatora funkcji, wykonując tę procedurę:

1. Zmodyfikuj kod źródłowy, aby zawierał nową funkcję z wybranym typem aktywatora.
2. wdrożyć funkcję, co spowoduje tymczasowe uruchomienie zarówno starej, jak i nowej funkcji;
3. Użyj interfejsu wiersza poleceń Firebase, aby usunąć starą funkcję z wersji produkcyjnej.

Jeśli na przykład istnieje funkcja, która została aktywowana, gdy obiekt został usunięte, ale potem włączono obsługa wersji obiektu Zamiast tego chcesz zasubskrybować wydarzenie archiwalne, najpierw zmień nazwę i ustaw ją na nowy typ aktywatora.

// before
const {onObjectDeleted} = require("firebase-functions/v2/storage");

exports.objectDeleted = onObjectDeleted((event) => {
    // ...
});

// after
const {onObjectArchived} = require("firebase-functions/v2/storage");

exports.objectArchived = onObjectArchived((event) => {
    // ...
});

# before
from firebase_functions import storage_fn

@storage_fn.on_object_deleted()
def object_deleted(event):
  # ...

# after 
from firebase_functions import storage_fn

@storage_fn.on_object_archived()
def object_archived(event):
  # ...

Następnie uruchom te polecenia, aby najpierw utworzyć nową funkcję, a potem usunąć starą:

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

# Wait until deployment is done; now both objectDeleted and objectArchived are running

# Delete objectDeleted
firebase functions:delete objectDeleted

Ustaw opcje środowiska wykonawczego

Cloud Functions dla Firebase pozwala wybrać opcje środowiska wykonawczego, takie jak Node.js wersję środowiska wykonawczego, limit czasu dla poszczególnych funkcji, przydział pamięci oraz minimalną/maksymalną wartość w instancjach funkcji.

Zalecamy ustawienie tych opcji (oprócz wersji Node.js) na do obiektu konfiguracji w kodzie funkcji. Ten RuntimeOptions jest źródłem danych dla opcji środowiska wykonawczego funkcji i będzie opcji zastępowania ustawionych za pomocą dowolnej innej metody (np. w konsoli Google Cloud) lub interfejsu wiersza poleceń gcloud).

Jeśli proces programowania obejmuje ręczne ustawienie opcji środowiska wykonawczego za pomocą w konsoli Google Cloud lub w gcloud CLI, ale nie chcesz, by te wartości były zastąpione przy każdym wdrożeniu, ustaw opcję preserveExternalChanges na true. Gdy ta opcja ma wartość true, Firebase łączy opcje środowiska wykonawczego ustawione w z ustawieniami obecnie wdrożonej wersji Twojej funkcji o następującym priorytecie:

1. Opcja jest ustawiona w kodzie funkcji: zastąp zmiany zewnętrzne.
2. Opcja ma wartość 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 obecnie wdrożonej funkcji. Użyj opcji określonej we wdrożonej funkcji.

Nie zalecamy używania opcji preserveExternalChanges: true. dla większości scenariuszy, ponieważ kod nie będzie już pełnym źródłem wiarygodnych opcji środowiska wykonawczego funkcji. Jeżeli już go używasz, sprawdź konsolę Google Cloud lub użyj gcloud. Interfejs wiersza poleceń wyświetlający pełną konfigurację funkcji.

Ustaw wersję Node.js

Pakiet SDK Firebase dla Cloud Functions umożliwia wybór środowiska wykonawczego Node.js. Możesz uruchomić wszystkie funkcje projektu wyłącznie w środowisku wykonawczym środowiska odpowiadającego jednej z tych obsługiwanych wersji Node.js:

• Node.js 22 (wersja przedpremierowa)
• Node.js 20
• Node.js 18

Node.js w wersjach 14 i 16 są wycofane i zostaną wycofane na początku 2025 r. Wdrożenie tych wycofanych wersji jest wyłączona.

Aby ustawić wersję Node.js:

Wersję możesz określić w polu engines w narzędziu package.json. utworzony w katalogu functions/ podczas inicjowania. Aby na przykład użyć tylko atrybutu wersji 18, edytuj ten wiersz w pliku package.json:

  "engines": {"node": "20"}

Jeśli korzystasz z menedżera pakietów Yarn lub masz inne wymagania dotyczące engines, możesz określić środowisko wykonawcze pakietu SDK Firebase dla Cloud Functions firebase.json w zamian:

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs20
    }
  }

Interfejs wiersza poleceń używa wartości określonej w zasadzie firebase.json jako dowolnej wartości lub ustawionym osobno w package.json.

Uaktualnij środowisko wykonawcze Node.js

Aby uaktualnić środowisko wykonawcze Node.js:

1. Upewnij się, że projekt jest Abonament Blaze
2. Upewnij się, że używasz interfejsu wiersza poleceń Firebase w wersji 11.18.0 lub nowszej.
3. Zmień wartość engines w pliku package.json, który został utworzony w katalogu functions/ podczas inicjowania. Jeśli na przykład uaktualniasz z wersji 18 do wersji 20, wpis powinien wyglądać tak: "engines": {"node": "20"}
4. Opcjonalnie przetestuj zmiany za pomocą Pakiet emulatorów lokalnych Firebase.
5. Wdróż ponownie wszystkie funkcje.

Ustaw wersję Pythona

Pakiet SDK Firebase dla Cloud Functions w wersji 12.0.0 lub nowszej umożliwia wybór Pythona w środowisku wykonawczym. Ustaw wersję środowiska wykonawczego w firebase.json w następujący sposób:

  {
    "functions": {
      "runtime": "python310" // or python311
    }
  }

Sterowanie skalowaniem

Domyślnie Cloud Functions dla Firebase skaluje liczbę uruchomionych instancji na podstawie liczby żądań przychodzących, potencjalnie skalować w dół do zera w czasach mniejszego ruchu. Jeśli jednak aplikacja wymaga ograniczenia i chcesz ograniczyć liczbę uruchomień „na zimno”, możesz zmienić to ustawienie. zachowanie domyślne, określając minimalną liczbę instancji kontenera, które mają i gotowe do obsługi żądań.

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

Używanie tych ustawień razem z ustawieniem równoczesności poszczególnych instancji (nowość w 2 generacji), możesz kontrolować i dostosowywać zachowanie skalowania w przypadku funkcji. charakter aplikacji i funkcji decyduje o tym, które ustawienia opłacalny i zapewni najlepsze wyniki.

W przypadku niektórych aplikacji o małym natężeniu ruchu opcja z mniejszą wartością procesora bez trybu wielu współbieżnych będzie optymalna. W innych przypadkach, gdy uruchomienia „na zimno” są poważnym problemem, ustawienie wysokiego poziomu równoczesność i minimalna liczba instancji oznacza, że zbiór instancji jest zawsze zachowywany do obsługi dużych skoków natężenia ruchu.

W przypadku mniejszych aplikacji, które generują bardzo mały ruch, ustawienie niskiej wartości maksymalnej instancji o wysokiej równoczesności oznacza, że aplikacja może obsłużyć porcje ruchu bez ponoszenia nadmiernych kosztów. Należy jednak pamiętać, że po ustawieniu maksymalnej liczba instancji jest ustawiona zbyt nisko, po osiągnięciu limitu żądania mogą być odrzucane.

Zezwalaj na żądania równoczesne

W Cloud Functions dla Firebase (1 generacji) każda instancja może obsłużyć jedno żądanie naraz, Zachowanie skalowania zostało ustawione tylko z ustawieniami minimalnej i maksymalnej liczby instancji. Oprócz sterowania liczbą instancji w Cloud Functions dla Firebase (2 generacji) może kontrolować liczbę żądań, które każda instancja może obsługiwać jednocześnie opcję concurrency. Domyślna wartość równoczesności to 80, ale możesz ustaw go na dowolną liczbę całkowitą od 1 do 1000.

Funkcje z wyższymi ustawieniami równoczesności mogą wychwytywać skoki natężenia ruchu bez uruchamianie „na zimno”, ponieważ każda instancja ma prawdopodobnie swój potencjał. Jeśli instancja jest skonfigurowano do obsługi do 50 równoczesnych żądań, ale obecnie obsługuje tylko 25, może obsłużyć skok liczby 25 dodatkowych żądań bez konieczności do uruchomienia „na zimno”. Natomiast przy ustawieniu równoczesności na poziomie 1 oznacza to, nagłe zwiększenie liczby żądań może doprowadzić do 25 uruchomień „na zimno”.

Ten uproszczony scenariusz pokazuje potencjalny wzrost efektywności i równoczesności. W rzeczywistości skalowanie działania w celu optymalizacji wydajności i zmniejszenia uruchomienia „na zimno” ze współbieżnością są bardziej skomplikowane. Równoczesność w Usługa Cloud Functions dla Firebase 2 generacji korzysta z Cloud Run i Reguły Cloud Run Autoskalowanie instancji kontenera.

eksperymentowanie z wyższymi ustawieniami równoczesności w Cloud Functions dla Firebase; (2 generacji), pamiętaj o tych kwestiach:

• Wyższe ustawienia równoczesności mogą wymagać większej liczby procesorów i pamięci RAM w celu uzyskania optymalnego do osiągnięcia praktycznego limitu. Funkcja, która wykonuje ciężkie zadanie przetwarzania obrazów lub wideo może na przykład nie mieć odpowiednich zasobów, 1000 żądań równoczesnych, nawet przy zmaksymalizowanych ustawieniach procesora i RAM.
• Ponieważ Cloud Functions dla Firebase (2 generacji) opiera się na Cloud Run, zapoznaj się też ze wskazówkami Google Cloud dotyczącymi optymalizacji równoczesności.
• Pamiętaj, aby dokładnie przetestować wiele równoczesności w środowisku testowym przed przejście na tryb wielu równoczesności w środowisku produkcyjnym.

Utrzymuj minimalną liczbę instancji w gotowości

Możesz ustawić minimalną liczbę instancji dla funkcji w kodzie źródłowym. Na przykład ta funkcja ustawia co najmniej 5 instancji aby było ciepło:

const { onCall } = require("firebase-functions/v2/https");

exports.getAutocompleteResponse = onCall(
  {
    // Keep 5 instances warm for this latency-critical function
    minInstances: 5,
  },
  (event) => {
    // Autocomplete user’s search term
  }
);

@https_fn.on_call(min_instances=5)
def get_autocomplete_response(event: https_fn.CallableRequest) -> https_fn.Response:

Oto kilka kwestii, które należy wziąć pod uwagę podczas ustawiania minimalnej wartości instancji:

• Jeśli Cloud Functions dla Firebase skaluje aplikację powyżej ustawienia, w każdej instancji powyżej tego progu nastąpi uruchomienie „na zimno”.
• Zimne uruchomienia mają najpoważniejszy wpływ na aplikacje o dużym natężeniu ruchu. Jeśli generuje duży ruch w aplikacji, a wartość uruchomienia „na zimno” przy każdym wzroście ruchu zmniejszają się, zauważysz znaczne i skrócenie czasu oczekiwania. W przypadku aplikacji o ciągłym ruchu uruchomienie „na zimno” jest mało prawdopodobne co w dużym stopniu wpływa na wydajność.

• Ustawienie minimalnej liczby instancji może być przydatne w środowiskach produkcyjnych, ale należy unikać w środowiskach testowych. Aby skalować do zera w i jednocześnie ograniczyć uruchomienia „na zimno” w projekcie produkcyjnym, może ustawić minimalną wartość instancji w konfiguracji z parametrami:

  Node.js

  const functions = require('firebase-functions');
  const { defineInt, defineString } = require('firebase-functions/params');
  
  // Define some parameters
  const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
  const welcomeMessage = defineString('WELCOME_MESSAGE');
  
  // To use configured parameters inside the config for a function, provide them 
  // directly. To use them at runtime, call .value() on them.
  export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
    (req, res) => {
      res.send(`${welcomeMessage.value()}! I am a function.`);
    }
  );
  

  Python

  MIN_INSTANCES = params.IntParam("HELLO_WORLD_MININSTANCES")
  WELCOME_MESSAGE = params.StringParam("WELCOME_MESSAGE")
  
  @https_fn.on_request(min_instances=MIN_INSTANCES.value())
  def get_autocomplete_response(event: https_fn.Request) -> https_fn.Response:
      return https_fn.Response(f"{WELCOME_MESSAGE.value()} I'm a function.")
  

Ogranicz maksymalną liczbę instancji funkcji

Możesz ustawić wartość maksymalnej liczby instancji w kodzie źródłowym funkcji. Na przykład ta funkcja ustawia limit 100 instancji, aby nie przesadzić z hipotetyczną starszą bazą danych:

const { onMessagePublished } = require("firebase-functions/v2/pubsub");

exports.mirrorevents = onMessagePublished(
  { topic: "topic-name", maxInstances: 100 },
  (event) => {
    // Connect to legacy database
  }
);

@pubsub_fn.on_message_published(topic="topic-name", max_instances=100)
def mirrorevents(event: pubsub_fn.CloudEvent):
#  Connect to legacy database

Jeśli funkcja HTTP zostanie przeskalowana do maksymalnej liczby instancji, nowe żądania zostaną w kolejce przez 30 sekund, a następnie odrzucona z kodem odpowiedzi 429 Too Many Requests, jeśli do tego czasu nie będzie dostępna żadna instancja.

Aby dowiedzieć się więcej o sprawdzonych metodach korzystania z ustawienia maksymalnej liczby instancji, zapoznaj się z artykułem wyrzuć te sprawdzonych metodach ustawiania maksymalnej liczby instancji.

Ustaw limit czasu i przydział pamięci

W niektórych przypadkach funkcje mogą mieć specjalne wymagania dotyczące długiego czasu oczekiwania lub znaczną ilość pamięci. Te wartości możesz ustawić w konsoli Google Cloud lub w kodzie źródłowym funkcji (tylko w Firebase).

Aby ustawić przydział pamięci i czas oczekiwania w kodzie źródłowym funkcji, użyj funkcji globalne opcje pamięci i limitu czasu (w sekundach) aby dostosować maszynę wirtualną, na której są uruchomione funkcje. Na przykład ta funkcja w Cloud Storage wykorzystuje 1 GiB pamięci i czasów po 300 sekundach:

exports.convertLargeFile = onObjectFinalized({
  timeoutSeconds: 300,
  memory: "1GiB",
}, (event) => {
  // Do some complicated things that take a lot of memory and time
});

@storage_fn.on_object_finalized(timeout_sec=300, memory=options.MemoryOption.GB_1)
def convert_large_file(event: storage_fn.CloudEvent):
# Do some complicated things that take a lot of memory and time.

Maksymalny czas oczekiwania w sekundach to 540, czyli 9 minut.

Aby ustawić przydział pamięci i limit czasu w konsoli Google Cloud:

1. W konsoli Google Cloud wybierz Cloud Functions dla Firebase menu po lewej stronie.
2. Wybierz funkcję, klikając jej nazwę na liście funkcji.
3. W menu u góry kliknij ikonę Edytuj.
4. Wybierz przydział pamięci z menu oznaczonego etykietą Pamięć przydzielona.
5. Kliknij Więcej, aby wyświetlić opcje zaawansowane, a następnie wpisz liczbę w polu tekstowym Limit czasu.
6. Kliknij Zapisz, aby zaktualizować funkcję.

Zastąp domyślne ustawienia procesora

Przydzielono do 2 GB pamięci na każdą funkcję w Cloud Functions dla Firebase (2 generacji) domyślnie jest ustawiany na 1 procesor, a następnie zwiększa się do 2 procesorów w przypadku 4 i 8 GB. Pamiętaj, że znacznie różni się to od domyślnego zachowania 1 generacji w sposób, skutkuje nieco wyższymi kosztami korzystania z funkcji o małej ilości pamięci, ta tabela:

Jeśli wolisz działanie 1 generacji w przypadku funkcji 2 generacji, ustaw wartości domyślne 1 generacji jako opcję globalną:

// Turn off Firebase defaults
setGlobalOptions({ cpu: 'gcf_gen1' });

# Use 1st gen behavior
set_global_options(cpu="gcf_gen1")

W przypadku funkcji wymagających dużej mocy procesora 2 generacja zapewnia elastyczność konfigurowania dodatkowych CPU. Możesz zwiększyć liczbę procesorów dla poszczególnych funkcji w następujący sposób:

// Boost CPU in a function:
export const analyzeImage = onObjectFinalized({ cpu: 2 }, (event) => {
  // computer vision goes here
});

# Boost CPU in a function:
@storage_fn.on_object_finalized(cpu=2)
def analyze_image(event: storage_fn.CloudEvent):
# computer vision goes here