ניהול פונקציות

אתה יכול לפרוס, למחוק ולשנות פונקציות באמצעות פקודות Firebase CLI או על ידי הגדרת אפשרויות זמן ריצה בקוד המקור של הפונקציות שלך.

פריסת פונקציות

כדי לפרוס פונקציות, הפעל את פקודת Firebase CLI זו:

firebase deploy --only functions

כברירת מחדל, Firebase CLI פורס את כל הפונקציות בתוך המקור שלך בו-זמנית. אם הפרוייקט שלך מכיל יותר מ-5 פונקציות, אנו ממליצים להשתמש בדגל --only עם שמות פונקציות ספציפיים כדי לפרוס רק את הפונקציות שערכת. פריסת פונקציות ספציפיות בדרך זו מזרזת את תהליך הפריסה ומסייעת לך להימנע מלהיתקל במכסות פריסה. לדוגמה:

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

בעת פריסת מספר רב של פונקציות, אתה עלול לחרוג מהמכסה הסטנדרטית ולקבל הודעות שגיאה HTTP 429 או 500. כדי לפתור זאת, פרוס פונקציות בקבוצות של 10 או פחות.

עיין בהפניה של Firebase CLI לרשימה המלאה של הפקודות הזמינות.

כברירת מחדל, ה-CLI של Firebase מחפש functions/ פונקציות אחר קוד המקור. אם אתה מעדיף, אתה יכול לארגן פונקציות בבסיסי קוד או בקבוצות מרובות של קבצים.

מחק פונקציות

אתה יכול למחוק פונקציות שנפרסו בעבר בדרכים הבאות:

• במפורש ב-Firebase CLI עם functions:delete
• במפורש במסוף Google Cloud .
• באופן מרומז על ידי הסרת הפונקציה מהמקור לפני הפריסה.

כל פעולות המחיקה מבקשות ממך לאשר לפני הסרת הפונקציה מהייצור.

מחיקת פונקציות מפורשת ב-Firebase CLI תומכת במספר ארגומנטים וכן בקבוצות פונקציות, ומאפשרת לך לציין פונקציה הפועלת באזור מסוים. כמו כן, תוכל לעקוף את בקשת האישור.

# 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

עם מחיקת פונקציות מרומזת, firebase deploy מנתח את המקור שלך ומסיר מהייצור כל פונקציה שהוסרו מהקובץ.

שנה שם, אזור או טריגר של פונקציה

אם אתה משנה את השם או משנה את האזורים או המפעיל עבור פונקציות המטפלות בתעבורת ייצור, בצע את השלבים בסעיף זה כדי למנוע אובדן אירועים במהלך השינוי. לפני שתבצע את השלבים האלה, תחילה ודא שהפונקציה שלך היא אימפוטנטית , שכן גם הגרסה החדשה וגם הגרסה הישנה של הפונקציה שלך יפעלו בו-זמנית במהלך השינוי.

שנה שם פונקציה

כדי לשנות שם של פונקציה, צור גרסה חדשה של הפונקציה עם שמה שונה במקור ולאחר מכן הפעל שתי פקודות פריסה נפרדות. הפקודה הראשונה פורסת את הפונקציה שקיבלה את השם החדש, והפקודה השנייה מסירה את הגרסה שנפרסה קודם לכן. לדוגמה, אם יש לך חיבור אינטרנט המופעל באמצעות HTTP שברצונך לשנות את שמו, שנה את הקוד באופן הבא:

// 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!")

לאחר מכן הפעל את הפקודות הבאות כדי לפרוס את הפונקציה החדשה:

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

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

# Delete webhook
firebase functions:delete webhook

שנה אזור או אזורים של פונקציה

אם אתה משנה את האזורים שצוינו עבור פונקציה שמטפלת בתעבורת ייצור, תוכל למנוע אובדן אירוע על ידי ביצוע השלבים הבאים לפי הסדר:

1. שנה את שם הפונקציה ושנה את האזור או האזורים שלה לפי הצורך.
2. פרוס את הפונקציה ששמה שונה, מה שגורם להרצה זמנית של אותו קוד בשתי קבוצות האזורים.
3. מחק את הפונקציה הקודמת.

