Zarządzaj funkcjami

Funkcje możesz wdrażać, usuwać i modyfikować za pomocą poleceń interfejsu wiersza poleceń Firebase 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 źródła jednocześnie. Jeśli Twój projekt zawiera więcej niż 5 funkcji, zalecamy użycie flagi --only z określonymi nazwami funkcji do wdrożenia tylko tych funkcji, które zostały przez Ciebie edytowane. Wdrożenie określonych funkcji w ten sposób przyspiesza proces wdrażania i pozwala uniknąć przekroczenia limitów wdrożenia. Przykład:

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

W przypadku wdrażania dużej liczby funkcji może dojść do przekroczenia limitu standardowego i pojawienia się komunikatów o błędach HTTP 429 lub 500. Aby rozwiązać ten problem, wdróż funkcje w grupach liczących maksymalnie 10 osób.

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

Domyślnie interfejs wiersza poleceń Firebase szuka kodu źródłowego w folderze functions/. Jeśli wolisz, możesz porzą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 wymagają potwierdzenia przed usunięciem funkcji z środowiska produkcyjnego.

Bezpośrednie usuwanie funkcji w interfejsie wiersza poleceń Firebase obsługuje wiele argumentów, jak również grupy funkcji. Umożliwia ono określenie funkcji uruchomionej 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 regionów lub aktywatorów funkcji, które obsługują ruch produkcyjny albo zmieniasz ich nazwy, wykonaj czynności opisane w tej sekcji, aby uniknąć utraty zdarzeń podczas modyfikacji. Zanim wykonasz te czynności, upewnij się, że Twoja funkcja jest idempotentna, ponieważ podczas zmiany zarówno nowa, jak i stara wersja funkcji będą uruchamiane w tym samym czasie.

Zmienianie nazwy funkcji

Aby zmienić nazwę funkcji, utwórz jej nową wersję ze zmienioną nazwą w źródle, a następnie uruchom 2 osobne polecenia wdrożeniowe. Pierwsze polecenie wdraża nową funkcję, a drugie usuwa wcześniej wdrożoną wersję. Jeśli na przykład masz webhooka aktywowanego przez HTTP, których nazwę chcesz zmienić, zmień jego kod w ten 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 funkcji, która obsługuje ruch produkcyjny, możesz zapobiec utracie zdarzeń, wykonując te czynności w następującej 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óra obecnie znajduje się 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
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

Obecnie są uruchomione 2 identyczne funkcje: funkcja firestoreTrigger jest uruchomiona w us-central1, a firestoreTriggerAsia działa w asia-northeast1.

Następnie usuń firestoreTrigger:

firebase functions:delete firestoreTrigger

Teraz istnieje tylko 1 funkcja firestoreTriggerAsia, która działa w zadaniu asia-northeast1.

Zmień typ aktywatora funkcji

W miarę opracowywania wdrożenia Cloud Functions dla Firebase może być konieczna zmiana typu aktywatora funkcji z różnych powodów. Możesz na przykład zmienić typ zdarzenia w Bazie danych czasu rzeczywistego Firebase lub Cloud Firestore na inny.

Nie można zmienić typu zdarzenia funkcji przez zmianę kodu źródłowego i uruchomienie polecenia 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 np. masz funkcję, która została aktywowana po usunięciu obiektu, a potem masz włączoną obsługę wersji obiektu i chcesz zamiast tego zasubskrybować zdarzenie archiwum, najpierw zmień nazwę funkcji i zmień jej typ 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 wersja środowiska wykonawczego Node.js, czas oczekiwania dla poszczególnych funkcji, przydział pamięci oraz minimalna i maksymalna liczba instancji funkcji.

Zalecaną metodą jest ustawienie tych opcji (z wyjątkiem wersji Node.js) w obiekcie konfiguracji w kodzie funkcji. Ten obiekt RuntimeOptions jest źródłem danych dotyczących opcji środowiska wykonawczego Twojej funkcji i zastępuje opcje ustawione za pomocą dowolnej innej metody (np. w konsoli Google Cloud lub gcloud CLI).

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

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.

W większości przypadków korzystanie z opcji preserveExternalChanges: true nie jest zalecane, ponieważ Twój kod nie będzie już pełnym źródłem wiarygodnych informacji w przypadku opcji środowiska wykonawczego dla Twoich funkcji. Jeśli już z niej korzystasz, sprawdź konsolę Google Cloud lub użyj gcloud CLI, aby wyświetlić pełną konfigurację funkcji.

