Tipps und Tricks

In diesem Dokument werden Best Practices für das Erstellen, Implementieren, Testen und Bereitstellen von Cloud Functions-Funktionen beschrieben.

Richtigkeit

In diesem Abschnitt werden allgemeine Best Practices für das Erstellen und Implementieren von Cloud Functions-Funktionen beschrieben.

Idempotente Funktionen schreiben

Die Funktionen sollten das gleiche Ergebnis liefern, auch wenn sie mehrmals aufgerufen werden. Dadurch können Sie einen Aufruf wiederholen, wenn der vorherige Aufruf nach der Hälfte des Codes fehlschlägt. Weitere Informationen finden Sie unter Ereignisgesteuerte Funktionen wiederholen.

Sicherstellen, dass HTTP-Funktionen eine HTTP-Antwort senden

Wenn Ihre Funktion durch HTTP ausgelöst wird, denken Sie daran, wie unten gezeigt eine HTTP-Antwort zu senden. Andernfalls wird die Funktion möglicherweise ausgeführt, bis eine Zeitüberschreitung erfolgt. In diesem Fall wird Ihnen die gesamte Zeit bis zur Zeitüberschreitung in Rechnung gestellt. Zeitüberschreitungen können außerdem unvorhersehbares Verhalten zur Folge haben oder zu Kaltstarts bei nachfolgenden Aufrufen führen, was ebenfalls unvorhersehbares Verhalten nach sich ziehen oder die Latenz erhöhen kann.

Node.js

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

/**
 * Responds to an HTTP request using data from the request body parsed according
 * to the "content-type" header.
 *
 * @param {Object} req Cloud Function request context.
 * @param {Object} res Cloud Function response context.
 */
functions.http('helloHttp', (req, res) => {
  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
});

Python


import functions_framework

from markupsafe import escape
@functions_framework.http
def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <https://flask.palletsprojects.com/en/1.1.x/api/#incoming-request-data>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.make_response>.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and "name" in request_json:
        name = request_json["name"]
    elif request_args and "name" in request_args:
        name = request_args["name"]
    else:
        name = "World"
    return f"Hello {escape(name)}!"

Einfach loslegen (Go)


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"

	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

func init() {
	functions.HTTP("HelloHTTP", HelloHTTP)
}

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Java


import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Logger;

public class HelloHttp implements HttpFunction {
  private static final Logger logger = Logger.getLogger(HelloHttp.class.getName());

  private static final Gson gson = new Gson();

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // Check URL parameters for "name" field
    // "world" is the default value
    String name = request.getFirstQueryParameter("name").orElse("world");

    // Parse JSON request and check for "name" field
    try {
      JsonElement requestParsed = gson.fromJson(request.getReader(), JsonElement.class);
      JsonObject requestJson = null;

      if (requestParsed != null && requestParsed.isJsonObject()) {
        requestJson = requestParsed.getAsJsonObject();
      }

      if (requestJson != null && requestJson.has("name")) {
        name = requestJson.get("name").getAsString();
      }
    } catch (JsonParseException e) {
      logger.severe("Error parsing JSON: " + e.getMessage());
    }

    var writer = new PrintWriter(response.getWriter());
    writer.printf("Hello %s!", name);
  }
}

C#

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;

namespace HelloHttp;

public class Function : IHttpFunction
{
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public async Task HandleAsync(HttpContext context)
    {
        HttpRequest request = context.Request;
        // Check URL parameters for "name" field
        // "world" is the default value
        string name = ((string) request.Query["name"]) ?? "world";

        // If there's a body, parse it as JSON and check for "name" field.
        using TextReader reader = new StreamReader(request.Body);
        string text = await reader.ReadToEndAsync();
        if (text.Length > 0)
        {
            try
            {
                JsonElement json = JsonSerializer.Deserialize<JsonElement>(text);
                if (json.TryGetProperty("name", out JsonElement nameElement) &&
                    nameElement.ValueKind == JsonValueKind.String)
                {
                    name = nameElement.GetString();
                }
            }
            catch (JsonException parseException)
            {
                _logger.LogError(parseException, "Error parsing JSON request");
            }
        }

        await context.Response.WriteAsync($"Hello {name}!");
    }
}