לדוגמה, אם יש לך פונקציה שהופעלה על ידי Cloud Firestore שנמצאת כרגע באזור הפונקציות המוגדרות כברירת מחדל של us-central1 , ואתה רוצה להעביר אותה asia-northeast1 , תחילה עליך לשנות את קוד המקור שלך כדי לשנות את שם הפונקציה ולשנות האזור.

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

לאחר מכן פרוס על ידי הפעלת:

firebase deploy --only functions:firestoreTriggerAsia

כעת פועלות שתי פונקציות זהות: firestoreTrigger פועל ב- us-central1 , ו- firestoreTriggerAsia פועל ב- asia-northeast1 .

לאחר מכן, מחק את firestoreTrigger :

firebase functions:delete firestoreTrigger

כעת יש רק פונקציה אחת - firestoreTriggerAsia , שפועלת asia-northeast1 .

שנה את סוג ההפעלה של פונקציה

בזמן שאתה מפתח את פונקציות הענן עבור Firebase שלך ​​לאורך זמן, ייתכן שיהיה עליך לשנות את סוג ההפעלה של פונקציה מסיבות שונות. לדוגמה, ייתכן שתרצה לשנות מסוג אחד של מסד נתונים בזמן אמת של Firebase או אירוע Cloud Firestore לסוג אחר.

לא ניתן לשנות את סוג האירוע של פונקציה רק ​​על ידי שינוי קוד המקור והפעלת firebase deploy . כדי למנוע שגיאות, שנה את סוג ההפעלה של פונקציה על ידי הליך זה:

1. שנה את קוד המקור כך שיכלול פונקציה חדשה עם סוג הטריגר הרצוי.
2. פרוס את הפונקציה, מה שגורם להרצה זמנית של הפונקציות הישנות והחדשות.
3. מחק במפורש את הפונקציה הישנה מהייצור באמצעות Firebase CLI.

לדוגמה, אם הייתה לך פונקציה שהופעלה כאשר אובייקט נמחק, אבל אז הפעלת ניהול גרסאות של אובייקט וברצונך להירשם לאירוע הארכיון במקום זאת, תחילה שנה את שם הפונקציה וערוך אותה כך שתהיה סוג הטריגר החדש.

// 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):
  # ...

לאחר מכן הפעל את הפקודות הבאות כדי ליצור תחילה את הפונקציה החדשה, לפני מחיקת הפונקציה הישנה:

# 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

הגדר אפשרויות זמן ריצה

Cloud Functions for Firebase מאפשר לך לבחור אפשרויות זמן ריצה כגון גרסת זמן הריצה של Node.js וזמן קצוב לכל פונקציה, הקצאת זיכרון ומופעי מינימום/מקסימום פונקציות.

כשיטת עבודה מומלצת, יש להגדיר את האפשרויות הללו (למעט גרסת Node.js) על אובייקט תצורה בתוך קוד הפונקציה. אובייקט RuntimeOptions זה הוא מקור האמת לאפשרויות זמן הריצה של הפונקציה שלך, והוא יעקוף את האפשרויות המוגדרות באמצעות כל שיטה אחרת (כגון דרך מסוף Google Cloud או gcloud CLI).

אם זרימת העבודה של הפיתוח שלך כוללת הגדרה ידנית של אפשרויות זמן ריצה דרך מסוף Google Cloud או gcloud CLI ואתה לא רוצה שערכים אלה יעקפו בכל פריסה, הגדר את האפשרות preserveExternalChanges ל- true . כאשר אפשרות זו מוגדרת כ- true , Firebase ממזג את אפשרויות זמן הריצה המוגדרות בקוד שלך עם ההגדרות של הגרסה הנפרסת כעת של הפונקציה שלך עם העדיפות הבאה:

1. האפשרות מוגדרת בקוד הפונקציות: לעקוף שינויים חיצוניים.
2. האפשרות מוגדרת ל- RESET_VALUE בקוד הפונקציות: עוקף שינויים חיצוניים עם ערך ברירת המחדל.
3. אפשרות לא מוגדרת בקוד הפונקציות, אלא מוגדרת בפונקציה שנפרסה כעת: השתמש באפשרות המצוינת בפונקציה הפרוסה.

