סביבת ההפעלה של Cloud Functions

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

זמני ריצה

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

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

Node.js

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
‫Node.js 24	דור שני	Ubuntu 24.04	nodejs24	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24
‫Node.js 22	דור ראשון, דור שני	Ubuntu 22.04	nodejs22	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs22
‫Node.js 20	דור ראשון, דור שני	Ubuntu 22.04	nodejs20	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs20
‫Node.js 18	דור ראשון, דור שני	Ubuntu 22.04	nodejs18	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs18
‫Node.js 16	דור ראשון, דור שני	Ubuntu 18.04	nodejs16	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs16
‫Node.js 14	דור ראשון, דור שני	Ubuntu 18.04	nodejs14	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs14
‫Node.js 12	דור ראשון, דור שני	Ubuntu 18.04	nodejs12	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs12
‫Node.js 10	דור ראשון, דור שני	Ubuntu 18.04	nodejs10	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs10
‫Node.js 8	דור ראשון, דור שני	Ubuntu 18.04	nodejs8	יצא משימוש
‫Node.js 6	דור ראשון, דור שני	Ubuntu 18.04	nodejs6	יצא משימוש

Python

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
Python 3.14	דור שני	Ubuntu 24.04	python314	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/python314
Python 3.13	דור שני	Ubuntu 22.04	python313	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python313
Python 3.12	דור ראשון, דור שני	Ubuntu 22.04	python312	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python312
Python 3.11	דור ראשון, דור שני	Ubuntu 22.04	python311	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python311
Python 3.10	דור ראשון, דור שני	Ubuntu 22.04	python310	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python310
Python 3.9	דור ראשון, דור שני	Ubuntu 18.04	python39	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python39
Python 3.8	דור ראשון, דור שני	Ubuntu 18.04	python38	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python38
Python 3.7	דור ראשון	Ubuntu 18.04	python37	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python37

Go

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
‫Go 1.26 (גרסת טרום-השקה)	דור שני	Ubuntu 24.04	go126	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/go126
‫Go 1.25	דור שני	Ubuntu 22.04	go125	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go125
‫Go 1.24	דור שני	Ubuntu 22.04	go124	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go124
‫Go 1.23	דור שני	Ubuntu 22.04	go123	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go123
‫Go 1.22	דור שני	Ubuntu 22.04	go122	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go122
‫Go 1.21	דור ראשון, דור שני	Ubuntu 22.04	go121	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go121
‫Go 1.20	דור ראשון, דור שני	Ubuntu 22.04	go120	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go120
‫Go 1.19	דור ראשון, דור שני	Ubuntu 22.04	go119	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go119
‫Go 1.18	דור ראשון, דור שני	Ubuntu 22.04	go118	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go118
‫Go 1.16	דור ראשון, דור שני	Ubuntu 18.04	go116	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go116
‫Go 1.13	דור ראשון, דור שני	Ubuntu 18.04	go113	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go113
‫Go 1.11	דור ראשון, דור שני	Ubuntu 18.04	go111	יצא משימוש

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

Java

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
Java 25	דור שני	Ubuntu 24.04	java25	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/java25
Java 21	דור שני	Ubuntu 22.04	java21	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java21
Java 17	דור ראשון, דור שני	Ubuntu 22.04	java17	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java17
Java 11	דור ראשון, דור שני	Ubuntu 18.04	java11	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/java11

Ruby

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
‫Ruby 4.0 (תצוגה מקדימה)	דור שני	Ubuntu 24.04	ruby40	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/ruby40
Ruby 3.4	דור שני	Ubuntu 22.04	ruby34	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby34
Ruby 3.3	דור ראשון, דור שני	Ubuntu 22.04	ruby33	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby33
Ruby 3.2	דור ראשון, דור שני	Ubuntu 22.04	ruby32	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32
‫Ruby 3.0	דור ראשון, דור שני	Ubuntu 18.04	ruby30	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby30
Ruby 2.7	דור ראשון, דור שני	Ubuntu 18.04	ruby27	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby27
‫Ruby 2.6	דור ראשון, דור שני	Ubuntu 18.04	ruby26	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby26