Ruby

require "functions_framework"
require "cgi"
require "json"

FunctionsFramework.http "hello_http" do |request|
  # The request parameter is a Rack::Request object.
  # See https://www.rubydoc.info/gems/rack/Rack/Request
  name = request.params["name"] ||
         (request.body.rewind && JSON.parse(request.body.read)["name"] rescue nil) ||
         "World"
  # Return the response body as a string.
  # You can also return a Rack::Response object, a Rack response array, or
  # a hash which will be JSON-encoded into a response.
  "Hello #{CGI.escape_html name}!"
end

PHP

<?php

use Google\CloudFunctions\FunctionsFramework;
use Psr\Http\Message\ServerRequestInterface;

// Register the function with Functions Framework.
// This enables omitting the `FUNCTIONS_SIGNATURE_TYPE=http` environment
// variable when deploying. The `FUNCTION_TARGET` environment variable should
// match the first parameter.
FunctionsFramework::http('helloHttp', 'helloHttp');

function helloHttp(ServerRequestInterface $request): string
{
    $name = 'World';
    $body = $request->getBody()->getContents();
    if (!empty($body)) {
        $json = json_decode($body, true);
        if (json_last_error() != JSON_ERROR_NONE) {
            throw new RuntimeException(sprintf(
                'Could not parse body: %s',
                json_last_error_msg()
            ));
        }
        $name = $json['name'] ?? $name;
    }
    $queryString = $request->getQueryParams();
    $name = $queryString['name'] ?? $name;

    return sprintf('Hello, %s!', htmlspecialchars($name));
}

Keine Hintergrundaktivitäten starten

Als Hintergrundaktivität werden alle Aktivitäten bezeichnet, die nach Beendigung der Funktion stattfinden. Ein Funktionsaufruf wird beendet, wenn die Funktion ein Ergebnis zurückgibt oder anderweitig ihren Abschluss signalisiert, z. B. durch Aufrufen des callback-Arguments in ereignisgesteuerten Node.js-Funktionen. Nach einer ordnungsgemäßen Beendigung ausgeführter Code kann nicht auf die CPU zugreifen und erzielt keine Fortschritte.

Wenn ein nachfolgender Aufruf in derselben Umgebung ausgeführt wird, wird außerdem die Hintergrundaktivität fortgesetzt und beeinträchtigt den neuen Aufruf. Das kann unerwartetes Verhalten und schwer zu analysierende Fehler hervorrufen. Wenn Sie nach Beendigung einer Funktion auf das Netzwerk zugreifen, werden Verbindungen in der Regelzurückgesetzt (Fehlercode ECONNRESET).

Hintergrundaktivitäten können häufig in Logs von individuellen Aufrufen erkannt werden. Dazu müssen Sie in den Logs danach suchen, was unterhalb der Zeile erfasst wurde, in der die Beendigung des Aufrufs aufgeführt ist. Hintergrundaktivitäten sind manchmal tiefer im Code verborgen, insbesondere wenn asynchrone Vorgänge wie Callbacks oder Timer vorliegen. Prüfen Sie den Code, um sicherzustellen, dass alle asynchronen Vorgänge abgeschlossen sind, bevor Sie die Funktion beenden.

Temporäre Dateien immer löschen

Der lokale Laufwerkspeicher im temporären Verzeichnis ist ein speicherinternes Dateisystem. Dateien, die Sie schreiben, belegen Arbeitsspeicher, der für die Funktion verfügbar ist, und bleiben manchmal zwischen Aufrufen bestehen. Wenn diese Dateien nicht explizit gelöscht werden, kann es zu einem Fehler aufgrund fehlenden Speichers und zu einem anschließenden Kaltstart kommen.

