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 konsoli Google Cloud .
• 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 webhook uruchamiany przez HTTP, którego nazwę chcesz zmienić, popraw kod 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 następujące 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 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ę uruchamianą przez Cloud Firestore, 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
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óż, uruchamiając:

firebase deploy --only functions:firestoreTriggerAsia

Teraz działają dwie identyczne funkcje: firestoreTrigger działa w us-central1 i firestoreTriggerAsia działa w asia-northeast1 .

Następnie usuń firestoreTrigger :

firebase functions:delete firestoreTrigger

Teraz jest tylko jedna funkcja - firestoreTriggerAsia , 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ę, która została wywołana po usunięciu obiektu, ale następnie włączyłeś wersjonowanie obiektu i zamiast tego chcesz subskrybować zdarzenie archiwizacji, najpierw zmień nazwę funkcji i edytuj ją, aby miała nowy typ wyzwalacza.

// 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 następujące polecenia, aby najpierw utworzyć nową funkcję, a następnie 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 umożliwia wybranie opcji środowiska wykonawczego, takich 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.

Ustaw wersję Pythona

Pakiet SDK Firebase dla Cloud Functions w wersji 12.0.0 i nowszych umożliwia wybór środowiska wykonawczego języka Python. Ustaw wersję środowiska wykonawczego w firebase.json , jak pokazano:

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

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.

Używając tych ustawień wraz z ustawieniem współbieżności dla instancji (nowość w drugiej generacji), możesz kontrolować i dostrajać zachowanie skalowania dla swoich funkcji. Charakter aplikacji i funkcji określi, które ustawienia będą najbardziej opłacalne i zapewnią najlepszą wydajność.

W przypadku niektórych aplikacji o małym ruchu optymalna jest opcja niższego procesora bez obsługi wielu współbieżności. W innych przypadkach, gdzie zimny start jest krytycznym problemem, ustawienie wysokiej współbieżności i minimalnej liczby instancji oznacza, że ​​zestaw instancji jest zawsze utrzymywany w cieple, aby obsłużyć duże skoki ruchu.

W przypadku aplikacji na mniejszą skalę, które generują bardzo mały ruch, ustawienie niskiej maksymalnej liczby wystąpień przy dużej współbieżności oznacza, że ​​aplikacja może obsłużyć impulsy ruchu bez ponoszenia nadmiernych kosztów. Należy jednak pamiętać, że jeśli maksymalna liczba instancji zostanie ustawiona na zbyt niskim poziomie, żądania mogą zostać odrzucone po osiągnięciu pułapu.

Zezwalaj na równoczesne żądania

W Cloud Functions dla Firebase (1. generacji) każda instancja mogła obsłużyć jedno żądanie na raz, więc zachowanie skalowania ustawiono tylko przy ustawieniach minimalnych i maksymalnych instancji. Oprócz kontrolowania liczby instancji, w Cloud Functions dla Firebase (2. generacji) możesz kontrolować liczbę żądań, które każda instancja może obsłużyć w tym samym czasie, korzystając z opcji concurrency . Domyślna wartość współbieżności to 80, ale można ją ustawić na dowolną liczbę całkowitą z zakresu od 1 do 1000.

Funkcje z wyższymi ustawieniami współbieżności mogą absorbować skoki ruchu bez zimnego rozruchu, ponieważ każda instancja prawdopodobnie ma pewien zapas mocy. Jeśli instancja jest skonfigurowana do obsługi maksymalnie 50 jednoczesnych żądań, ale obecnie obsługuje tylko 25, może obsłużyć gwałtowny wzrost liczby 25 dodatkowych żądań bez konieczności zimnego startu nowej instancji. Z kolei przy ustawieniu współbieżności wynoszącym zaledwie 1 taki wzrost liczby żądań może prowadzić do 25 zimnych startów.

