Cloud Functions 執行環境

Cloud Run 函式是在全代管的無伺服器環境中執行，由 Google 處理基礎架構、作業系統和執行階段環境。每一項函式都在隔離的專屬安全執行環境中執行，並視需要自動擴充，生命週期也與其他函式各自獨立。

執行階段

Cloud Run functions 支援多種語言的執行階段，各別包含一組標準的系統套件，以及該語言所需的工具和程式庫。如要透過指令列或 Terraform 部署函式，則需提供「執行階段 ID」值。

Google 會為所有第 1 代與第 2 代執行環境提供安全性及維護更新項目。這些更新會自動或需以手動方式套用，視環境和設定方式而定。如要進一步瞭解如何執行環境更新，請參閱「保護 Cloud Run 函式安全」。

Node.js

執行階段	生成	環境	執行階段 ID	執行階段映像檔
Node.js 24	第 2 代	Ubuntu 24.04	nodejs24	us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24
Node.js 22	第 1 代、第 2 代	Ubuntu 22.04	nodejs22	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs22
Node.js 20	第 1 代、第 2 代	Ubuntu 22.04	nodejs20	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs20
Node.js 18	第 1 代、第 2 代	Ubuntu 22.04	nodejs18	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs18
Node.js 16	第 1 代、第 2 代	Ubuntu 18.04	nodejs16	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs16
Node.js 14	第 1 代、第 2 代	Ubuntu 18.04	nodejs14	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs14
Node.js 12	第 1 代、第 2 代	Ubuntu 18.04	nodejs12	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs12
Node.js 10	第 1 代、第 2 代	Ubuntu 18.04	nodejs10	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs10
Node.js 8	第 1 代、第 2 代	Ubuntu 18.04	nodejs8	已停用
Node.js 6	第 1 代、第 2 代	Ubuntu 18.04	nodejs6	已停用

Python

執行階段	生成	環境	執行階段 ID	執行階段映像檔
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	第 1 代、第 2 代	Ubuntu 22.04	python312	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python312
Python 3.11	第 1 代、第 2 代	Ubuntu 22.04	python311	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python311
Python 3.10	第 1 代、第 2 代	Ubuntu 22.04	python310	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python310
Python 3.9	第 1 代、第 2 代	Ubuntu 18.04	python39	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python39
Python 3.8	第 1 代、第 2 代	Ubuntu 18.04	python38	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python38
Python 3.7	第 1 代	Ubuntu 18.04	python37	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python37

Go

執行階段	生成	環境	執行階段 ID	執行階段映像檔
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	第 1 代、第 2 代	Ubuntu 22.04	go121	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go121
Go 1.20	第 1 代、第 2 代	Ubuntu 22.04	go120	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go120
Go 1.19	第 1 代、第 2 代	Ubuntu 22.04	go119	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go119
Go 1.18	第 1 代、第 2 代	Ubuntu 22.04	go118	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go118
Go 1.16	第 1 代、第 2 代	Ubuntu 18.04	go116	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go116
Go 1.13	第 1 代、第 2 代	Ubuntu 18.04	go113	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go113
Go 1.11	第 1 代、第 2 代	Ubuntu 18.04	go111	已停用

注意：根據 Go 的發布政策，每個 Go 主要版本的支援效期，會持續到出現兩個更新的主要版本為止。在更新版本的 Go 公開發布之前，相關重要日期可能暫時無法提供。

Java

執行階段	生成	環境	執行階段 ID	執行階段映像檔
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	第 1 代、第 2 代	Ubuntu 22.04	java17	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java17
Java 11	第 1 代、第 2 代	Ubuntu 18.04	java11	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/java11

Ruby

執行階段	生成	環境	執行階段 ID	執行階段映像檔
Ruby 3.4	第 2 代	Ubuntu 22.04	ruby34	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby34
Ruby 3.3	第 1 代、第 2 代	Ubuntu 22.04	ruby33	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby33
Ruby 3.2	第 1 代、第 2 代	Ubuntu 22.04	ruby32	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32
Ruby 3.0	第 1 代、第 2 代	Ubuntu 18.04	ruby30	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby30
Ruby 2.7	第 1 代、第 2 代	Ubuntu 18.04	ruby27	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby27
Ruby 2.6	第 1 代、第 2 代	Ubuntu 18.04	ruby26	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby26

PHP

執行階段	環境	生成	執行階段 ID	執行階段映像檔
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	第 1 代、第 2 代	Ubuntu 22.04	php82	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php82
PHP 8.1	第 1 代、第 2 代	Ubuntu 18.04	php81	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php81
PHP 7.4	第 1 代、第 2 代	Ubuntu 18.04	php74	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php74

