Ambiente di esecuzione di Cloud Functions
Le funzioni Cloud Run vengono eseguite in un ambiente serverless completamente gestito in cui Google gestisce l'infrastruttura, i sistemi operativi e gli ambienti di runtime. Ogni funzione viene eseguita nella propria esecuzione sicura isolata di contesto, scala automaticamente e ha un ciclo di vita indipendente funzioni.
Runtime
Le funzioni Cloud Run supportano più ambienti di runtime per i linguaggi. Ognuno contiene un insieme standard di pacchetti di sistema, nonché gli strumenti e le librerie necessari per quel linguaggio. Avrai bisogno della Valore ID runtime se esegui il deployment delle funzioni dalla riga di comando o tramite Terraform.
Gli aggiornamenti di manutenzione e sicurezza sono disponibili per tutti gli utenti di 1a e 2ª generazione ambienti di esecuzione. 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 Proteggi la funzione Cloud Run.
Node.js
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime |
---|---|---|---|---|
Node.js 22 (solo anteprima) | 2ª gen. | Ubuntu 22.04 | nodejs22 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs22 |
Node.js 20 | 1ª gen., 2ª gen. | Ubuntu 22.04 | nodejs20 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs20 |
Node.js 18 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | nodejs18 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/nodejs18 |
Node.js 16 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs16 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs16 |
Node.js 14 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs14 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs14 |
Node.js 12 | 1ª gen., 2ª gen. | Ubuntu 18.04 | nodejs12 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs12 |
Node.js 10 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs10 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/nodejs10 |
Node.js 8 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs8 | Dismesso |
Node.js 6 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | nodejs6 | Dismesso |
Python
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime |
---|---|---|---|---|
Python 3.12 | 1ª gen., 2ª gen. | Ubuntu 22.04 | python312 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python312 |
Python 3.11 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | python311 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python311 |
Python 3.10 | 1ª gen., 2ª gen. | Ubuntu 22.04 | python310 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python310 |
Python 3.9 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | python39 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python39 |
Python 3.8 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | python38 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python38 |
Python 3.7 | 1ª gen. | Ubuntu 18.04 | python37 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/python37 |
Vai
Java
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime |
---|---|---|---|---|
Java 21 | 2ª gen. | Ubuntu 22.04 | java21 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java21 |
Java 17 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | java17 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/java17 |
Java 11 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | java11 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/java11 |
Ruby
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime |
---|---|---|---|---|
Ruby 3.3 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | ruby33 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32 |
Ruby 3.2 | 1ª generazione., 2ª generazione. | Ubuntu 22.04 | ruby32 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/ruby32 |
Ruby 3.0 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | ruby30 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby30 |
Ruby 2.7 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | ruby27 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby27 |
Ruby 2.6 | 1ª gen., 2ª gen. | Ubuntu 18.04 | ruby26 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/ruby26 |
PHP
Runtime | Ambiente | Generazione | ID runtime | Immagine runtime |
---|---|---|---|---|
PHP 8.3 | 2ª gen. | Ubuntu 22.04 | php83 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php83 |
PHP 8.2 | 1ª gen., 2ª gen. | Ubuntu 22.04 | php82 | us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/php82 |
PHP 8.1 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | php81 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php81 |
PHP 7.4 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | php74 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/php74 |
.NET Core
Runtime | Generazione | Ambiente | ID runtime | Immagine runtime |
---|---|---|---|---|
.NET Core 8 | 2ª gen. | 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 |
.NET Core 3 | 1ª generazione., 2ª generazione. | Ubuntu 18.04 | dotnet3 | us-central1-docker.pkg.dev/serverless-runtimes/google-18-full/runtimes/dotnet3 |
Comportamento di scalabilità automatica
Le funzioni Cloud Run implementano il paradigma serverless, in cui esegui il tuo codice senza preoccuparti dell'infrastruttura sottostante, come i server o macchine virtuali. Una volta dipiegato, le funzioni vengono gestite e scalate automaticamente.
Le funzioni Cloud Run gestisce le richieste in entrata assegnandole a instances della funzione. A seconda del volume di richieste, nonché il numero di istanze di funzione esistenti, le funzioni Cloud Run possono assegnare a un'istanza esistente o crearne una nuova.
Se il volume delle richieste in entrata supera il numero di istanze esistenti, Le funzioni Cloud Run possono avviare più nuove istanze per gestire le richieste. Questo comportamento di scalabilità automatica consente alle funzioni Cloud Run di gestire molte richieste in parallelo, ciascuna utilizzando un'istanza diversa della funzione.
In alcuni casi, la scalabilità illimitata potrebbe non essere desiderata. Per risolvere questo problema, Le funzioni di Cloud Run consentono di configurare numero massimo di istanze che possono coesistere in qualsiasi momento per una particolare 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 potrebbero essere gestite da una funzione diversa di Compute Engine, che non condividono variabili globali, memoria, file system o altre 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 rendere permanenti i dati. Consulta database Google Cloud e Prodotti di archiviazione Google Cloud per ulteriori informazioni le opzioni di database e archiviazione fornite da Google Cloud.
Contemporaneità
Funzioni di Cloud Run (2ª generazione.)
Le funzioni Cloud Run (2ª generazione.) supportano la gestione di più richieste in parallelo su un un'istanza di funzione singola. Questo può essere utile per evitare avvii a freddo, dato che un'istanza già in uso può elaborare più richieste contemporaneamente, riducendo la latenza complessiva. Per maggiori dettagli, vedi Contemporaneità.
Funzioni Cloud Run (1ª gen.)
Nelle funzioni Cloud Run (1ª gen.), ogni istanza di una funzione gestisce una sola richiesta concorrenziale alla volta. Ciò significa che mentre il codice ne sta elaborando uno, non c'è alcuna possibilità che una seconda richiesta venga instradata allo stesso in esecuzione in un'istanza Compute Engine. Di conseguenza, la richiesta originale può utilizzare la quantità completa di risorse (memoria e CPU) che assegni.
Poiché le richieste in parallelo nelle funzioni Cloud Run (1ª generazione.) vengono elaborate istanze di funzione diverse, non condividono variabili o memoria locale. Consulta Stateless e Per ulteriori informazioni, consulta la durata di un'istanza 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 per il 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 rispetto alle richieste instradate a istanze di funzione esistenti. Se la tua funzione riceve un carico costante, tuttavia, il numero di avvii a freddo è generalmente trascurabile, a meno che la funzione abbia arresti anomali frequenti e richieda il riavvio di dell'ambiente della funzione.
Se il codice della funzione genera un'eccezione non rilevata o si arresta in modo anomalo un'istanza della funzione potrebbe essere riavviata. Ciò può causare un aumento del con conseguente maggiore latenza, per cui consigliamo di rilevare le eccezioni e in altro modo per evitare l'interruzione della procedura corrente. Consulta Segnalazione di errori per una discussione su come gestire e segnalare gli errori nelle funzioni Cloud Run.
Se la funzione è sensibile alla latenza, valuta la possibilità di impostare una numero minimo di istanze evitare avvii a freddo.
Durata di un'istanza di funzione
Le istanze di funzione sono in genere resilienti e riutilizzate dalla funzione successiva di chiamate, a meno che non venga fatto lo scale down del numero di istanze per mancanza traffico in corso o la funzione si arresta in modo anomalo. Ciò significa che al termine dell'esecuzione di una funzione, l'invocazione di un'altra funzione può essere gestita dalla stessa istanza della funzione.
Ambito della funzione e ambito globale
Una singola chiamata di funzione comporta l'esecuzione solo del corpo della funzione dichiarata come punto di ingresso. L'ambito globale dell'origine della funzione il codice viene eseguito solo sugli avvii a freddo e non sulle istanze che sono già stati inizializzati.
Node.js
Python
Vai
Java
Ruby
Puoi usare le variabili globali per l'ottimizzazione del rendimento, ma non devi si basa sullo stato impostato nell'ambito globale dalle chiamate di funzione precedenti: Per ulteriori informazioni, consulta la sezione Stateless.
Si può presumere che per ogni istanza di funzione, l'ambito globale sia stato eseguito esattamente una volta prima di richiamare il codice della funzione. Tuttavia, devi non dipendono dal numero totale o dalla tempistica delle esecuzioni in ambito globale, potrebbe variare in base all'attività di scalabilità automatica.
Cronologia di esecuzione della funzione
Una funzione ha accesso alle risorse allocate (memoria e CPU) solo per durata dell'esecuzione della funzione. Il codice eseguito al di fuori del periodo di esecuzione non è l'esecuzione è garantita e può essere arrestata in qualsiasi momento. Pertanto, devi segnala sempre correttamente la fine dell'esecuzione della funzione ed evita di eseguirla qualsiasi codice al di fuori. Per indicazioni, consulta Funzioni HTTP, Funzioni in background e Funzioni CloudEvent.
L'esecuzione della funzione è inoltre soggetta alla sua durata di timeout. Per ulteriori informazioni, consulta Timeout della funzione.
Tieni conto delle tempistiche di esecuzione durante l'inizializzazione dell'applicazione. Le attività in background non devono essere create a livello 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, Le funzioni Cloud Run non garantiscono 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 tua funzione può essere richiamata per un singolo evento dipende dal tipo di funzione:
Le funzioni HTTP vengono richiamate al massimo una volta. Questo accade a causa della natura sincrona delle chiamate HTTP e significa che qualsiasi errore che si verifica durante l'invocazione della funzione verrà restituito senza alcun nuovo tentativo. 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 natura asincrona degli eventi, in cui nessun chiamante attende per la risposta. In rare circostanze, il sistema potrebbe invocare una funzione basata su eventi più di una volta per garantire l'invio dell'evento. Se la chiamata di una funzione basata su eventi ha esito negativo e restituisce un errore, la funzione non essere richiamati di nuovo a meno che tentativi in caso di errore sono abilitati per quella funzione.
Per assicurarti che la funzione comporti correttamente i nuovi tentativi di esecuzione, dovresti renderla idempotente implementandola in modo che vengano restituiti (ed effetti collaterali) vengono generati 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 le chiamate all'endpoint della funzione HTTP. Per ulteriori informazioni su come rendere idempotente la funzione, consulta Nuovo tentativo per le funzioni basate su eventi.
Memoria e file system
A ogni funzione è allocata una certa quantità di memoria per l'utilizzo. Puoi per configurare la quantità di memoria al momento del deployment, Limiti di memoria per ulteriori informazioni.
L'ambiente di esecuzione della funzione include un file system in memoria che contiene i file e le directory di origine di cui è stato eseguito il deployment con la funzione (vedi 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 dell'utilizzo della memoria di una funzione.
La tua funzione può interagire con il file system utilizzando metodi standard in ogni linguaggio di programmazione.
Rete
La funzione può accedere a internet pubblico utilizzando metodi standard in ogni linguaggio di programmazione, tramite le librerie integrate offerte dal runtime o le librerie di terze parti incluse come dipendenze.
Prova a riutilizzare le connessioni di rete nelle chiamate di funzione, descritta in Ottimizzazione del networking. Tuttavia, tieni presente che una connessione che rimane inutilizzata per 10 minuti potrebbe verrà chiuso dal sistema e ulteriori tentativi di utilizzare una connessione chiusa comportano la "reimpostazione della connessione" . Il codice deve utilizzare una libreria che gestisca bene le connessioni chiuse o che le gestisca esplicitamente costrutti di networking di basso livello.
Isolamento delle funzioni
Ogni funzione di cui è stato eseguito il deployment è isolata da tutte le altre funzioni, comprese 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 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 a un argomento Pub/Sub per attivare un Pub/Sub personalizzata.