שימוש באפשרות preserveExternalChanges: true אינה מומלצת עבור רוב התרחישים מכיוון שהקוד שלך כבר לא יהיה מקור האמת המלא לאפשרויות זמן ריצה עבור הפונקציות שלך. אם אתה כן משתמש בו, בדוק את מסוף Google Cloud או השתמש ב-gcloud CLI כדי להציג את התצורה המלאה של פונקציה.

הגדר את גרסת Node.js

Firebase SDK for Cloud Functions מאפשר מבחר זמן ריצה של Node.js. אתה יכול לבחור להפעיל את כל הפונקציות בפרויקט אך ורק בסביבת זמן הריצה המתאימה לאחת מגרסאות Node.js הנתמכות הבאות:

• Node.js 20 (תצוגה מקדימה)
• Node.js 18
• Node.js 16
• Node.js 14

כדי להגדיר את גרסת Node.js:

אתה יכול להגדיר את הגרסה בשדה engines בקובץ package.json שנוצר בספריית functions/ שלך במהלך האתחול. לדוגמה, כדי להשתמש רק בגרסה 18, ערוך את השורה הזו ב- package.json :

  "engines": {"node": "18"}

אם אתה משתמש במנהל החבילות של Yarn או שיש לך דרישות ספציפיות אחרות לתחום engines , אתה יכול להגדיר את זמן הריצה עבור Firebase SDK for Cloud Functions ב- firebase.json במקום זאת:

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

ה-CLI משתמש בערך שהוגדר ב- firebase.json בהעדפה לכל ערך או טווח שתגדיר בנפרד ב- package.json .

שדרג את זמן הריצה של Node.js

כדי לשדרג את זמן הריצה של Node.js:

1. ודא שהפרויקט שלך נמצא בתוכנית התמחור של Blaze .
2. ודא שאתה משתמש ב-Firebase CLI v11.18.0 ואילך.
3. שנה את ערך engines בקובץ package.json שנוצר בספריית functions/ שלך במהלך האתחול. לדוגמה, אם אתה משדרג מגרסה 16 לגרסה 18, הערך צריך להיראות כך: "engines": {"node": "18"}
4. לחלופין, בדוק את השינויים שלך באמצעות Firebase Local Emulator Suite .
5. פרוס מחדש את כל הפונקציות.

הגדר את גרסת Python

Firebase SDK for Cloud Functions גרסאות 12.0.0 ומעלה מאפשרות בחירה של זמן הריצה של Python. הגדר את גרסת זמן הריצה ב- firebase.json כפי שמוצג:

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

שליטה בהתנהגות קנה המידה

כברירת מחדל, Cloud Functions for Firebase משנה את מספר המופעים הפועלים בהתבסס על מספר הבקשות הנכנסות, ועלולה להקטין לאפס מופעים בזמנים של תנועה מופחתת. עם זאת, אם האפליקציה שלך דורשת זמן אחזור מופחת ואתה רוצה להגביל את מספר התחלות קרות, תוכל לשנות את התנהגות ברירת המחדל הזו על ידי ציון מספר מינימלי של מופעי מיכל שיישמרו חמים ומוכנים להגשת בקשות.

באופן דומה, אתה יכול להגדיר מספר מקסימלי כדי להגביל את קנה המידה של מופעים בתגובה לבקשות נכנסות. השתמש בהגדרה זו כדרך לשלוט בעלויות שלך או כדי להגביל את מספר החיבורים לשירות גיבוי כגון למסד נתונים.

באמצעות הגדרות אלה יחד עם הגדרת המקבילות לכל מופע (חדש בדור השני), אתה יכול לשלוט ולכוון את התנהגות קנה המידה עבור הפונקציות שלך. אופי היישום והתפקוד שלך יקבעו אילו הגדרות הן החסכוניות ביותר ויביאו לביצועים הטובים ביותר.