PHP

זמן ריצה	סביבה	יצירה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
PHP 8.5	דור שני	Ubuntu 24.04	php85	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/php85
PHP 8.4	דור שני	Ubuntu 22.04	php84	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php84
PHP 8.3	דור שני	Ubuntu 22.04	php83	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php83
PHP 8.2	דור ראשון, דור שני	Ubuntu 22.04	php82	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php82
PHP 8.1	דור ראשון, דור שני	Ubuntu 18.04	php81	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php81
PHP 7.4	דור ראשון, דור שני	Ubuntu 18.04	php74	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php74

‎.NET Core

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
‫‎.NET Core 10	דור שני	Ubuntu 24.04	dotnet10	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/dotnet10
‫‎.NET Core 8	דור שני	Ubuntu 22.04	dotnet8	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet8
‫‎.NET Core 6	דור ראשון, דור שני	Ubuntu 22.04	dotnet6	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet6
‫‎.NET Core 3	דור ראשון, דור שני	Ubuntu 18.04	dotnet3	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/dotnet3

אופן הפעולה של התאמה אוטומטית לעומס

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

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

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

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

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

חוסר אזרחות

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

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

אם אתם צריכים לשתף מצב בין הפעלות של פונקציות, הפונקציה צריכה להשתמש בשירות כמו Memorystore,‏ Datastore,‏ Firestore או Cloud Storage כדי לשמור את הנתונים. מידע נוסף על אפשרויות האחסון ומסדי הנתונים ש- Google Cloudמספקת זמין במאמרים בנושא Google Cloud מסדי נתונים וGoogle Cloud מוצרי אחסון.

בו-זמניות

פונקציות Cloud Run (דור שני)

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

פונקציות Cloud Run (דור ראשון)

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

מכיוון שבפונקציות Cloud Run (דור ראשון) בקשות מקבילות מעובדות על ידי מופעים שונים של פונקציות, הן לא משתפות משתנים או זיכרון מקומי. מידע נוסף זמין במאמרים בנושא Statelessness וFunction instance lifespan.

הפעלות במצב התחלתי (cold start)

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

• כשפורסים את הפונקציה.

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

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

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

הערה: בדור הראשון, כמות הזיכרון שמוקצה לפונקציה משפיעה על הקצאת המעבד (CPU), וזה בתורו יכול להשפיע על זמן ההפעלה במצב התחלתי (cold start) (ראו תמחור). אמנם זה נכון גם בדור השני כברירת מחדל, אבל בדור השני יש אפשרות להגדיר הקצאת CPU בנפרד מהזיכרון.

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

משך החיים של מופע פונקציה

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

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

היקף הפונקציה לעומת היקף גלובלי

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

Node.js

const functions = require('@google-cloud/functions-framework');

// TODO(developer): Define your own computations
const {lightComputation, heavyComputation} = require('./computations');

// Global (instance-wide) scope
// This computation runs once (at instance cold-start)
const instanceVar = heavyComputation();

/**
 * HTTP function that declares a variable.
 *
 * @param {Object} req request context.
 * @param {Object} res response context.
 */
functions.http('scopeDemo', (req, res) => {
  // Per-function scope
  // This computation runs every time this function is called
  const functionVar = lightComputation();

  res.send(`Per instance: ${instanceVar}, per function: ${functionVar}`);
});

Python

import time

import functions_framework


# Placeholder
def heavy_computation():
    return time.time()


# Placeholder
def light_computation():
    return time.time()


# Global (instance-wide) scope
# This computation runs at instance cold-start
instance_var = heavy_computation()


@functions_framework.http
def scope_demo(request):
    """
    HTTP Cloud Function that declares a variable.
    Args:
        request (flask.Request): The request object.
        <http://flask.pocoo.org/docs/1.0/api/#flask.Request>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
    """

    # Per-function scope
    # This computation runs every time this function is called
    function_var = light_computation()
    return f"Instance: {instance_var}; function: {function_var}"

Go

// h is in the global (instance-wide) scope.
var h string

