Zarządzaj funkcjami

.


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

Wdrażanie funkcji

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

firebase deploy --only functions

Domyślnie wiersz poleceń Firebase wdraża wszystkie funkcje w Twoim źródle 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

Podczas wdrażania dużej liczby funkcji możesz przekroczyć standardowy limit i otrzymać komunikaty o błędach HTTP 429 lub 500. Aby tego uniknąć, stosuj funkcje w grupach liczących co najwyżej 10 elementów.

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

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

Usuwanie funkcji

Funkcję, która została już wdrożona, możesz usunąć na jeden z tych sposobów:

  • wyraźnie w interfejsie wiersza poleceń Firebase za pomocą polecenia functions:delete.
  • wyraźnie w Google Cloud konsoli.
  • domyślnie, usuwając funkcję ze źródła przed wdrożeniem.

Przed usunięciem funkcji z produkcji musisz potwierdzić wszystkie operacje usuwania.

Wyraźne usuwanie funkcji w CLI Firebase 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 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

Przy domyślnym usuwaniu funkcji firebase deploy analizuje kod źródłowy i usuwa z wersji produkcyjnej wszystkie funkcje, które zostały usunięte z pliku.

Zmiana nazwy, regionu lub aktywatora funkcji

Jeśli zmieniasz nazwy regionów lub ich uruchamianie w przypadku funkcji, które obsługują ruch produkcyjny, wykonaj czynności opisane w tym rozdziale, aby uniknąć utraty zdarzeń podczas modyfikacji. Zanim wykonasz te czynności, upewnij się, że funkcja jest idempotentna, ponieważ podczas zmiany będą działać jednocześnie nowa i stara wersja funkcji.

Zmienianie nazwy funkcji

Aby zmienić nazwę funkcji, utwórz w źródle nową wersję funkcji ze zmienioną nazwą a następnie uruchom 2 osobne polecenia wdrożeniowe. Pierwsze polecenie wdraża funkcję o nowej nazwie, a drugie usuwa wcześniej wdrożony wariant. Jeśli na przykład masz wywoływany przez HTTP webhook, który chcesz przemianować, zmodyfikuj kod w ten sposób:

Node.js

// 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");
});

Python

# 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

Zmiana regionu lub regionów funkcji

Jeśli zmieniasz określone regiony w przypadku funkcji, która obsługuje ruch produkcyjny, możesz zapobiec utracie zdarzeń, wykonując te czynności w kolejności:

  1. Zmień nazwę funkcji oraz odpowiednio zmień jej region lub regiony.
  2. Wdróż przemianowaną funkcję, co spowoduje tymczasowe uruchomienie 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.

Node.js

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

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

Zaktualizowany kod powinien określać właściwy filtr zdarzeń (w tym przypadku document) wraz z regionem. Zobacz Lokalizacje Cloud Functions, aby dowiedzieć się więcej.

Python

# 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óż, wykonując te czynności:

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 jest tylko jedna funkcja – firestoreTriggerAsia, która działa w ramach asia-northeast1.

Zmień typ aktywatora funkcji

W miarę rozwijania wdrożenia Cloud Functions for Firebase może się okazać, że z różnych powodów trzeba zmienić typ wyzwalacza funkcji. Możesz na przykład zmienić jeden typ zdarzenia Firebase Realtime Database lub Cloud Firestore na inny.

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 okna funkcji:

  1. Zmodyfikuj kod źródłowy, aby uwzględnić nową funkcję z wybranym typem wyzwalacza.
  2. wdrożyć funkcję, co spowoduje tymczasowe uruchomienie zarówno starej, jak i nowej funkcji;
  3. Wyraźnie usuń starą funkcję z środowiska produkcyjnego za pomocą interfejsu wiersza poleceń Firebase.

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.

Node.js

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

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

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

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

Python

# 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 for Firebase pozwala wybrać opcje czasu wykonywania, takie jak wersja środowiska wykonawczego Node.js i limit czasu dla poszczególnych funkcji, alokacja pamięci oraz minimalna i maksymalna liczba instancji funkcji.