.NET Core

執行階段	生成	環境	執行階段 ID	執行階段映像檔
.NET Core 8	第 2 代	Ubuntu 22.04	dotnet8	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet8
.NET Core 6	第 1 代、第 2 代	Ubuntu 22.04	dotnet6	us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet6
.NET Core 3	第 1 代、第 2 代	Ubuntu 18.04	dotnet3	us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/dotnet3

自動調整資源配置行為

Cloud Run functions 實作無伺服器模式，您只需執行程式碼，而不必擔心伺服器或虛擬機器等基礎架構問題。部署完成後，系統會自動管理函式並調度相關資源。

Cloud Run functions 處理傳入要求的方式，是將其指派給函式的執行個體。視要求量和現有函式執行個體數量而定，Cloud Run functions 可能會將要求指派給現有執行個體，或建立新的執行個體。

如果傳入要求量超過現有執行個體數量，Cloud Run functions 可能會啟動多個新執行個體來處理要求。這種自動調整資源配置的行為模式，可讓 Cloud Run functions 並行處理多個要求，且各別使用不同的函式執行個體。

注意： 如果傳入流量急遽增加，可能會間歇造成部分要求失敗，並傳回 HTTP 500 錯誤代碼，原因是這些要求在等待建立新執行個體的佇列中逾時。將工作負載設定在一分鐘內逐步增加流量，將有助於緩解此問題。詳情請參閱「Cloud Functions 疑難排解」。

在某些情況下，無限制調度資源可能並非理想選擇。為此，Cloud Run functions 允許設定特定函式在任一時間點可共存的執行個體數量上限。

無狀態

如要啟用函式的自動管理和資源調度功能，函式必須為無狀態 (stateless)，亦即單次函式叫用不得依賴前次叫用所設定的記憶體內狀態。叫用作業可能由不同函式執行個體處理，它們不會共用全域變數、記憶體、檔案系統或其他狀態。

注意：雖然不應依賴記憶體內狀態，但其通常可重複使用以提升效能；詳情請參閱「提示與祕訣」中的建議。

若要在多次函式叫用之間共用狀態，函式應使用 Memorystore、Datastore、Firestore 或 Cloud Storage 等服務持續保存資料。如要進一步瞭解 Google Cloud提供的資料庫和儲存空間選項，請參閱Google Cloud 資料庫和Google Cloud 儲存空間產品。

並行

Cloud Run functions (第 2 代)

Cloud Run functions (第 2 代) 支援在單一函式執行個體上處理多個並行要求。這有助於避免冷啟動，因為已預熱的執行個體可以同時處理多個要求，進而縮短整體延遲時間。詳情請參閱「並行」。

Cloud Run functions (第 1 代)

在 Cloud Run functions (第 1 代) 中，每個函式執行個體只能逐次處理一項並行要求，亦即程式碼每次處理一項要求時，就無法將另一項要求轉送至相同執行個體。因此，原始要求可以使用您分配的全部資源 (記憶體和 CPU)。

由於 Cloud Run functions (第 1 代) 中的並行要求是由不同的函式執行個體處理，因此不會共用變數或本機記憶體。詳情請參閱「無狀態」和「函式執行個體生命週期」。

冷啟動

新函式執行個體會在下列兩種情況啟動：

• 部署函式時。

• 當系統自動建立新函式執行個體，藉此擴充資源以因應負載需求，或偶而需要替換現有執行個體時。

在啟動新函式執行個體時，會需要載入執行階段與您的程式碼。若要求中含有函式執行個體啟動作業 (又稱冷啟動)，速度可能會比轉送至現有函式執行個體的要求更慢。但若函式接收穩定負載，冷啟動次數通常可忽略不計；除非函式頻繁異常終止而需重新啟動執行環境。

如果函式程式碼擲回未擷取的例外狀況，或導致目前程序異常終止，函式執行個體可能會重新啟動。這可能會導致更多冷啟動，進而增加延遲時間，因此建議擷取例外狀況，並避免終止目前程序。

注意：在第 1 代中，函式可用的記憶體量會影響 CPU 分配，進而影響冷啟動時間 (請參閱價格)。雖然第 2 代預設也是如此，但第 2 代可以選擇將 CPU 分配與記憶體分開設定。

如果函式易受延遲影響，請考慮設定執行個體數量下限，以避免冷啟動。

函式執行個體效期

函式執行個體通常較具韌性，除非因持續流量不足而數量縮減或函式異常終止，否則一般都會由後續函式叫用重複使用。這表示，當一個函式執行結束時，另一個函式叫用可能會由相同的函式執行個體處理。