Wenn Sie nachsehen möchten, wie viel Arbeitsspeicher eine bestimmte Funktion belegt, können Sie sie in der Liste der Funktionen in der Google Cloud Console auswählen und das Diagramm Arbeitsspeichernutzung auswählen.

Versuchen Sie nicht, Code außerhalb des temporären Verzeichnisses zu schreiben, und verwenden Sie zum Erstellen von Dateipfaden unbedingt plattform-/betriebssystemunabhängige Methoden.

Wenn Sie größere Dateien mit Pipelining verarbeiten, können Sie den Arbeitsspeicherbedarf reduzieren. Zum Verarbeiten einer Datei in Cloud Storage können Sie beispielsweise einen Lesestream erstellen, diesen durch einen streambasierten Prozess leiten und den Ausgabestream direkt in Cloud Storage schreiben.

Functions Framework

Wenn Sie eine Funktion bereitstellen, wird das Functions Framework automatisch als Abhängigkeit mit der aktuellen Version hinzugefügt. Damit dieselben Abhängigkeiten in verschiedenen Umgebungen einheitlich installiert werden, empfehlen wir, dass Sie Ihre Funktion an eine bestimmte Version des Functions Frameworks anpinnen.

Fügen Sie dazu Ihre bevorzugte Version in die entsprechende Sperrdatei ein, z. B. package-lock.json für Node.js oder requirements.txt für Python.

Tools

Dieser Abschnitt enthält Richtlinien zur Verwendung von Tools zum Implementieren, Testen und Anwenden von Cloud Functions-Funktionen.

Lokale Entwicklung

Da die Funktionsbereitstellung zeitaufwendig ist, geht es oft schneller, den Code einer Funktion lokal zu testen.

Fehlerberichte

Lösen Sie bei Sprachen, in denen eine Ausnahmenbehandlung erfolgt, keine nicht erfassten Ausnahmen aus, da diese bei zukünftigen Aufrufen Kaltstarts erzwingen. Informationen zur ordnungsgemäßen Erstellung von Fehlerberichten finden Sie im Error Reporting-Leitfaden.

Nicht manuell beenden

Das manuelle Beenden kann zu unerwartetem Verhalten führen. Bitte verwenden Sie stattdessen die folgenden sprachspezifischen Programmiersprachen:

Node.js

Nicht process.exit() verwenden. HTTP-Funktionen sollten eine Antwort mit res.status(200).send(message) senden. Ereignisgesteuerte Funktionen werden beendet, wenn sie zurückgegeben werden (entweder implizit oder explizit).

Python

Nicht sys.exit() verwenden. HTTP-Funktionen sollten eine Antwort explizit als String zurückgeben. Ereignisgesteuerte Funktionen werden beendet, sobald sie einen Wert zurückgeben (entweder implizit oder explizit).

Go

Nicht os.Exit() verwenden. HTTP-Funktionen sollten eine Antwort explizit als String zurückgeben. Ereignisgesteuerte Funktionen werden beendet, sobald sie einen Wert zurückgeben (entweder implizit oder explizit).

Java

Nicht System.exit() verwenden. HTTP-Funktionen sollten eine Antwort mit response.getWriter().write(message) senden. Ereignisgesteuerte Funktionen werden beendet, wenn sie zurückgegeben werden (entweder implizit oder explizit).

C#

Nicht System.Environment.Exit() verwenden. HTTP-Funktionen sollten eine Antwort mit context.Response.WriteAsync(message) senden. Ereignisgesteuerte Funktionen werden beendet, wenn sie zurückgegeben werden (entweder implizit oder explizit).

Ruby

Verwenden Sie nicht exit() oder abort(). HTTP-Funktionen sollten eine Antwort explizit als String zurückgeben. Ereignisgesteuerte Funktionen werden beendet, sobald sie einen Wert zurückgeben (entweder implizit oder explizit).

PHP

Verwenden Sie nicht exit() oder die(). HTTP-Funktionen sollten eine Antwort explizit als String zurückgeben. Ereignisgesteuerte Funktionen werden beendet, sobald sie einen Wert zurückgeben (entweder implizit oder explizit).

