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

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

סביבות זמן ריצה

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

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

Node.js

זמן ריצה	יצירה	סביבה	המזהה של סביבת זמן הריצה	תמונה נטענת לאפקט
‫Node.js 26 (גרסת טרום-השקה (Preview))	דור 2	Ubuntu 24.04	nodejs26	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs26
‫Node.js 24	דור 2	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.15 (גרסת טרום-השקה (Preview))	דור 2	Ubuntu 24.04	python315	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/python315
‫Python 3.14	דור 2	Ubuntu 24.04	python314	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/python314
‫Python 3.13	דור 2	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 1.27	דור 2	Ubuntu 24.04	go127	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/go127
Go 1.26	דור 2	Ubuntu 24.04	go126	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/go126
Go 1.25	דור 2	Ubuntu 22.04	go125	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go125
Go 1.24	דור 2	Ubuntu 22.04	go124	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go124
Go 1.23	דור 2	Ubuntu 22.04	go123	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go123
Go 1.22	דור 2	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	דור 2	Ubuntu 24.04	java25	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/java25
Java 21	דור 2	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	דור 2	Ubuntu 24.04	ruby40	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/ruby40
Ruby 3.4	דור 2	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	דור 2	Ubuntu 24.04	php85	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/php85
PHP 8.4	דור 2	Ubuntu 22.04	php84	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php84
PHP 8.3	דור 2	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	דור 2	Ubuntu 24.04	dotnet10	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/dotnet10
‎.NET Core 8	דור 2	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

התנהגות של התאמה אוטומטית לעומס (automatic scaling)

פונקציות 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 (דור שני) אפשר לטפל בכמה בקשות מקבילות במכונה אחת של פונקציה. זה יכול לעזור למנוע הפעלות מההתחלה (cold start), כי מכונה שכבר הופעלה יכולה לעבד כמה בקשות בו-זמנית, וכך להפחית את זמן האחזור הכולל. לפרטים נוספים, קראו את המאמר בו-זמניות.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

לפונקציה יש גישה למשאבים שהוקצו לה (זיכרון ומעבד) רק למשך זמן הביצוע שלה. אין ערובה לכך שקוד שמופעל מחוץ לתקופת ההפעלה יופעל, ואפשר לעצור אותו בכל שלב. לכן, תמיד צריך לסמן את סיום הפונקציה בצורה נכונה ולהימנע מהרצת קוד מעבר לכך. להנחיות, קראו את המאמרים פונקציות 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.