Best practice per le funzioni

Questo documento descrive le best practice per la progettazione, l'implementazione, il test e il deployment di Cloud Run Functions.

Correttezza

Questa sezione descrive le best practice generali per la progettazione e l'implementazione di Cloud Run functions.

Scrivere funzioni idempotenti

Le funzioni devono produrre lo stesso risultato anche se vengono chiamate più volte. In questo modo puoi riprovare un'invocazione se la precedente non va a buon fine a metà del codice. Per saperne di più, consulta Riprovare le funzioni basate su eventi.

Assicurati che le funzioni HTTP inviino una risposta HTTP

Se la tua funzione è attivata tramite HTTP, ricorda di inviare una risposta HTTP, come mostrato di seguito. In caso contrario, la funzione verrà eseguita fino al timeout. In questo caso, ti verrà addebitato l'intero periodo di timeout. I timeout possono anche causare comportamenti imprevedibili o avvii a freddo nelle invocazioni successive, con conseguenti comportamenti imprevedibili o latenza aggiuntiva.

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

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}!", context.RequestAborted);
    }
}

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

Non avviare attività in background

L'attività in background è tutto ciò che accade dopo la chiusura della funzione. Una chiamata di funzione termina quando la funzione restituisce o segnala il completamento, ad esempio chiamando l'argomento callback nelle funzioni basate su eventi Node.js. Qualsiasi codice eseguito dopo l'arresto normale non può accedere alla CPU e non farà alcun progresso.

Inoltre, quando una chiamata successiva viene eseguita nello stesso ambiente, l'attività in background riprende, interferendo con la nuova chiamata. Ciò potrebbe comportare errori e comportamenti imprevisti difficili da diagnosticare. L'accesso alla rete dopo la terminazione di una funzione di solito comporta il ripristino delle connessioni (codice di errore ECONNRESET).

L'attività in background può spesso essere rilevata nei log delle singole chiamate, trovando qualsiasi elemento registrato dopo la riga che indica che la chiamata è terminata. L'attività in background a volte può essere nascosta più in profondità nel codice, soprattutto quando sono presenti operazioni asincrone come callback o timer. Controlla il codice per assicurarti che tutte le operazioni asincrone vengano completate prima di terminare la funzione.

Eliminare sempre i file temporanei

Lo spazio di archiviazione del disco locale nella directory temporanea è un file system in memoria. I file che scrivi consumano la memoria disponibile per la tua funzione e a volte persistono tra le chiamate. Se non elimini esplicitamente questi file, alla fine potresti riscontrare un errore di memoria insufficiente e un successivo riavvio a freddo.

Puoi visualizzare la memoria utilizzata da una singola funzione selezionandola nell'elenco delle funzioni nella consoleGoogle Cloud e scegliendo il grafico Utilizzo della memoria.

Se hai bisogno di accedere a uno spazio di archiviazione a lungo termine, valuta la possibilità di utilizzare i volumi di Cloud Run con Cloud Storage o i volumi NFS.

Puoi ridurre i requisiti di memoria durante l'elaborazione di file più grandi utilizzando il pipelining. Ad esempio, puoi elaborare un file su Cloud Storage creando un flusso di lettura, passandolo attraverso un processo basato sul flusso e scrivendo il flusso di output direttamente in Cloud Storage.

Framework di Functions

Per garantire che le stesse dipendenze vengano installate in modo coerente in tutti gli ambienti, ti consigliamo di includere la libreria Functions Framework nel gestore dei pacchetti e di bloccare la dipendenza a una versione specifica di Functions Framework.

A questo scopo, includi la versione che preferisci nel file di blocco pertinente (ad esempio, package-lock.json per Node.js o requirements.txt per Python).

Se Functions Framework non è elencato esplicitamente come dipendenza, verrà aggiunto automaticamente durante il processo di build utilizzando l'ultima versione disponibile.

Strumenti

Questa sezione fornisce linee guida su come utilizzare gli strumenti per implementare, testare e interagire con le funzioni Cloud Run.

Sviluppo locale

Il deployment della funzione richiede un po' di tempo, quindi spesso è più veloce testare il codice della funzione localmente.

Segnalazione degli errori

Nei linguaggi che utilizzano la gestione delle eccezioni, non generare eccezioni non rilevate, perché forzano gli avvii a freddo nelle invocazioni future.