E-Mails mit SendGrid senden

Cloud Functions lässt keine ausgehenden Verbindungen über Port 25 zu, sodass Sie keine nicht gesicherten Verbindungen zu einem SMTP-Server herstellen können. Die empfohlene Methode zum Senden von E-Mails ist SendGrid. Weitere Optionen zum Senden von E-Mails finden Sie in der Anleitung E-Mails von einer Instanz senden für Google Compute Engine.

Leistung

In diesem Abschnitt erfahren Sie mehr über die Best Practices zur Optimierung der Leistung.

Abhängigkeiten mit Bedacht verwenden

Da Funktionen zustandslos sind, wird die Ausführungsumgebung in einem sogenannten Kaltstart oft komplett neu initialisiert. Wenn ein Kaltstart erfolgt, wird der globale Kontext der Funktion ausgewertet.

Wenn für Funktionen Module importiert werden, kann die Ladezeit dieser Module die Aufruflatenz während eines Kaltstarts erhöhen. Sie können diese Latenz und die für die Bereitstellung der Funktion erforderliche Zeit reduzieren, indem Sie Abhängigkeiten ordnungsgemäß laden und keine nicht benötigten Abhängigkeiten verwenden.

Globale Variablen verwenden, um Objekte in zukünftigen Aufrufen wiederzuverwenden

Es gibt keine Garantie dafür, dass der Status einer Cloud Functions-Funktion für zukünftige Aufrufe erhalten bleibt. Die Ausführungsumgebung eines vorherigen Aufrufs wird in Cloud Functions jedoch oft wiederverwendet. Wenn Sie eine globale Variable deklarieren, kann ihr Wert in nachfolgenden Aufrufen wiederverwendet werden, ohne dass eine Neuberechnung erforderlich ist.

Dadurch können Sie Objekte, deren Neuerstellung bei jedem Funktionsaufruf teuer sein kann, im Cache speichern. Das Verschieben solcher Objekte aus dem Funktionsrumpf in den globalen Gültigkeitsbereich kann zu erheblichen Leistungsverbesserungen führen. Im folgenden Beispiel wird ein schweres Objekt nur einmal pro Funktionsinstanz erstellt und für alle Funktionsaufrufe freigegeben, die die angegebene Instanz erreichen:

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

Einfach loslegen (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();
  }
}

C#

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using System.Linq;
using System.Threading.Tasks;

namespace Scopes;

public class Function : IHttpFunction
{
    // Global (server-wide) scope.
    // This computation runs at server cold-start.
    // Warning: Class variables used in functions code must be thread-safe.
    private static readonly int GlobalVariable = HeavyComputation();

    // Note that one instance of this class (Function) is created per invocation,
    // so calling HeavyComputation in the constructor would not have the same
    // benefit.

    public async Task HandleAsync(HttpContext context)
    {
        // Per-function-invocation scope.
        // This computation runs every time this function is called.
        int functionVariable = LightComputation();

        await context.Response.WriteAsync($"Global: {GlobalVariable}; function: {functionVariable}");
    }

    private static int LightComputation()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        return numbers.Sum();
    }

    private static int HeavyComputation()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        return numbers.Aggregate((current, next) => current * next);
    }
}

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

PHP


use Psr\Http\Message\ServerRequestInterface;

