Ambiente di esecuzione di Cloud Functions
Cloud Functions viene eseguito in un ambiente serverless completamente gestito in cui Google gestisce l'infrastruttura, i sistemi operativi e gli ambienti di runtime. Ogni funzione viene eseguita nel proprio contesto di esecuzione sicura e isolato, scala automaticamente e ha un ciclo di vita indipendente da altre funzioni.
Runtime
Cloud Functions supporta più runtime dei linguaggi. Ciascuno contiene un set standard di pacchetti di sistema, nonché gli strumenti e le librerie necessari per quel linguaggio. Avrai bisogno del valore ID runtime se esegui il deployment delle funzioni dalla riga di comando o tramite Terraform.
Gli aggiornamenti di sicurezza e manutenzione sono disponibili per tutti gli ambienti di esecuzione di 1a e 2ª generazione. Questi aggiornamenti vengono applicati automaticamente o manualmente, a seconda dell'ambiente e di come lo hai configurato. Per ulteriori informazioni sugli aggiornamenti dell'ambiente di esecuzione, consulta Proteggere la funzione Cloud Functions.
Node.js
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
Node.js 22 (solo anteprima) | 2ª generazione | Ubuntu 22.04 | nodejs22 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs22 | 2027-04-30 | 2027-10-31 |
Node.js 20 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | nodejs20 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs20 | 2026-04-30 | 2026-10-30 |
Node.js 18 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | nodejs18 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs18 | 2025-04-30 | 2025-10-30 |
Node.js 16 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs16 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs16 | 2024-01-30 | 2025-01-30 |
Node.js 14 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs14 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs14 | 2024-01-30 | 2025-01-30 |
Node.js 12 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs12 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs12 | 2024-01-30 | 2025-01-30 |
Node.js 10 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs10 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs10 | 2024-01-30 | 2025-01-30 |
Node.js 8 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs8 | Dismesso | 2020-06-05 | Febbraio 2021 |
Node.js 6 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs6 | Dismesso | 2019-04-17 | Agosto 2020 |
Python
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
Python 3.12 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | python312 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python312 | 2028-10-02 | 2029-04-02 |
Python 3.11 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | python311 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python311 | 2027-10-24 | 2028-04-24 |
Python 3.10 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | python310 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python310 | 2026-10-04 | 2027-04-04 |
Python 3.9 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | python39 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python39 | 2025-10-05 | 2026-04-05 |
Python 3.8 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | python38 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python38 | 2024-10-14 | 2025-10-14 |
Python 3.7 | 1ª generazione | Ubuntu 18.04 | python37 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python37 | 2024-01-30 | 2025-01-30 |
Go
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
Vai a 1,22 | 2ª generazione | Ubuntu 22.04 | go122 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go122 | ||
Go 1.21 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | go121 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go121 | ||
Vai a 1,20 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | go120 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go120 | 2024-05-01 | 2025-05-01 |
Go 1.19 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | go119 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go119 | 2024-04-30 | 2025-01-30 |
Go 1.18 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | go118 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/go118 | 2024-01-30 | 2025-01-30 |
Go 1.16 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | go116 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go116 | 2024-01-30 | 2025-01-30 |
Go 1.13 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | go113 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/go113 | 2024-01-30 | 2025-01-30 |
Go 1.11 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | go111 | Dismesso | 2020-08-05 | Febbraio 2021 |
Java
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
Java 21 | 2ª generazione | Ubuntu 22.04 | java21 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java21 | Ottobre 2031 | |
Java 17 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | java17 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java17 | Ottobre 2027 | |
Java 11 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | java11 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/java11 | Ottobre 2024 |
Ruby
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
Ruby 3.3 (solo anteprima) | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | ruby33 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32 | 2026-03-31 | 2026-09-30 |
Ruby 3.2 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | ruby32 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32 | 2026-03-31 | 2026-09-30 |
Ruby 3.0 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | ruby30 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby30 | 2024-03-31 | 2025-03-31 |
Ruby 2.7 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | ruby27 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby27 | 2024-01-30 | 2025-01-30 |
Ruby 2.6 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | ruby26 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby26 | 2024-01-30 | 2025-01-30 |
PHP
Runtime | Ambiente | Generazione | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
PHP 8.3 | 2ª generazione | Ubuntu 22.04 | php83 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php83 | 2026-11-23 | 2027-05-23 |
PHP 8.2 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | php82 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php82 | 2025-12-08 | 2026-06-08 |
PHP 8.1 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | php81 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php81 | 2024-11-25 | 2025-11-25 |
PHP 7.4 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | php74 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php74 | 2024-01-30 | 2025-01-30 |
.NET Core
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime | Ritiro | Disattivazione |
---|---|---|---|---|---|---|
.NET Core 8 | 2ª generazione | Ubuntu 22.04 | dotnet8 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet8 | ||
.NET Core 6 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | dotnet6 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/dotnet6 | 2024-11-12 | 2025-11-12 |
.NET Core 3 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | dotnet3 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/dotnet3 | 2024-01-30 | 2025-01-30 |
Comportamento di scalabilità automatica
Cloud Functions implementa il paradigma serverless, in cui esegui il codice senza preoccuparti dell'infrastruttura sottostante, come i server o le macchine virtuali. Dopo il deployment, le funzioni vengono gestite e scalate automaticamente.
Cloud Functions gestisce le richieste in entrata assegnandole alle istanze della funzione. A seconda del volume di richieste e del numero di istanze di funzione esistenti, Cloud Functions può assegnare una richiesta a un'istanza esistente o crearne una nuova.
Nei casi in cui il volume di richieste in entrata superi il numero di istanze esistenti, Cloud Functions può avviare più nuove istanze per gestire le richieste. Questo comportamento di scalabilità automatica consente a Cloud Functions di gestire molte richieste in parallelo, ognuna utilizzando un'istanza diversa della funzione.
In alcuni casi, la scalabilità illimitata potrebbe non essere desiderata. Per risolvere questo problema, Cloud Functions consente di configurare un numero massimo di istanze che possono coesistere in qualsiasi momento per una determinata funzione.
Condizione stateless
Per abilitare la gestione e la scalabilità automatiche delle funzioni, le funzioni devono essere stateless: una chiamata di funzione non deve basarsi sullo stato in memoria impostato da una chiamata precedente. Le chiamate possono essere gestite da istanze di funzioni diverse, che non condividono variabili globali, memoria, file system o altro stato.
Se devi condividere lo stato tra le chiamate di funzione, la funzione deve utilizzare un servizio come Memorystore, Datastore, Firestore o Cloud Storage per mantenere i dati. Consulta i database Google Cloud e i prodotti di archiviazione di Google Cloud per ulteriori informazioni sulle opzioni di database e archiviazione fornite da Google Cloud.
Contemporaneità
Cloud Functions (2nd gen)
Cloud Functions (2nd gen) supporta la gestione di più richieste in parallelo su un'istanza di funzione singola. Ciò può essere utile per evitare avvii a freddo, dato che un'istanza già riscaldata può elaborare più richieste contemporaneamente, riducendo così la latenza complessiva. Per maggiori dettagli, vedi Contemporaneità.
Cloud Functions (1ª generazione.)
In Cloud Functions (1ª generazione.), ogni istanza di una funzione gestisce una sola richiesta in parallelo alla volta. Ciò significa che mentre il codice elabora una richiesta, non è possibile che una seconda richiesta venga instradata alla stessa istanza. Di conseguenza, la richiesta originale può utilizzare la quantità completa di risorse (memoria e CPU) allocate.
Poiché le richieste in parallelo in Cloud Functions (1ª generazione.) vengono elaborate da istanze di funzione diverse, non condividono variabili né memoria locale. Per ulteriori informazioni, consulta Statelessness e Durata delle istanze di funzione.
Avvii a freddo
Una nuova istanza di funzione viene avviata in due casi:
Quando esegui il deployment della funzione.
Quando viene creata automaticamente una nuova istanza di funzione per fare lo scale up in base al carico o, occasionalmente, per sostituire un'istanza esistente.
L'avvio di una nuova istanza di funzione comporta il caricamento del runtime e del codice. Le richieste che includono l'avvio dell'istanza di funzione, chiamato avvii a freddo, possono essere più lente rispetto alle richieste instradate a istanze di funzione esistenti. Tuttavia, se la funzione riceve un carico costante, il numero di avvii a freddo generalmente è trascurabile, a meno che la funzione non abbia arresti anomali frequenti e non richieda il riavvio dell'ambiente della funzione.
Se il codice della funzione genera un'eccezione non rilevata o si arresta in modo anomalo il processo attuale, l'istanza della funzione potrebbe essere riavviata. Ciò può causare un maggior numero di avvii a freddo, con una latenza maggiore, pertanto consigliamo di rilevare le eccezioni e di evitare l'interruzione del processo attuale. Consulta Segnalazione degli errori per una discussione su come gestire e segnalare gli errori in Cloud Functions.
Se la funzione è sensibile alla latenza, ti consigliamo di impostare un numero minimo di istanze per evitare avvii a freddo.
Durata di un'istanza di funzione
Le istanze di funzione sono in genere resilienti e riutilizzate per successive chiamate di funzione, a meno che non venga fatto lo scale down del numero di istanze per mancanza di traffico in corso o per arresto anomalo della funzione. Ciò significa che, quando termina l'esecuzione di una funzione, la stessa istanza di funzione può gestire la chiamata di un'altra funzione.
Ambito della funzione e ambito globale
Una singola chiamata di funzione comporta l'esecuzione del solo corpo della funzione dichiarato come punto di ingresso. L'ambito globale del codice sorgente della funzione viene eseguito solo agli avvii a freddo e non su istanze che sono già state inizializzate.
Node.js
Python
Go
Java
Ruby
Puoi utilizzare le variabili globali per ottimizzare le prestazioni, ma non devi fare affidamento sullo stato impostato nell'ambito globale da chiamate di funzione precedenti. Per ulteriori informazioni, consulta la sezione Statelessness.
Puoi presumere che per ogni istanza di funzione, l'ambito globale sia stato eseguito esattamente una volta prima di richiamare il codice della funzione. Tuttavia, non devi dipendere dal numero totale o dalla tempistica delle esecuzioni in ambito globale, poiché potrebbero variare a seconda dell'attività di scalabilità automatica.
Cronologia di esecuzione della funzione
Una funzione ha accesso alle risorse allocate (memoria e CPU) solo per la durata dell'esecuzione della funzione. L'esecuzione del codice al di fuori del periodo di esecuzione non è garantita e l'esecuzione del codice può essere interrotta in qualsiasi momento. Di conseguenza, dovresti sempre segnalare correttamente la fine dell'esecuzione della funzione ed evitare di eseguire qualsiasi codice al di fuori di quest'ultima. Per indicazioni, consulta Funzioni HTTP, Funzioni in background e CloudEvent Functions.
L'esecuzione della funzione è inoltre soggetta alla sua durata di timeout. Per ulteriori informazioni, consulta Timeout funzione.
Tieni conto delle tempistiche di esecuzione durante l'inizializzazione dell'applicazione. Le attività in background non devono essere create in ambito globale durante l'inizializzazione, poiché verrebbero eseguite al di fuori della durata di una richiesta.
Garanzie di esecuzione
In genere le funzioni vengono richiamate una volta per ogni evento in arrivo. Tuttavia, Cloud Functions non garantisce una singola chiamata in tutti i casi a causa delle differenze negli scenari di errore.
Il numero massimo o minimo di volte in cui la funzione può essere richiamata per un singolo evento dipende dal tipo di funzione:
Le funzioni HTTP vengono richiamate al massimo una volta. Questo è dovuto alla natura sincrona delle chiamate HTTP e significa che qualsiasi errore che si verifica durante la chiamata della funzione verrà restituito senza riprovare. Il chiamante di una funzione HTTP deve gestire gli errori e riprovare, se necessario.
Le funzioni basate su eventi vengono richiamate almeno una volta. Ciò è dovuto alla natura asincrona degli eventi, in cui nessun chiamante attende la risposta. In rare circostanze, il sistema potrebbe richiamare una funzione basata su eventi più volte per garantire la consegna dell'evento. Se la chiamata di una funzione basata su eventi ha esito negativo e restituisce un errore, la funzione non verrà richiamata di nuovo a meno che non vengano abilitati nuovi tentativi in caso di errore per quella funzione.
Per assicurarti che la funzione comporti correttamente i nuovi tentativi di esecuzione, devi renderla idempotente implementandola in modo che vengano generati i risultati (e gli effetti collaterali) desiderati anche se un evento viene pubblicato più volte. Nel caso delle funzioni HTTP, ciò significa anche restituire il valore desiderato anche se il chiamante riesegue la chiamata all'endpoint della funzione HTTP. Consulta Ripetere le funzioni basate su eventi per ulteriori informazioni su come rendere idempotente la tua funzione.
Memoria e file system
A ogni funzione è allocata una certa quantità di memoria per l'utilizzo. Puoi configurare la quantità di memoria al momento del deployment. Per ulteriori informazioni, consulta Limiti di memoria.
L'ambiente di esecuzione della funzione include un file system in memoria che contiene i file di origine e le directory di cui è stato eseguito il deployment con la funzione (consulta Struttura del codice sorgente). La directory contenente i file di origine è di sola lettura, ma il resto del file system è scrivibile (ad eccezione dei file utilizzati dal sistema operativo). L'utilizzo del file system viene conteggiato ai fini della quantità di memoria utilizzata da una funzione.
La tua funzione può interagire con il file system utilizzando metodi standard in ciascun linguaggio di programmazione.
Rete
La tua funzione può accedere alla rete internet pubblica utilizzando metodi standard in ogni linguaggio di programmazione, tramite librerie integrate offerte dal runtime o librerie di terze parti che includi come dipendenze.
Prova a riutilizzare le connessioni di rete nelle chiamate alle funzioni, come descritto in Ottimizzazione del networking. Tuttavia, tieni presente che una connessione che rimane inutilizzata per 10 minuti potrebbe essere chiusa dal sistema e che ulteriori tentativi di utilizzare una connessione chiusa comporteranno un errore di "reimpostazione della connessione". Il codice dovrebbe utilizzare una libreria che gestisce bene le connessioni chiuse, oppure gestirle esplicitamente se si utilizzano costrutti di rete di basso livello.
Isolamento delle funzioni
Ogni funzione di cui è stato eseguito il deployment è isolata da tutte le altre funzioni, anche quelle di cui è stato eseguito il deployment dallo stesso file di origine. In particolare, non condividono memoria, variabili globali, file system o altri stati.
Per condividere i dati tra le funzioni di cui è stato eseguito il deployment, puoi utilizzare servizi come Memorystore, Datastore, Firestore o Cloud Storage. In alternativa, puoi richiamare una funzione da un'altra usando i trigger appropriati e trasmettendo i dati necessari. Ad esempio, effettua una richiesta HTTP all'endpoint di una funzione HTTP o pubblica un messaggio in un argomento Pub/Sub per attivare una funzione Pub/Sub.