Non uscire manualmente

L'uscita manuale può causare un comportamento imprevisto. Utilizza invece le seguenti espressioni idiomatiche specifiche per la lingua:

Node.js

Non utilizzare process.exit(). Le funzioni HTTP devono inviare una risposta con res.status(200).send(message), mentre le funzioni basate sugli eventi termineranno una volta restituite (in modo implicito o esplicito).

Python

Non utilizzare sys.exit(). Le funzioni HTTP devono restituire esplicitamente una risposta come stringa e le funzioni basate su eventi vengono chiuse una volta che restituiscono un valore (in modo implicito o esplicito).

Vai

Non utilizzare os.Exit(). Le funzioni HTTP devono restituire esplicitamente una risposta come stringa e le funzioni basate su eventi vengono chiuse una volta che restituiscono un valore (in modo implicito o esplicito).

Java

Non utilizzare System.exit(). Le funzioni HTTP devono inviare una risposta con response.getWriter().write(message), mentre le funzioni basate sugli eventi termineranno una volta restituite (in modo implicito o esplicito).

C#

Non utilizzare System.Environment.Exit(). Le funzioni HTTP devono inviare una risposta con context.Response.WriteAsync(message), mentre le funzioni basate sugli eventi termineranno una volta restituite (in modo implicito o esplicito).

Ruby

Non utilizzare exit() o abort(). Le funzioni HTTP devono restituire esplicitamente una risposta come stringa e le funzioni basate su eventi vengono chiuse una volta che restituiscono un valore (in modo implicito o esplicito).

PHP

Non utilizzare exit() o die(). Le funzioni HTTP devono restituire esplicitamente una risposta come stringa e le funzioni basate su eventi vengono chiuse una volta che restituiscono un valore (in modo implicito o esplicito).

Utilizzare SendGrid per inviare email

Cloud Run Functions non consente connessioni in uscita sulla porta 25, pertanto non puoi stabilire connessioni non sicure a un server SMTP. Il modo consigliato per inviare email è utilizzare un servizio di terze parti come SendGrid. Puoi trovare altre opzioni per l'invio di email nell'esercitazione Invio di email da un'istanza per Google Compute Engine.

Prestazioni

Questa sezione descrive le best practice per ottimizzare il rendimento.

Evita una bassa concorrenza

Poiché gli avvii completi sono costosi, la possibilità di riutilizzare istanze avviate di recente durante un picco è un'ottima ottimizzazione per gestire il carico. La limitazione della concorrenza limita il modo in cui è possibile sfruttare le istanze esistenti, causando quindi più avvii a freddo.

L'aumento della concorrenza consente di posticipare più richieste per istanza, semplificando la gestione dei picchi di carico.

Utilizzare le dipendenze in modo strategico

Poiché le funzioni sono stateless, l'ambiente di esecuzione viene spesso inizializzato da zero (durante quello che è noto come avvio a freddo). Quando si verifica un avvio a freddo, viene valutato il contesto globale della funzione.

Se le tue funzioni importano moduli, il tempo di caricamento di questi moduli può aumentare la latenza di chiamata durante un avvio a freddo. Puoi ridurre questa latenza, nonché il tempo necessario per il deployment della funzione, caricando correttamente le dipendenze e non caricando le dipendenze che la funzione non utilizza.

Utilizza le variabili globali per riutilizzare gli oggetti nelle chiamate future

Non è garantito che lo stato di una funzione Cloud Run venga preservato per le invocazioni future. Tuttavia, Cloud Run Functions spesso ricicla l'ambiente di esecuzione di una chiamata precedente. Se dichiari una variabile nell'ambito globale, il suo valore può essere riutilizzato nelle invocazioni successive senza dover essere ricalcolato.

In questo modo puoi memorizzare nella cache gli oggetti che potrebbero essere costosi da ricreare a ogni invocazione di funzione. Lo spostamento di questi oggetti dal corpo della funzione all'ambito globale può comportare miglioramenti significativi delle prestazioni. Il seguente esempio crea un oggetto pesante una sola volta per istanza di funzione e lo condivide tra tutte le chiamate di funzione che raggiungono l'istanza specificata:

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

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}",
            context.RequestAborted);
    }

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

