Zarządzaj funkcjami


Funkcje możesz wdrażać, usuwać i modyfikować za pomocą poleceń 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 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 w ten sposób przyspiesza proces wdrażania i pomaga uniknąć przekroczenia limitów wdrażania. 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 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 uporządkować funkcje w kodzie źródłowym lub w kilku zestawach plików.

Usuwanie funkcji

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

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

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

Jawne 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.

Zmiana nazwy, regionu lub aktywatora funkcji

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 funkcja jest idempotentna, ponieważ podczas zmiany będą działać jednocześnie nowa i stara wersja funkcji.

Zmiana nazwy funkcji

Aby zmienić nazwę funkcji, utwórz nową wersję funkcji w źródle i uruchom 2 osobne polecenia wdrożenia. 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:

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 i w razie potrzeby 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ę wywoływaną przez Cloud Firestore, która znajduje się obecnie w regionie domyślnych funkcji w us-central1, i chcesz ją przenieść do asia-northeast1, musisz najpierw zmodyfikować kod źródłowy, aby zmienić nazwę funkcji i zaktualizować 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ć prawidłowy 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óż konfigurację, uruchamiając polecenie:

firebase deploy --only functions:firestoreTriggerAsia

Teraz są uruchomione 2 identyczne funkcje: firestoreTrigger w kontekście us-central1 i firestoreTriggerAsia w kontekście asia-northeast1.

Następnie usuń firestoreTrigger:

firebase functions:delete firestoreTrigger

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

Zmiana typu wyzwalacza funkcji

Gdy będziesz rozwijać wdrożenie Cloud Functions for Firebase z czasem, możesz musisz zmienić typ aktywatora funkcji z różnych powodów. 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 aktywatora funkcji, wykonując tę procedurę:

  1. Zmodyfikuj kod źródłowy, aby zawierał nową funkcję z wybranym typem aktywatora.
  2. Wdroż funkcję, co spowoduje tymczasowe uruchomienie zarówno starej, jak i nowej funkcji.
  3. Usuń starą funkcję z produkcji 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 umożliwia wybór opcji środowiska wykonawczego, takich jak Node.js wersję środowiska wykonawczego, limit czasu dla poszczególnych funkcji, przydział pamięci oraz minimalną/maksymalną wartość w instancjach funkcji.

Zgodnie ze sprawdzoną metodą te opcje (z wyjątkiem wersji Node.js) powinny być ustawiane w obiekcie 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 Twój proces rozwoju obejmuje ręczne ustawianie opcji czasu wykonywania w konsoli Google Cloud lub interfejsie wiersza poleceń 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 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. 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.

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

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 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 przetestuj 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 Twoja aplikacja wymaga krótszego czasu oczekiwania 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 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.

Za pomocą tych ustawień oraz ustawienia wielozadaniowość dla poszczególnych instancji (nowość w 2 generacji) możesz kontrolować i dostrajać zachowanie skalowania funkcji. Charakter aplikacji i jej funkcje decydują o tym, które ustawienia są najbardziej opłacalne i zapewnią najlepszą wydajność.

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 przypadku innych usług, w których uruchomienia „na zimno” stanowią poważny problem, ustawienie wysokiej współbieżności i minimalnej liczby instancji oznacza, że zestaw instancji jest zawsze utrzymywany w gotowości, aby obsługiwać duże wzrosty natężenia ruchu.

W przypadku mniejszych aplikacji, które mają niewielką liczbę użytkowników, ustawienie niskiej maksymalnej liczby instancji przy dużej liczbie jednoczesnych użytkowników oznacza, że aplikacja może obsługiwać wzrosty liczby użytkowników bez generowania nadmiernych kosztów. Pamiętaj jednak, że jeśli wartość maksymalnej liczby instancji jest zbyt niska, prośby mogą być odrzucane po osiągnięciu limitu.

Zezwalaj na żądania równoczesne

W usłudze Cloud Functions for Firebase (pierwszej generacji) każda instancja mogła obsługiwać tylko 1 żądanie naraz, więc zachowanie skalowania było ustawiane tylko za pomocą ustawień minimalnej i maksymalnej liczby instancji. Oprócz sterowania liczbą instancji w Cloud Functions for Firebase (2 generacji) możesz 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ównoczelności na 1 wzrost liczby żądań może spowodować 25 zimnych startów.

Ten uproszczony scenariusz pokazuje potencjalne zwiększenie wydajności dzięki równoległoś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 Cloud Functions for Firebase (druga generacja) korzysta z technologii Cloud Run i obserwuje Reguły użytkownika Cloud Run dotyczące Autoskalowanie instancji kontenera.

Podczas eksperymentowania 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 ilości pamięci RAM w celu uzyskania optymalnego do osiągnięcia praktycznego limitu. Funkcja, która wykonuje intensywne przetwarzanie obrazów lub filmów, może nie mieć zasobów do obsługi 1000 równoczesnych żądań, nawet jeśli ustawienia procesora i pamięci RAM są zmaksymalizowane.
  • 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.
  • Zanim przełączysz się na korzystanie z wielozadaności w produkcji, dokładnie przetestuj ją w środowisku testowym.

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 co najmniej 5 instancji aby było ciepło:

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.
  • Zimne uruchomienia mają najpoważniejszy wpływ na aplikacje o dużym natężeniu ruchu. Jeśli ruch w Twojej aplikacji jest nieregularny, a Ty ustawisz wystarczająco wysoką wartość, która zmniejszy liczbę zimnych uruchomień przy każdym wzroście natężenia ruchu, zauważysz znacznie krótszy czas oczekiwania. W przypadku aplikacji o stalej liczbie wizyt uruchomienia „na zimno” prawdopodobnie nie mają większego wpływu 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/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.")

Ograniczanie maksymalnej liczby instancji funkcji

W kodzie źródłowym funkcji możesz ustawić wartość maksymalnej liczby wystąpień. 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 zwiększona do maksymalnej liczby instancji, nowe żądania są umieszczane w kolejce na 30 sekund, a następnie odrzucane z kodem odpowiedzi 429 Too Many Requests, jeśli do tego czasu nie będzie dostępnej instancji.

Aby dowiedzieć się więcej o sprawdzonych metodach korzystania z ustawień maksymalnej liczby instancji, zapoznaj się z tymi sprawdzonymi metodami konfigurowania 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 dużej alokacji pamięci. Wartości te możesz ustawić w konsoli Google Cloud lub w kodzie źródłowym funkcji (tylko w Firebase).

Aby ustawić przydział 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ą 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.

Maksymalna wartość limitu czasu 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. W 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ępowanie domyślnych ustawień 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 (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:

Przydzielona pamięć RAM Wersja 1. Domyślny procesor (ułamkowy) Domyślny CPU w wersji 2 Wzrost ceny za ms
128 MB 1/12 1 10,5×
256MB 1/6 1 5,3×
512MB 1/3 1 2,7×
1 GB 7/12 1 1,6×
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 działanie 1 generacji w przypadku funkcji 2 generacji, ustaw wartości domyślne 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 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:

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