Ustaw wersję Node.js

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

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

Wersje 14 i 16 Node.js zostały wycofane i na początku 2025 r. zostaną wycofane. Wdrażanie z tymi wycofanymi wersjami jest wyłączone.

Aby ustawić wersję Node.js:

Możesz ustawić wersję w polu engines w pliku package.json, który został utworzony w katalogu functions/ podczas inicjowania. Aby na przykład użyć tylko wersji 18, zmień ten wiersz w pliku package.json:

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

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

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

Interfejs wiersza poleceń używa wartości ustawionej w zasadzie firebase.json w pierwszej kolejności z dowolnej wartości lub zakresu ustawionych oddzielnie w zasadzie package.json.

Uaktualnij środowisko wykonawcze Node.js

Aby uaktualnić środowisko wykonawcze Node.js:

1. Sprawdź, czy Twój projekt jest objęty abonamentem 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 utworzonym w katalogu functions/ podczas inicjowania. Jeśli na przykład uaktualniasz wersję 18 do wersji 20, wpis powinien wyglądać tak: "engines": {"node": "20"}
4. Opcjonalnie przetestuj zmiany za pomocą Pakietu 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 środowiska wykonawczego Pythona. 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, co może zmniejszyć liczbę instancji do zera w okresach mniejszego ruchu. Jeśli jednak aplikacja wymaga mniejszego opóźnienia i chcesz ograniczyć liczbę uruchomień „na zimno”, możesz zmienić to domyślne działanie, określając minimalną liczbę instancji kontenera, które mają być utrzymywane w gotowości do obsługi żądań.

Podobnie możesz ustawić maksymalną liczbę, aby ograniczyć skalowanie instancji w odpowiedzi na żądania przychodzące. To ustawienie służy do kontrolowania kosztów lub ograniczania liczby połączeń z usługą bazową, taką jak baza danych.

Korzystając z tych ustawień w połączeniu z ustawieniem równoczesności dla poszczególnych instancji (nowość w 2 generacji), możesz kontrolować i dostrajać skalowanie dla funkcji. Charakter aplikacji i funkcji określa, które ustawienia są najbardziej ekonomiczne i zapewniają największą wydajność.

W przypadku niektórych aplikacji o małym natężeniu ruchu optymalna jest optymalizacja pod kątem mniejszej liczby procesorów bez obsługi wielu równoczesności. W innych przypadkach, w których uruchomienia „na zimno” są kluczowym problemem, ustawienie wysokiej równoczesności i minimalnej liczby instancji oznacza, że zbiór instancji jest zawsze utrzymywany w gotowości do obsługi dużych skoków natężenia ruchu.

W przypadku aplikacji na mniejszą skalę, które otrzymują bardzo mały ruch, ustawienie niskiej maksymalnej liczby instancji z wysoką równoczesnością oznacza, że aplikacja będzie w stanie obsłużyć porcje porcji ruchu bez generowania nadmiernych kosztów. Pamiętaj jednak, że jeśli maksymalna liczba instancji będzie ustawiona na zbyt niską, żądania mogą być odrzucane po osiągnięciu limitu.

Zezwalaj na żądania równoczesne

W Cloud Functions dla Firebase (1 generacji) każda instancja mogła obsłużyć 1 żądanie jednocześnie, więc zachowanie skalowania było ustawiane tylko z uwzględnieniem ustawień minimalnej i maksymalnej liczby instancji. Oprócz kontrolowania liczby instancji w Cloud Functions dla Firebase (2 generacji) możesz za pomocą opcji concurrency kontrolować liczbę żądań, które każda instancja może obsługiwać jednocześnie. Domyślna wartość równoczesności wynosi 80, ale możesz ustawić dowolną liczbę całkowitą z zakresu od 1 do 1000.

Funkcje o wyższych ustawieniach równoczesności mogą wychwytywać nagłe skoki natężenia ruchu bez uruchamiania „na zimno”, ponieważ każda instancja prawdopodobnie ma pewien margines. Jeśli instancja jest skonfigurowana do obsługi maksymalnie 50 żądań równoczesnych, ale obecnie obsługuje tylko 25 żądań, może obsłużyć nagłe 25 dodatkowych żądań bez konieczności tworzenia nowej instancji do uruchomienia „na zimno”. Z kolei przy ustawieniu równoczesności równym 1 taki wzrost liczby żądań może doprowadzić do 25 uruchomień „na zimno”.