Ten uproszczony scenariusz ilustruje potencjalny wzrost wydajności wynikający z współbieżności. W rzeczywistości skalowanie w celu optymalizacji wydajności i ograniczenia zimnych startów przy współbieżności jest bardziej złożone. Współbieżność w Cloud Functions dla Firebase drugiej generacji jest obsługiwana przez Cloud Run i jest zgodna z regułami Cloud Run dotyczącymi automatycznego skalowania instancji kontenera .

Eksperymentując z wyższymi ustawieniami współbieżności w Cloud Functions dla Firebase (2. generacji), pamiętaj o następujących kwestiach:

• Wyższe ustawienia współbieżności mogą wymagać większego procesora i pamięci RAM w celu uzyskania optymalnej wydajności, aż do osiągnięcia praktycznego limitu. Na przykład funkcja, która intensywnie przetwarza obrazy lub wideo, może nie mieć zasobów do obsługi 1000 jednoczesnych żądań, nawet jeśli ustawienia procesora i pamięci RAM są maksymalne.
• Ponieważ Cloud Functions dla Firebase (2. generacji) jest obsługiwane przez Cloud Run, możesz także zapoznać się ze wskazówkami Google Cloud dotyczącymi optymalizacji współbieżności .
• Przed przejściem na wielowspółbieżność w środowisku produkcyjnym należy dokładnie przetestować wielowspółbieżność w środowisku testowym.

Utrzymuj minimalną liczbę instancji w cieple

Możesz ustawić minimalną liczbę wystąpień funkcji w kodzie źródłowym. Na przykład ta funkcja ustawia co najmniej 5 instancji utrzymywania ciepła:

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 rzeczy, które należy wziąć pod uwagę przy ustawianiu minimalnej wartości instancji:

• Jeśli Cloud Functions dla Firebase przeskaluje aplikację powyżej ustawień, 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ść 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ć minimalną wartość instancji w sparametryzowanej konfiguracji:

  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.`);
    }
  );
  

  Pyton

  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ę wystąpień funkcji

Można ustawić wartość maksymalnej liczby wystąpień w kodzie źródłowym funkcji. Na przykład ta funkcja ustawia limit 100 instancji, aby nie przeciążać 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 jest skalowana do maksymalnego limitu instancji, 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 żadna instancja nie będzie dostępna.

Aby dowiedzieć się więcej o sprawdzonych metodach korzystania z ustawień maksymalnej liczby instancji, zapoznaj się z tymi sprawdzonymi metodami dotyczącymi ustawiania maksymalnej liczby instancji .

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 konsoli Google Cloud 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 opcji globalnych dotyczących pamięci i limitu czasu w sekundach, aby dostosować maszynę wirtualną, na której działają Twoje funkcje. Na przykład ta funkcja Cloud Storage wykorzystuje 1GiB pamięci i kończy się 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.

Maksymalna wartość sekund limitu czasu wynosi 540 , czyli 9 minut.

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

1. W konsoli Google Cloud wybierz Cloud Functions for Firebase 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 przycisk Zapisz , aby zaktualizować funkcję.

Zastąp ustawienia domyślne procesora

Do 2 GB przydzielonej pamięci, każda funkcja w Cloud Functions dla Firebase (2. generacji) domyślnie obsługuje jeden procesor, a następnie zwiększa się do 2 procesorów dla 4 i 8 GB. Należy zauważyć, że różni się to znacznie od domyślnego zachowania pierwszej generacji w sposób, który może prowadzić do nieco wyższych kosztów w przypadku funkcji wymagających małej ilości pamięci, jak przedstawiono w poniższej tabeli:

Jeśli wolisz zachowanie pierwszej generacji dla funkcji drugiej generacji, ustaw ustawienia domyślne pierwszej 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 intensywnie obciążających procesor, druga generacja zapewnia elastyczność konfiguracji dodatkowego procesora. Możesz zwiększyć procesor dla poszczególnych funkcji, jak pokazano:

// 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