È particolarmente importante memorizzare nella cache le connessioni di rete, i riferimenti alle librerie e gli oggetti client API nell'ambito globale. Per alcuni esempi, consulta le best practice per il networking.

Ridurre gli avvii a freddo impostando un numero minimo di istanze

Per impostazione predefinita, Cloud Run Functions adatta il numero di istanze in base al numero di richieste in entrata. Puoi modificare questo comportamento predefinito impostando un numero minimo di istanze che le funzioni Cloud Run devono mantenere pronte per gestire le richieste. L'impostazione di un numero minimo di istanze riduce gli avvii a freddo della tua applicazione. Se la tua applicazione è sensibile alla latenza, ti consigliamo di impostare un numero minimo di istanze e di completare l'inizializzazione al momento del caricamento.

Per scoprire come impostare un numero minimo di istanze, consulta Utilizzo delle istanze minime.

Note sull'avvio completo e sull'inizializzazione

L'inizializzazione globale avviene al momento del caricamento. Senza, la prima richiesta dovrebbe completare l'inizializzazione e caricare i moduli, con conseguente latenza maggiore.

Tuttavia, l'inizializzazione globale ha un impatto anche sugli avvii a freddo. Per ridurre al minimo questo impatto, inizializza solo ciò che è necessario per la prima richiesta, in modo da mantenere la latenza della prima richiesta il più bassa possibile.

Ciò è particolarmente importante se hai configurato le istanze minime come descritto sopra per una funzione sensibile alla latenza. In questo scenario, il completamento dell'inizializzazione al momento del caricamento e la memorizzazione nella cache dei dati utili garantiscono che la prima richiesta non debba farlo e venga gestita con una latenza bassa.

Se inizializzi le variabili nell'ambito globale, a seconda del linguaggio, tempi di inizializzazione lunghi possono comportare due comportamenti: - Per alcune combinazioni di linguaggi e librerie asincrone, il framework della funzione può essere eseguito in modo asincrono e restituire immediatamente un valore, causando l'esecuzione continua del codice in background, il che potrebbe causare problemi come l'impossibilità di accedere alla CPU. Per evitare questo problema, devi bloccare l'inizializzazione del modulo come descritto di seguito. In questo modo, le richieste non vengono pubblicate finché l'inizializzazione non è completata. - D'altra parte, se l'inizializzazione è sincrona, il lungo tempo di inizializzazione causerà avvii a freddo più lunghi, il che potrebbe essere un problema soprattutto con le funzioni a bassa concorrenza durante i picchi di carico.

Esempio di pre-riscaldamento di una libreria Node.js asincrona

Node.js con Firestore è un esempio di libreria Node.js asincrona. Per sfruttare min_instances, il seguente codice completa il caricamento e l'inizializzazione al momento del caricamento, bloccando il caricamento del modulo.

Viene utilizzato TLA, il che significa che è necessario ES6, utilizzando un'estensione .mjs per il codice node.js o aggiungendo type: module al file package.json.

{
  "main": "main.js",
  "type": "module",
  "dependencies": {
    "@google-cloud/firestore": "^7.10.0",
    "@google-cloud/functions-framework": "^3.4.5"
  }
}

Node.js

import Firestore from '@google-cloud/firestore';
import * as functions from '@google-cloud/functions-framework';

const firestore = new Firestore({preferRest: true});

// Pre-warm firestore connection pool, and preload our global config
// document in cache. In order to ensure no other request comes in,
// block the module loading with a synchronous global request:
const config = await firestore.collection('collection').doc('config').get();

functions.http('fetch', (req, res) => {

// Do something with config and firestore client, which are now preloaded
// and will execute at lower latency.
});

Esempi di inizializzazione globale

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  # noqa: F824

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

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}",
            context.RequestAborted);
    }

    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

Le funzioni PHP non possono conservare le variabili tra le richieste. L'esempio di ambiti riportato sopra utilizza il caricamento differito per memorizzare nella cache i valori delle variabili globali in un file.

Ciò è particolarmente importante se definisci più funzioni in un unico file e funzioni diverse utilizzano variabili diverse. A meno che tu non utilizzi l'inizializzazione differita, potresti sprecare risorse per variabili inizializzate ma mai utilizzate.

Risorse aggiuntive

Scopri di più sull'ottimizzazione del rendimento nel video "Google Cloud Performance Atlas" Tempo di avvio a freddo di Cloud Run Functions.