Suggerimenti e trucchi

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

Correttezza

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

Scrivere funzioni idempotenti

Le funzioni devono produrre lo stesso risultato anche se vengono chiamate più volte. In questo modo, puoi riprovare una chiamata se quella precedente non riesce a metà del tuo codice. Per ulteriori informazioni, consulta Riprovare le funzioni basate su eventi.

Non avviare attività in background

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

Inoltre, quando viene eseguita un'invocazione successiva nello stesso ambiente, la tua attività in background riprende, interferendo con la nuova invocazione. Ciò può portare a comportamenti imprevisti ed errori difficili da diagnosticare. L'accesso alla rete al termine di una funzione di solito comporta la reimpostazione delle connessioni (codice di errore ECONNRESET).

Spesso l'attività in background può essere rilevata nei log delle singole invocazioni, trovandovi tutto ciò che viene registrato dopo la riga che indica il termine dell'invocazione. A volte l'attività in background 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 rimangono tra le chiamate. Se non elimini esplicitamente questi file, potresti incorrere in un errore di esaurimento della memoria e in un successivo avvio a freddo.

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

Non tentare di scrivere all'esterno della directory temporanea e assicurati di utilizzare metodi indipendenti dalla piattaforma/dal sistema operativo per creare i percorsi dei file.

Puoi ridurre i requisiti di memoria quando elabori file di dimensioni maggiori utilizzando la pipeline. Ad esempio, puoi elaborare un file su Cloud Storage creando uno stream di lettura, facendolo passare attraverso un processo basato su stream e scrivendo lo stream di output direttamente su Cloud Storage.

Framework di Functions

Quando esegui il deployment di una funzione, il framework Functions viene aggiunto automaticamente come dipendenza utilizzando la versione corrente. Per assicurarti che le stesse dipendenze siano installate in modo coerente in diversi ambienti, ti consigliamo di bloccare la funzione a una versione specifica del framework di Functions.

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

Strumenti

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

Sviluppo locale

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

Utilizza Sendgrid per inviare email

Cloud Functions non consente connessioni in uscita sulla porta 25, pertanto non puoi effettuare connessioni non sicure a un server SMTP. Il modo consigliato per inviare email è utilizzare SendGrid. Puoi trovare altre opzioni per l'invio di email nel tutorial Invio di email da un'istanza per Google Compute Engine.

Prestazioni

Questa sezione descrive le best practice per ottimizzare il rendimento.

Usa le dipendenze con oculatezza

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

Se le 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 eseguire il deployment della funzione, caricando correttamente le dipendenze e non caricando quelle che la funzione non utilizza.

Utilizza le variabili globali per riutilizzare gli oggetti nelle chiamate future

Non vi è alcuna garanzia che lo stato di una funzione venga conservato per le chiamate future. Tuttavia, Cloud Functions spesso ricicla l'ambiente di esecuzione di un'invocazione precedente. Se dichiari una variabile in ambito globale, il suo valore può essere riutilizzato nelle chiamate successive senza dover essere ricalcolato.

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

console.log('Global scope');
const perInstance = heavyComputation();
const functions = require('firebase-functions');

exports.function = functions.https.onRequest((req, res) => {
  console.log('Function invocation');
  const perFunction = lightweightComputation();

  res.send(`Per instance: ${perInstance}, per function: ${perFunction}`);
});

import time

from firebase_functions import https_fn

# 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()

@https_fn.on_request()
def scope_demo(request):

  # Per-function scope
  # This computation runs every time this function is called
  function_var = light_computation()
  return https_fn.Response(f"Instance: {instance_var}; function: {function_var}")
  

È particolarmente importante memorizzare nella cache le connessioni di rete, i riferimenti alle librerie e gli oggetti client dell'API a livello globale. Per esempi, consulta Ottimizzazione della rete.

Esegui l'inizializzazione lazy delle variabili globali

Se inizili le variabili a livello globale, il codice di inizializzazione verrà sempre eseguito tramite un'invocazione a freddo, aumentando la latenza della funzione. In alcuni casi, questo causa timeout intermittenti per i servizi chiamati se non vengono gestiti correttamente in un blocco try/catch. Se alcuni oggetti non vengono utilizzati in tutti i percorsi di codice, valuta la possibilità di inizializzarli in modo lento on demand:

const functions = require('firebase-functions');
let myCostlyVariable;

exports.function = functions.https.onRequest((req, res) => {
  doUsualWork();
  if(unlikelyCondition()){
      myCostlyVariable = myCostlyVariable || buildCostlyVariable();
  }
  res.status(200).send('OK');
});

from firebase_functions import https_fn

# 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

@https_fn.on_request()
def lazy_globals(request):

  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 https_fn.Response(f"Lazy: {lazy_global}, non-lazy: {non_lazy_global}.")
  

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

Riduci gli avvii a freddo impostando un numero minimo di istanze

Per impostazione predefinita, Cloud Functions scala il numero di istanze in base al numero di richieste in entrata. Puoi modificare questo comportamento predefinito impostando un numero minimo di istanze che Cloud Functions deve mantenere pronte per gestire le richieste. L'impostazione di un numero minimo di istanze riduce gli avvii a freddo dell'applicazione. Ti consigliamo di impostare un numero minimo di istanze se la tua applicazione è sensibile alla latenza.

Risorse aggiuntive

Scopri di più sull'ottimizzazione delle prestazioni nel video "Google Cloud Performance Atlas" Cloud Functions tempo di avvio a freddo.