function scopeDemo(ServerRequestInterface $request): string
{
    // Heavy computations should be cached between invocations.
    // The PHP runtime does NOT preserve variables between invocations, so we
    // must write their values to a file or otherwise cache them.
    // (All writable directories in Cloud Functions are in-memory, so
    // file-based caching operations are typically fast.)
    // You can also use PSR-6 caching libraries for this task:
    // https://packagist.org/providers/psr/cache-implementation
    $cachePath = sys_get_temp_dir() . '/cached_value.txt';

    $response = '';
    if (file_exists($cachePath)) {
        // Read cached value from file, using file locking to prevent race
        // conditions between function executions.
        $response .= 'Reading cached value.' . PHP_EOL;
        $fh = fopen($cachePath, 'r');
        flock($fh, LOCK_EX);
        $instanceVar = stream_get_contents($fh);
        flock($fh, LOCK_UN);
    } else {
        // Compute cached value + write to file, using file locking to prevent
        // race conditions between function executions.
        $response .= 'Cache empty, computing value.' . PHP_EOL;
        $instanceVar = _heavyComputation();
        file_put_contents($cachePath, $instanceVar, LOCK_EX);
    }

    // Lighter computations can re-run on each function invocation.
    $functionVar = _lightComputation();

    $response .= 'Per instance: ' . $instanceVar . PHP_EOL;
    $response .= 'Per function: ' . $functionVar . PHP_EOL;

    return $response;
}

Insbesondere globale Netzwerkverbindungen, Bibliotheksreferenzen und API-Clientobjekte sollten im Cache gespeichert werden. Entsprechende Beispiele finden Sie unter Netzwerke optimieren.

Verzögerte Initialisierung globaler Variablen

Bei der Initialisierung globaler Variablen wird der Initialisierungscode immer über einen Kaltstartaufruf ausgeführt, wodurch sich die Latenz der Funktion erhöht. In bestimmten Fällen führt dies zu vorübergehenden Zeitüberschreitungen bei den Diensten, die aufgerufen werden, wenn sie nicht ordnungsgemäß in einem try/catch-Block verarbeitet werden. Wenn einige Objekte nicht in allen Codepfaden verwendet werden, sollten Sie sie nach Bedarf verzögert initialisieren:

Node.js

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

// Always initialized (at cold-start)
const nonLazyGlobal = fileWideComputation();

// Declared at cold-start, but only initialized if/when the function executes
let lazyGlobal;

/**
 * HTTP function that uses lazy-initialized globals
 *
 * @param {Object} req request context.
 * @param {Object} res response context.
 */
functions.http('lazyGlobals', (req, res) => {
  // This value is initialized only if (and when) the function is called
  lazyGlobal = lazyGlobal || functionSpecificComputation();

  res.send(`Lazy global: ${lazyGlobal}, non-lazy global: ${nonLazyGlobal}`);
});

Python

import functions_framework

# Always initialized (at cold-start)
non_lazy_global = file_wide_computation()

# Declared at cold-start, but only initialized if/when the function executes
lazy_global = None

@functions_framework.http
def lazy_globals(request):
    """
    HTTP Cloud Function that uses lazily-initialized globals.
    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>.
    """
    global lazy_global, non_lazy_global

    # This value is initialized only if (and when) the function is called
    if not lazy_global:
        lazy_global = function_specific_computation()

    return f"Lazy: {lazy_global}, non-lazy: {non_lazy_global}."

Einfach loslegen (Go)


// Package tips contains tips for writing Cloud Functions in Go.
package tips