עבור אפליקציות מסוימות עם תעבורה נמוכה, אפשרות מעבד נמוכה יותר ללא ריבוי במקביל היא אופטימלית. עבור אחרים שבהם התחלות קרות הן נושא קריטי, הגדרת מקיפות גבוהה ומופעים מינימליים פירושה שקבוצה של מופעים נשמרת תמיד חמה כדי להתמודד עם עליות גדולות בפקק.

עבור אפליקציות בקנה מידה קטן יותר שמקבלות מעט מאוד תעבורה, קביעת מופעים מקסימליים נמוכים עם בו זמנית גבוהה פירושה שהאפליקציה יכולה להתמודד עם פרצי תעבורה מבלי לשאת בעלויות מופרזות. עם זאת, זכור שכאשר מופעים מקסימליים מוגדרים נמוך מדי, בקשות עלולות להיפסל כאשר תגיע לתקרה.

אפשר בקשות במקביל

ב-Cloud Functions for Firebase (דור ראשון), כל מופע יכול לטפל בבקשה אחת בכל פעם, כך שהתנהגות קנה המידה נקבעה רק עם הגדרות מינימום ומקסימום מופעים. בנוסף לשליטה במספר המופעים, ב-Cloud Functions for Firebase (דור שני) תוכלו לשלוט במספר הבקשות שכל מופע יכול לשרת בו זמנית עם אפשרות concurrency . ערך ברירת המחדל עבור מקביליות הוא 80, אבל אתה יכול להגדיר אותו לכל מספר שלם בין 1 ל-1000.

פונקציות עם הגדרות בו-זמניות גבוהות יותר יכולות לספוג עליות תעבורה ללא התנעה קרה מכיוון שלכל מופע יש סבירות מרווח. אם מופע מוגדר לטפל בעד 50 בקשות במקביל אך הוא מטפל כעת ב-25 בלבד, הוא יכול לטפל בשיא של 25 בקשות נוספות מבלי לדרוש מופע חדש להפעלה קרה. לעומת זאת, עם הגדרת מקיפות של 1 בלבד, עלייה זו בבקשות עשויה להוביל ל-25 התחלות קרות.

תרחיש מפושט זה מדגים את רווחי היעילות הפוטנציאליים של במקביל. במציאות, התנהגות קנה מידה כדי לייעל את היעילות ולהפחית התחלות קרות במקביל היא מורכבת יותר. מקביליות בפונקציות ענן עבור Firebase דור 2 מופעלת על ידי Cloud Run, ועוקבת אחר הכללים של Cloud Run של קנה מידה אוטומטי של מופע מיכל .

בעת ניסוי עם הגדרות במקביל גבוהות יותר ב-Cloud Functions for Firebase (דור שני), זכור את הדברים הבאים:

• הגדרות מקבילות גבוהות יותר עשויות לדרוש מעבד וזיכרון RAM גבוהים יותר לביצועים מיטביים עד הגעה למגבלה מעשית. פונקציה שעושה עיבוד תמונה או וידאו כבד, למשל, עשויה להיעדר את המשאבים לטפל ב-1000 בקשות במקביל, גם כאשר הגדרות ה-CPU וה-RAM שלה מוגדלות.
• מכיוון ש-Cloud Functions for Firebase (דור שני) מופעלת על-ידי Cloud Run, אתה יכול לעיין גם בהנחיות של Google Cloud לאופטימיזציה של מקיפות .
• הקפד לבדוק ריבוי-מקביליות ביסודיות בסביבת בדיקה לפני המעבר לרב-מקבילות בייצור.

שמור על מספר מינימלי של מופעים חמים

אתה יכול להגדיר מספר מינימלי של מופעים עבור פונקציה בקוד המקור. לדוגמה, פונקציה זו מגדירה מינימום של 5 מקרים כדי לשמור על חום:

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:

הנה כמה דברים שכדאי לקחת בחשבון בעת ​​הגדרת ערך מינימלי של מופעים:

• אם Cloud Functions for Firebase מגדיל את האפליקציה שלך מעל ההגדרה שלך, תחווה התחלה קרה עבור כל מופע מעל הסף הזה.
• להתחלות קרות יש את ההשפעה הקשה ביותר על אפליקציות עם תעבורה קפיצית. אם לאפליקציה שלך יש תנועה קפיצית ואתה מגדיר ערך גבוה מספיק כדי שהתחלות קרות יצטמצמו בכל עלייה בתנועה, תראה זמן אחזור מופחת משמעותית. עבור אפליקציות עם תעבורה קבועה, סביר להניח שהתחלות קרות לא ישפיעו קשות על הביצועים.