// init runs during package initialization. So, this will only run during an
// an instance's cold start.
func init() {
	h = heavyComputation()
	functions.HTTP("ScopeDemo", ScopeDemo)
}

// ScopeDemo is an example of using globally and locally
// scoped variables in a function.
func ScopeDemo(w http.ResponseWriter, r *http.Request) {
	l := lightComputation()
	fmt.Fprintf(w, "Global: %q, Local: %q", h, l)
}

Java

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;

public class Scopes implements HttpFunction {
  // Global (instance-wide) scope
  // This computation runs at instance cold-start.
  // Warning: Class variables used in functions code must be thread-safe.
  private static final int INSTANCE_VAR = heavyComputation();

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // Per-function scope
    // This computation runs every time this function is called
    int functionVar = lightComputation();

    var writer = new PrintWriter(response.getWriter());
    writer.printf("Instance: %s; function: %s", INSTANCE_VAR, functionVar);
  }

  private static int lightComputation() {
    int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    return Arrays.stream(numbers).sum();
  }

  private static int heavyComputation() {
    int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    return Arrays.stream(numbers).reduce((t, x) -> t * x).getAsInt();
  }
}

Ruby

# Global (instance-wide) scope.
# This block runs on cold start, before any function is invoked.
#
# Note: It is usually best to run global initialization in an on_startup block
# instead at the top level of the Ruby file. This is because top-level code
# could be executed to verify the function during deployment, whereas an
# on_startup block is run only when an actual function instance is starting up.
FunctionsFramework.on_startup do
  instance_data = perform_heavy_computation

  # To pass data into function invocations, the best practice is to set a
  # key-value pair using the Ruby Function Framework's built-in "set_global"
  # method. Functions can call the "global" method to retrieve the data by key.
  # (You can also use Ruby global variables or "toplevel" local variables, but
  # they can make it difficult to isolate global data for testing.)
  set_global :my_instance_data, instance_data
end

FunctionsFramework.http "tips_scopes" do |_request|
  # Per-function scope.
  # This method is called every time this function is called.
  invocation_data = perform_light_computation

  # Retrieve the data computed by the on_startup block.
  instance_data = global :my_instance_data

  "instance: #{instance_data}; function: #{invocation_data}"
end

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

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

ציר זמן של הפעלת פונקציה

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

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

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

התחייבויות לביצוע

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

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

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

• פונקציות מבוססות-אירועים מופעלות לפחות פעם אחת. הסיבה לכך היא האופי האסינכרוני של האירועים, שבהם אין מתקשר שמחכה לתגובה. במקרים נדירים, המערכת עשויה להפעיל פונקציה מבוססת-אירועים יותר מפעם אחת כדי לוודא שהאירוע יועבר. אם הפעלת פונקציה מבוססת-אירועים נכשלת עם שגיאה, הפונקציה לא תופעל שוב אלא אם האפשרות retries on failure (ניסיונות חוזרים במקרה של כשל) מופעלת עבור הפונקציה הזו.

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

זיכרון ומערכת קבצים

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

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

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

הערה: בסביבת ההרצה של פונקציות Cloud Run, ספריית הבסיס של קוד המקור של הפונקציה היא ספריית העבודה הנוכחית (.), למעט סביבות ריצה של Go, שבהן ספריית הבסיס של קוד המקור של הפונקציה נמצאת מתחת לספריית העבודה הנוכחית בנתיב ./serverless_function_source_code.

רשת

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

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

בידוד פונקציות

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

כדי לשתף נתונים בין פונקציות שפרסתם, אתם יכולים להשתמש בשירותים כמו Memorystore,‏ Datastore,‏ Firestore או Cloud Storage. לחלופין, אפשר להפעיל פונקציה אחת מתוך פונקציה אחרת באמצעות הטריגרים המתאימים שלהן ולהעביר את הנתונים הנדרשים. לדוגמה, אפשר לשלוח בקשת HTTP לנקודת הקצה של פונקציית HTTP או לפרסם הודעה בנושא Pub/Sub כדי להפעיל פונקציית Pub/Sub.