import (
	"context"
	"log"
	"net/http"
	"sync"

	"cloud.google.com/go/storage"
	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

// client is lazily initialized by LazyGlobal.
var client *storage.Client
var clientOnce sync.Once

func init() {
	functions.HTTP("LazyGlobal", LazyGlobal)
}

// LazyGlobal is an example of lazily initializing a Google Cloud Storage client.
func LazyGlobal(w http.ResponseWriter, r *http.Request) {
	// You may wish to add different checks to see if the client is needed for
	// this request.
	clientOnce.Do(func() {
		// Pre-declare an err variable to avoid shadowing client.
		var err error
		client, err = storage.NewClient(context.Background())
		if err != nil {
			http.Error(w, "Internal error", http.StatusInternalServerError)
			log.Printf("storage.NewClient: %v", err)
			return
		}
	})
	// Use client.
}

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 LazyFields implements HttpFunction {
  // Always initialized (at cold-start)
  // Warning: Class variables used in Servlet classes must be thread-safe,
  // or else might introduce race conditions in your code.
  private static final int NON_LAZY_GLOBAL = fileWideComputation();

  // Declared at cold-start, but only initialized if/when the function executes
  // Uses the "initialization-on-demand holder" idiom
  // More information: https://en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom
  private static class LazyGlobalHolder {
    // Making the default constructor private prohibits instantiation of this class
    private LazyGlobalHolder() {}

    // This value is initialized only if (and when) the getLazyGlobal() function below is called
    private static final Integer INSTANCE = functionSpecificComputation();

    private static Integer getInstance() {
      return LazyGlobalHolder.INSTANCE;
    }
  }

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    Integer lazyGlobal = LazyGlobalHolder.getInstance();

    var writer = new PrintWriter(response.getWriter());
    writer.printf("Lazy global: %s; non-lazy global: %s%n", lazyGlobal, NON_LAZY_GLOBAL);
  }

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

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

C#

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace LazyFields;

public class Function : IHttpFunction
{
    // This computation runs at server cold-start.
    // Warning: Class variables used in functions code must be thread-safe.
    private static readonly int NonLazyGlobal = FileWideComputation();

    // This variable is initialized at server cold-start, but the
    // computation is only performed when the function needs the result.
    private static readonly Lazy<int> LazyGlobal = new Lazy<int>(
        FunctionSpecificComputation,
        LazyThreadSafetyMode.ExecutionAndPublication);

    public async Task HandleAsync(HttpContext context)
    {
        // In a more complex function, there might be some paths that use LazyGlobal.Value,
        // and others that don't. The computation is only performed when necessary, and
        // only once per server.
        await context.Response.WriteAsync(
            $"Lazy global: {LazyGlobal.Value}; non-lazy global: {NonLazyGlobal}");
    }

    private static int FunctionSpecificComputation()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        return numbers.Sum();
    }

    private static int FileWideComputation()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        return numbers.Aggregate((current, next) => current * next);
    }
}

Ruby

FunctionsFramework.on_startup do
  # This method is called when the function is initialized, not on each
  # invocation.

  # Declare and set non_lazy_global
  set_global :non_lazy_global, file_wide_computation

  # Declare, but do not set, lazy_global
  set_global :lazy_global do
    function_specific_computation
  end
end

FunctionsFramework.http "tips_lazy" do |_request|
  # This method is called every time this function is called.

  "Lazy: #{global :lazy_global}; non_lazy: #{global :non_lazy_global}"
end

PHP

PHP-Funktionen können Variablen zwischen Anfragen nicht beibehalten. Im Bereichsbeispiel oben wird Lazy Loading verwendet, um globale Variablenwerte aus einer Datei im Cache zu speichern.

Das ist besonders wichtig, wenn Sie mehrere Funktionen in einer einzigen Datei definieren und wenn verschiedene Funktionen unterschiedliche Variablen verwenden. Wenn Sie auf die verzögerte Initialisierung verzichten, verschwenden Sie möglicherweise Ressourcen für Variablen, die zwar initialisiert, aber nie verwendet werden.

Kaltstarts durch Festlegen einer Mindestanzahl an Instanzen reduzieren

Standardmäßig skaliert Cloud Functions die Anzahl der Instanzen basierend auf der Anzahl der eingehenden Anfragen. Sie können dieses Standardverhalten ändern, indem Sie eine Mindestanzahl von Instanzen festlegen, die Cloud Functions bereithalten muss, Anfragen zu verarbeiten. Wenn Sie eine Mindestanzahl von Instanzen festlegen, werden Kaltstarts der Anwendung reduziert. Wir empfehlen, eine Mindestanzahl von Instanzen festzulegen, wenn Ihre Anwendung latenzempfindlich ist.

Informationen zum Festlegen einer Mindestanzahl von Instanzen finden Sie unter Mindestinstanzzahl verwenden.

Weitere Informationen

Das Video „Cloud Performance Atlas“ von Google mit dem Titel Cloud Functions Cold Boot Time (Kaltstartzeit von Cloud Functions) enthält weitere Informationen.