Zgodnie ze sprawdzoną metodą te opcje (z wyjątkiem wersji Node.js) powinny być ustawiane w obiekcie konfiguracji w kodzie funkcji. Ten obiekt RuntimeOptions jest źródłem informacji o opcjach czasu wykonywania funkcji i zastąpi opcje ustawione za pomocą dowolnej innej metody (np. w konsoli Google Cloud lub w interfejsie 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 jest ustawiona na RESET_VALUE w kodzie funkcji: zastąpij 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 w większości scenariuszy, ponieważ kod nie będzie już pełnym źródłem informacji o opcjach środowiska wykonawczego funkcji. Jeśli go używasz, wyświetl pełną konfigurację funkcji w konsoli Google Cloud lub za pomocą interfejsu wiersza poleceń gcloud.

Ustawianie wersji Node.js

Pakiet SDK Firebase dla usługi Cloud Functions umożliwia wybranie ś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. Wdrażanie tych wycofanych wersji jest wyłączone.

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. Aby na przykład używać tylko wersji 18, w pliku package.json zmodyfikuj ten wiersz:

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

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

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

CLI używa wartości ustawionej w parametrye firebase.json zamiast wartości lub zakresu ustawionego oddzielnie w parametrye package.json.

Uaktualnianie środowiska wykonawczego Node.js

Aby uaktualnić środowisko wykonawcze Node.js:

  1. Upewnij się, że 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, który został utworzony w katalogu functions/ podczas inicjowania. Jeśli na przykład przechodzisz z wersji 18 na wersję 20, wpis powinien wyglądać tak: "engines": {"node": "20"}
  4. Opcjonalnie możesz przetestować zmiany za pomocą Firebase Local Emulator Suite.
  5. Wdróż ponownie wszystkie funkcje.

Ustawianie wersji Pythona

Pakiet Firebase SDK w wersji Cloud Functions 12.0.0 lub nowszej umożliwia wybranie ś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 for 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 w odpowiedzi na przychodzące żądania. Użyj tego ustawienia, aby kontrolować koszty lub ograniczyć liczbę połączeń z usługą wspierającą, np. z bazą 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łej liczbie użytkowników optymalna jest opcja z niższym wykorzystaniem procesora bez obsługi wielu wątków. 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łą liczbę wizyt, ustawienie niskiej maksymalnej liczby instancji przy dużej liczbie jednoczesnych użytkowników pozwala aplikacji obsługiwać szczyty ruchu bez generowania nadmiernych kosztów. Pamiętaj jednak, że jeśli wartość maksymalnej liczby instancji jest zbyt niska, prośby mogą zostać odrzucone po osiągnięciu limitu.

Zezwalaj na żądania równoczesne

W Cloud Functions for Firebase (1 generacji) każda instancja może obsłużyć 1 żądanie naraz, więc Zachowanie skalowania zostało ustawione tylko z ustawieniami minimalnej i maksymalnej liczby instancji. Oprócz kontroli liczby instancji w Cloud Functions for Firebase (2 generacji) możesz też za pomocą opcji concurrency kontrolować liczbę żądań, które każda instancja może obsługiwać jednocześnie. Domyślna wartość równoczesności to 80, ale możesz ustawić dowolną liczbę całkowitą z zakresu 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 potencjalne zwiększenie wydajności dzięki współbieżnoś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ównoległość w Cloud Functions for Firebase drugiej generacji jest obsługiwana przez Cloud Run i podlega regułom Cloud Run dotyczącym autoskalowania instancji kontenera.

Eksperymentując z wyższymi ustawieniami równoległości w Cloud Functions for 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 for Firebase (2 generacji) korzysta z Cloud Run, możesz też zapoznać się z instrukcjami Google Cloud dotyczącymi optymalizacji współbieżnoś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.

Utrzymywanie w gotowości minimalnej liczby instancji

Możesz ustawić minimalną liczbę instancji dla funkcji w kodzie źródłowym. Na przykład ta funkcja ustawia minimalną liczbę instancji na 5, aby utrzymać je w stanie gotowości:

Node.js

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

Python

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

Podczas określania minimalnej liczby instancji należy wziąć pod uwagę te kwestie:

  • Jeśli Cloud Functions for Firebase skaluje aplikację powyżej ustawienia, zainicjujesz uruchomienie „na zimno” w każdej instancji powyżej tego progu.
  • Uruchomienia „na zimno” mają największy wpływ na aplikacje z nieregularnym ruchem. Jeśli ruch w Twojej aplikacji jest nieregularny i ustawisz wartość na tyle wysoką, że zmniejszysz liczbę zimnych uruchomień przy każdym wzroście natężenia ruchu, zauważysz znacznie krótszy czas 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 zmniejszyć liczbę instancji do zera w projekcie testowym, ale nadal ograniczać uruchomienia „na zimno” w projekcie produkcyjnym, możesz ustawić minimalną liczbę instancji w skonfigurowanej konfiguracji:

    Node.js

    const functions = require('firebase-functions/v1');
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

W kodzie źródłowym funkcji możesz ustawić wartość maksymalnej liczby instancji. Na przykład ta funkcja ustawia limit 100 wystąpieni, aby nie przeciążać hipotetycznej starszej bazy danych:

Node.js

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

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

Python

@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 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 funkcja Cloud Storage zużywa 1 GB pamięci i przestaje działać po 300 sekundach:

Node.js

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

Python

@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ć alokację pamięci i limit czasu w konsoli Google Cloud:

  1. W konsoli Google Cloud wybierz Cloud Functions for Firebase z 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, i wpisz liczbę sekund w polu tekstowym Limit czasu.
  6. Aby zaktualizować funkcję, kliknij Zapisz.

Zastąp domyślne ustawienia procesora

Maksymalnie 2 GB przydzielonej pamięci na każdą funkcję w Cloud Functions for 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 to działanie różni się znacznie od domyślnego działania funkcji 1 generacji, co może prowadzić do nieco wyższych kosztów funkcji o małej ilości pamięci, jak pokazano w poniższej tabeli:

Przydzielona pamięć RAM Wersja 1. Domyślny procesor (ułamkowy) Domyślny CPU w wersji 2 Podwyżka ceny za ms
128 MB 12.01 1 10,5-krotnie
256MB 1/6 1 5,3×
512 MB 1/3 1 2,7 x
1 GB 7/12 1 1,6x
2 GB 1 1 1x
4 GB 2 2 1x
8 GB 2 2 1x
16 GB Nie dotyczy 4 Nie dotyczy

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

Node.js

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

Python

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

W przypadku funkcji wymagających dużej mocy obliczeniowej funkcje 2 generacji umożliwiają konfigurowanie dodatkowego procesora. Możesz zwiększyć moc procesora dla poszczególnych funkcji:

Node.js

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

Python

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