Ten uproszczony scenariusz przedstawia potencjalny wzrost wydajności wynikający z równoczesności. W rzeczywistości skalowanie działania w celu optymalizacji wydajności i ograniczenia „zimnych uruchomień” przy użyciu równoczesności jest bardziej złożone. Równoczesność w Cloud Functions dla Firebase 2 generacji jest obsługiwana przez Cloud Run i jest zgodna z regułami autoskalowania instancji kontenera w Cloud Run.

Eksperymentując 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ększego procesora i pamięci RAM, aby uzyskać optymalną wydajność, aż do osiągnięcia praktycznego limitu. Funkcja, która na przykład przetwarza obrazy lub filmy intensywnie, może nie mieć zasobów do obsługi 1000 równoczesnych żądań, nawet jeśli jej ustawienia procesora i RAM są zmaksymalizowane.
• Cloud Functions dla Firebase (2 generacji) opiera się na technologii Cloud Run, dlatego warto skorzystać z wskazówek Google Cloud dotyczących optymalizacji równoczesności.
• Pamiętaj, aby dokładnie przetestować wiele równoczesności w środowisku testowym, zanim przejdziesz 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, które mają być „wgrzewane”:

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 przypadku każdej instancji nastąpi uruchomienie „na zimno” powyżej tego progu.
• Zimne uruchomienia mają najpoważniejszy wpływ na aplikacje o dużym natężeniu ruchu. Jeśli ruch w aplikacji jest duży i ustawisz wystarczająco wysoką wartość, aby przy każdym takim wzroście zmniejszyła się liczba uruchomień „na zimno”, zauważysz znaczne skrócenie czasu oczekiwania. W przypadku aplikacji o ciągłym ruchu uruchomienia „na zimno” raczej nie będą negatywnie wpływać na wydajność.

• Ustawienie minimalnej liczby instancji może być przydatne w środowiskach produkcyjnych, ale zazwyczaj należy go unikać w środowiskach testowych. Aby w projekcie testowym skalować się do zera, ale nadal ograniczać uruchomienia „na zimno” w projekcie produkcyjnym, możesz 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 przytłoczyć hipotetycznej starszej bazy 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 są umieszczane w kolejce przez 30 sekund, a następnie odrzucane z kodem odpowiedzi 429 Too Many Requests, jeśli w tym czasie nie będzie dostępne żadne wystąpienie.

Aby dowiedzieć się więcej o sprawdzonych metodach korzystania z ustawienia maksymalnej liczby instancji, zapoznaj się ze sprawdzonymi metodami ustawiania maksymalnej liczby instancji.

Ustaw limit czasu i przydział pamięci

W niektórych przypadkach funkcje mogą mieć specjalne wymagania dotyczące długiej wartości limitu czasu lub dużej ilości 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 globalnych opcji pamięci i czasu oczekiwania w sekundach, co pozwoli Ci dostosować maszynę wirtualną, na której działają Twoje funkcje. Na przykład ta funkcja w Cloud Storage wykorzystuje 1 GiB pamięci i limit czasu oczekiwania 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 w menu po lewej stronie wybierz Cloud Functions dla Firebase.
2. Wybierz funkcję, klikając jej nazwę na liście funkcji.
3. W menu u góry kliknij ikonę Edytuj.
4. Z menu Przydzielona pamięć wybierz przydział pamięci.
5. Kliknij Więcej, aby wyświetlić opcje zaawansowane, i wpisz liczbę sekund w polu tekstowym Limit czasu.
6. Kliknij Zapisz, aby zaktualizować funkcję.

Zastąp domyślne ustawienia procesora

Przydzielono do 2 GB pamięci, każda funkcja w Cloud Functions dla Firebase (2 generacji) domyślnie ma 1 procesor, a następnie zwiększa liczbę procesorów do 2 z 4 i 8 GB. Pamiętaj, że to znacznie różni się od domyślnego zachowania 1 generacji w sposób, który może prowadzić do nieco wyższego kosztu funkcji o niewielkiej ilości pamięci, jak pokazano w tej tabeli:

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 dodatkowego procesora. 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