注意：為充分提升效能，您可以在全域範圍內快取跨多次叫用的共同狀態，但函式不得依賴這個快取狀態，因為無法保證下一次叫用是否會由相同函式執行個體處理 - 請參閱「無狀態」。

函式範圍與全域範圍

單一函式叫用只會執行經宣告為進入點的函式主體。函式原始碼的全域範圍只會在冷啟動時執行，不會在已初始化的執行個體上執行。

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

您可以使用全域變數來提升效能，但不得依賴先前函式叫用在全域範圍中設定的狀態，詳情請參閱「無狀態」。

對於每個函式執行個體中，可以假設全域範圍會在函式叫用前正好執行一次。但仍不可依賴全域範圍執行的總次數或時間，因為這些值可能因自動調整資源配置的活動情形而異。

函式執行時程

函式只能在執行期間存取所分配的資源 (記憶體和 CPU)。在執行期間以外運作的程式碼不一定會執行，而且隨時都有可能停止。因此請務必正確發出函式執行結束的訊號，並避免在結束後執行任何程式碼。相關說明請參閱「HTTP 函式」、「背景函式」和「CloudEvent 函式」。

函式執行作業也受限於函式逾時的時間長度。詳情請參閱「函式逾時」。

初始化應用程式時，請將執行時程納入考量。初始化期間不應在全域範圍內建立背景任務，因為這類任務會在要求期間以外執行。

執行保證

對於每個傳入事件，通常會叫用一次函式。但是，Cloud Run functions 會因錯誤情況的不同，而無法保證在所有情況下都會叫用一次。

單一事件可叫用函式的次數上限或下限取決於函式類型：

• HTTP 函式「最多」會叫用一次。這是因為 HTTP 叫用的同步性質所致，亦即函式叫用期間發生的任何錯誤都會傳回，不會重試。正常情況下，HTTP 函式叫用端會處理錯誤並視需要重試。

• 事件導向的函式至少會叫用一次。這是由於事件具備非同步特性，在此情況下，沒有呼叫端會等待回應。在罕見情況下，系統可能會多次叫用事件驅動函式，確保事件能順利傳送。如果事件驅動函式叫用失敗並發生錯誤，除非為該函式啟用「失敗時重試」，否則系統不會再次叫用函式。

為確保函式在重試執行時正常運作，您應將其實作為「冪等」函式，確保事件即使傳送多次仍可產生預期結果 (及附帶影響)。若為 HTTP 函式，則同時表示即使呼叫者重試呼叫 HTTP 函式端點，也會傳回需要的值。如要進一步瞭解如何將函式設定為冪等，請參閱「重試背景函式」一文。

記憶體和檔案系統

每個函式都配有一定數量的記憶體可供使用。您可以在部署時設定記憶體容量，詳情請參閱「設定記憶體」。

函式執行環境內建檔案系統，其中含有與函式一併部署的來源檔案和目錄 (請參閱「結構化原始碼」)。含有來源檔案的目錄為唯讀，但其餘檔案系統皆可寫入 (作業系統所使用的檔案除外)。檔案系統的使用會納入函式記憶體用量的計算。

函式可使用各個程式設計語言的標準方法來與檔案系統互動。

注意： 在 Cloud Run functions 執行環境中，函式原始碼的根目錄就是目前的工作目錄 (.)，但 Go 執行階段例外，其函式原始碼的根目錄位於目前工作目錄下方的 ./serverless_function_source_code。

網路

無論透過執行階段內建程式庫，或是以依附元件形式納入的第三方程式庫，函式都能使用各個程式設計語言標準方法來存取公開網際網路。

嘗試在函式叫用之間重複使用網路連線。 但請注意，系統可能會關閉未使用達 10 鐘的連線，若再嘗試使用關閉的連線，會導致產生「連線重設」錯誤。程式碼應使用能夠妥善處理已關閉連線的程式庫；若使用底層網路構件，則必須明確處理連線關閉的情況。

函式隔離

每個函式部署後都會與所有其他函式相互隔離，即使是從相同來源檔案部署的函式也是如此，尤其不會共用記憶體、全域變數、檔案系統或其他狀態。

如要在已部署的函式之間共用資料，可以使用 Memorystore、Datastore、Firestore 或 Cloud Storage 等服務。或者，也可以使用適當的觸發條件，從某一個函式叫用另一個函式並傳遞必要資料，例如向 HTTP 函式的端點提出 HTTP 要求，或是將訊息發布至 Pub/Sub 主題，藉此觸發 Pub/Sub 函式。