• הגדרת מופעים מינימליים יכולה להיות הגיונית עבור סביבות ייצור, אך בדרך כלל יש להימנע ממנה בסביבות בדיקה. כדי לשנות את קנה המידה לאפס בפרויקט הבדיקה שלך אך עדיין לצמצם התחלות קרות בפרויקט הייצור שלך, אתה יכול להגדיר ערך מינימלי של מופעים בתצורת הפרמטר שלך:

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

  פִּיתוֹן

  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.")
  

הגבל את המספר המרבי של מופעים עבור פונקציה

אתה יכול להגדיר ערך עבור מופעים מקסימליים בקוד מקור הפונקציה. לדוגמה, פונקציה זו מגדירה מגבלה של 100 מופעים כדי לא להציף מסד נתונים מדור קודם היפותטי:

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

אם פונקציית HTTP מוגדלת למגבלה המקסימלית של מופעים, בקשות חדשות יעמדו בתור למשך 30 שניות ולאחר מכן נדחות עם קוד תגובה של 429 Too Many Requests אם אין מופע זמין עד אז.

למידע נוסף על שיטות עבודה מומלצות לשימוש בהגדרות מקסימום מופעים, עיין בשיטות מומלצות אלה להגדרת מופעים מקסימליים .

הגדר פסק זמן והקצאת זיכרון

במקרים מסוימים, לפונקציות שלך עשויות להיות דרישות מיוחדות לערך זמן קצוב ארוך או הקצאה גדולה של זיכרון. אתה יכול להגדיר ערכים אלה במסוף Google Cloud או בקוד המקור של הפונקציה (Firebase בלבד).

כדי להגדיר הקצאת זיכרון וזמן קצוב בקוד המקור של הפונקציות, השתמש באפשרויות הגלובליות של שניות זיכרון ופסק זמן כדי להתאים אישית את המחשב הווירטואלי שמפעיל את הפונקציות שלך. לדוגמה, פונקציית אחסון בענן זו משתמשת ב-1GiB של זיכרון וזמן קצוב לאחר 300 שניות:

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.

הערך המרבי עבור שניות הזמן הקצוב הוא 540 , או 9 דקות.

כדי להגדיר הקצאת זיכרון וזמן קצוב במסוף של Google Cloud:

1. במסוף Google Cloud בחר ב- Cloud Functions for Firebase מהתפריט השמאלי.
2. בחר פונקציה על ידי לחיצה על שמה ברשימת הפונקציות.
3. לחץ על סמל העריכה בתפריט העליון.
4. בחר הקצאת זיכרון מהתפריט הנפתח שכותרתו זיכרון מוקצה .
5. לחץ על עוד כדי להציג את האפשרויות המתקדמות, והזן מספר שניות בתיבת הטקסט פסק זמן .
6. לחץ על שמור כדי לעדכן את הפונקציה.

לעקוף את ברירת המחדל של המעבד

עד 2GB של זיכרון שהוקצו, כל פונקציה ב-Cloud Functions for Firebase (דור שני) מוגדרת כברירת מחדל למעבד אחד, ולאחר מכן גדלה ל-2 CPU עבור 4 ו-8GB. שים לב שזה שונה באופן משמעותי מהתנהגות ברירת המחדל של הדור הראשון בדרכים שעלולות להוביל לעלויות מעט גבוהות יותר עבור פונקציות עם זיכרון נמוך, כפי שמתבטאת בטבלה הבאה:

אם אתה מעדיף התנהגות של דור ראשון עבור פונקציות הדור השני שלך, הגדר ברירת מחדל של דור ראשון כאפשרות גלובלית:

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

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

עבור פונקציות עתירות מעבד, דור שני מספק את הגמישות להגדיר מעבד נוסף. אתה יכול להגביר את המעבד על בסיס פונקציה כפי שמוצג:

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