Best practice

Utilizza le best practice elencate qui come riferimento rapido quando crei un'applicazione che utilizza Firestore.

Località del database

Quando crei l'istanza di database, seleziona la posizione del database più vicina agli utenti e alle risorse di calcolo. I hop di rete di ampio raggio sono più soggetti a errori e aumentano la latenza delle query.

Per massimizzare la disponibilità e la durabilità della tua applicazione, seleziona una posizione in più regioni e posiziona le risorse di calcolo critiche in almeno due regioni.

Seleziona una località a livello di regione per ridurre i costi, per una minore latenza di scrittura se la tua applicazione è sensibile alla latenza o per la colocazione con altre risorse Google Cloud.

ID documento

• Evita gli ID documento . e ...
• Evita di utilizzare barre oblique / negli ID documento.

• Non utilizzare ID documento in aumento monotonico, ad esempio:

  • Customer1, Customer2, Customer3, ...
  • Product 1, Product 2, Product 3, ...

  Questi ID sequenziali possono generare hotspot che influiscono sulla latenza.

Nomi dei campi

• Evita i seguenti caratteri nei nomi dei campi perché richiedono un'interpretazione letterale aggiuntiva:

  • . punto
  • [ parentesi quadra aperta
  • ] parentesi quadra chiusa
  • * asterisco
  • ` accento grave

Indici

Riduci la latenza di scrittura

Il fattore principale che contribuisce alla latenza di scrittura è il fanout dell'indice. Le best practice per ridurre il fanout dell'indice sono:

• Imposta le esenzioni dell'indice a livello di raccolta. Un'impostazione predefinita semplice è disattivare l'ordinamento decrescente e l'indice array. La rimozione dei valori indicizzati non utilizzati riduce anche i costi di archiviazione.

• Riduci il numero di documenti in una transazione. Per scrivere un numero elevato di documenti, valuta la possibilità di utilizzare uno scrittore collettivo anziché lo scrittore batch atomico.

Esenzioni dall'indice

Per la maggior parte delle app, puoi fare affidamento sull'indicizzazione automatica e su eventuali link ai messaggi di errore per gestire gli indici. Tuttavia, ti consigliamo di aggiungere esenzioni per un singolo campo nei seguenti casi:

Operazioni di lettura e scrittura

• La frequenza massima esatta con cui un'app può aggiornare un singolo documento dipende molto dal carico di lavoro. Per saperne di più, consulta Aggiornamenti a un singolo documento.

• Utilizza chiamate asincrone, se disponibili, anziché chiamate sincrone. Le chiamate asincrone riducono al minimo l'impatto della latenza. Ad esempio, considera un'applicazione che ha bisogno del risultato di una ricerca di documenti e dei risultati di una query prima di visualizzare una risposta. Se la ricerca e la query non hanno una dipendenza dai dati, non è necessario attendere in modo sincrono il completamento della ricerca prima di iniziare la query.

• Non utilizzare gli offset. Utilizza invece i cursor. L'utilizzo di un offset evita solo di restituire i documenti saltati alla tua applicazione, ma questi documenti vengono comunque recuperati internamente. I documenti ignorati influiscono sulla latenza della query e alla tua applicazione vengono addebitate le operazioni di lettura necessarie per recuperarli.

Nuovi tentativi di transazione

Gli SDK e le librerie client di Firestore riprovano automaticamente le transazioni non riuscite per gestire gli errori temporanei. Se la tua applicazione accede a Firestore tramite le API REST o RPC direttamente anziché tramite un SDK, deve implementare i tentativi di transazione per aumentare l'affidabilità.

Aggiornamenti in tempo reale

Per le best practice relative agli aggiornamenti in tempo reale, consulta Informazioni sulle query in tempo reale su larga scala.

Progettazione per la scalabilità

Le best practice riportate di seguito descrivono come evitare situazioni che possono creare problemi di contesa.

Aggiornamenti a un singolo documento

Durante la progettazione dell'app, valuta la velocità con cui l'app aggiorna i singoli documenti. Il modo migliore per caratterizzare le prestazioni del carico di lavoro è eseguire test di carico. La frequenza massima esatta con cui un'app può aggiornare un singolo documento dipende molto dal carico di lavoro. I fattori includono la frequenza di scrittura, la concorrenza tra le richieste e il numero di indici interessati.

Un'operazione di scrittura del documento aggiorna il documento e gli eventuali indici associati e Firestore applica l'operazione di scrittura in modo sincrono a un quorum di repliche. A frequenze di scrittura sufficientemente elevate, il database inizierà a riscontrare contese, latenze più elevate o altri errori.

Alte frequenze di lettura, scrittura ed eliminazione in un intervallo ristretto di documenti

Evita frequenze di lettura o scrittura elevate per chiudere i documenti in ordine alfabetico, altrimenti la tua applicazione riscontrerà errori di contesa. Questo problema è noto come hotspotting e la tua applicazione può verificarlo se esegue una delle seguenti operazioni:

• Crea nuovi documenti a una velocità molto elevata e assegna i propri ID in aumento in modo monotonico.

  Firestore assegna gli ID documento utilizzando un algoritmo di dispersione. Non dovresti riscontrare hotspot sulle scritture se crei nuovi documenti utilizzando ID documento automatici.

• Crea nuovi documenti a una frequenza elevata in una raccolta con pochi documenti.

• Crea nuovi documenti con un campo in aumento monotono, ad esempio un timestamp, a una frequenza molto elevata.

• Elimina i documenti di una raccolta a una frequenza elevata.

• Scrive nel database a una velocità molto elevata senza aumentare gradualmente il traffico.

Evitare di saltare i dati eliminati

Evita query che ignorano i dati eliminati di recente. Una query potrebbe dover saltare un numero elevato di voci dell'indice se i risultati iniziali della query sono stati eliminati di recente.

Un esempio di carico di lavoro che potrebbe dover saltare molti dati eliminati è quello che tenta di trovare gli elementi di lavoro in coda più vecchi. La query potrebbe avere il seguente aspetto:

docs = db.collection('WorkItems').order_by('created').limit(100)
delete_batch = db.batch()
for doc in docs.stream():
  finish_work(doc)
  delete_batch.delete(doc.reference)
delete_batch.commit()

Ogni volta che viene eseguita questa query, vengono analizzate le voci dell'indice per il campo created in tutti i documenti eliminati di recente. Ciò rallenta le query.

Per migliorare il rendimento, utilizza il metodo start_at per trovare il punto di partenza migliore. Ad esempio:

completed_items = db.collection('CompletionStats').document('all stats').get()
docs = db.collection('WorkItems').start_at(
    {'created': completed_items.get('last_completed')}).order_by(
        'created').limit(100)
delete_batch = db.batch()
last_completed = None
for doc in docs.stream():
  finish_work(doc)
  delete_batch.delete(doc.reference)
  last_completed = doc.get('created')

if last_completed:
  delete_batch.update(completed_items.reference,
                      {'last_completed': last_completed})
  delete_batch.commit()

NOTA: l'esempio riportato sopra utilizza un campo con valori in aumento monotonico, che è un anti-pattern per frequenze di scrittura elevate.

Aumento del traffico

Devi aumentare gradualmente il traffico verso le nuove raccolte o i documenti chiusi in ordine alfabetico per dare a Firestore il tempo sufficiente per preparare i documenti all'aumento del traffico. Ti consigliamo di iniziare con un massimo di 500 operazioni al secondo per una nuova raccolta e di aumentare il traffico del 50% ogni 5 minuti. Analogamente, puoi aumentare il traffico di scrittura, ma tieni presente i limiti standard di Firestore. Assicurati che le operazioni siano distribuite in modo relativamente uniforme nell'intervallo di chiavi. Questa è chiamata regola "500/50/5".

Migrazione del traffico a una nuova raccolta

L'aumento graduale è particolarmente importante se esegui la migrazione del traffico delle app da una raccolta all'altra. Un modo semplice per gestire questa migrazione è leggere dalla vecchia raccolta e, se il documento non esiste, dalla nuova raccolta. Tuttavia, ciò potrebbe causare un improvviso aumento del traffico verso i documenti correlati in modo lessicografico nella nuova raccolta. Firestore potrebbe non essere in grado di preparare in modo efficiente la nuova raccolta per l'aumento del traffico, soprattutto se contiene pochi documenti.

Un problema simile può verificarsi se modifichi gli ID di molti documenti all'interno della stessa raccolta.

La strategia migliore per eseguire la migrazione del traffico a una nuova raccolta dipende dal tuo modello di dati. Di seguito è riportata una strategia di esempio nota come letture parallele. Dovrai determinare se questa strategia è efficace per i tuoi dati e un aspetto importante da considerare sarà l'impatto sui costi delle operazioni parallele durante la migrazione.

Letture parallele

Per implementare le letture parallele durante la migrazione del traffico a una nuova raccolta, leggi prima dalla vecchia raccolta. Se il documento non è presente, leggi dalla nuova raccolta. Un tasso elevato di letture di documenti inesistenti può portare a hotspot, quindi assicurati di aumentare gradualmente il carico sulla nuova raccolta. Una strategia migliore è copiare il vecchio documento nella nuova raccolta e poi eliminarlo. Aumenta gradualmente le letture parallele per assicurarti che Firestore possa gestire il traffico verso la nuova raccolta.

Una possibile strategia per aumentare gradualmente le letture o le scritture in una nuova raccolta consiste nell'utilizzare un hash deterministico dell'ID utente per selezionare una percentuale casuale di utenti che tentano di scrivere nuovi documenti. Assicurati che il risultato dell'hash dell'ID utente non sia distorto dalla tua funzione o dal comportamento dell'utente.

Nel frattempo, esegui un job batch che copia tutti i dati dai vecchi documenti alla nuova raccolta. Il job batch deve evitare le scritture in ID documento sequenziali per evitare hotspot. Al termine del job batch, puoi leggere solo dalla nuova raccolta.

Un perfezionamento di questa strategia consiste nel eseguire la migrazione di piccoli batch di utenti alla volta. Aggiungi al documento dell'utente un campo che monitori lo stato della migrazione dell'utente. Seleziona un batch di utenti di cui eseguire la migrazione in base a un hash dell'ID utente. Utilizza un job batch per eseguire la migrazione dei documenti per quel batch di utenti e le letture parallele per gli utenti nel mezzo della migrazione.

Tieni presente che non puoi eseguire facilmente il rollback a meno che non esegui scritture doppie sia delle entità vecchie che di quelle nuove durante la fase di migrazione. Ciò aumenterebbe i costi di Firestore sostenuti.

Privacy

• Evita di archiviare informazioni sensibili in un ID progetto Cloud. Un ID progetto Cloud potrebbe essere conservato oltre la durata del progetto.
• Come best practice per la conformità dei dati, ti consigliamo di non memorizzare informazioni sensibili nei nomi dei documenti e dei campi dei documenti.