Comprendre les requêtes en temps réel à grande échelle

Lisez ce document pour obtenir des conseils sur le scaling de votre application sans serveur au-delà de milliers d'opérations par seconde ou des centaines de milliers d'utilisateurs simultanés. Ce document aborde des sujets avancés à comprendre le système en profondeur. Si vous débutez avec Firestore, consultez plutôt le guide de démarrage rapide.

Firestore et les SDK mobiles/Web Firebase constituent un modèle puissant pour développer des applications sans serveur où le code côté client accède directement base de données. Les SDK permettent aux clients d'écouter les mises à jour des données en temps réel. Toi peuvent utiliser des mises à jour en temps réel pour créer des applications réactives qui ne nécessitent pas de serveurs de l'infrastructure. Bien qu'il soit très facile de mettre en place une application, il est utile de comprendre les contraintes des systèmes qui constituent Firestore afin que votre application sans serveur puisse évoluer et fonctionner correctement lorsque le trafic augmente.

Consultez les sections suivantes pour obtenir des conseils sur le scaling de votre application.

Choisir un emplacement de base de données à proximité de vos utilisateurs

Le schéma suivant illustre l'architecture d'une application en temps réel :

Exemple d'architecture d'application en temps réel

Lorsqu'une application exécutée sur l'appareil d'un utilisateur (mobile ou Web) établit une connexion à Firestore, la connexion est acheminée vers serveur frontend Firestore dans le même région où se trouve votre base de données. Par exemple : Si votre base de données se trouve dans us-east1, la connexion est également acheminée vers Interface Firestore également dans us-east1. Ces connexions sont et restent ouverts jusqu'à ce qu'ils soient explicitement fermés par l'application. La lit les données des systèmes de stockage Firestore sous-jacents.

La distance entre la position physique d'un utilisateur et l'emplacement de la base de données Firestore affecte la latence ressentie par l'utilisateur. Par exemple, un utilisateur en Inde dont l'application communique avec une base de données dans une région Google Cloud en Amérique du Nord peut trouver l'expérience plus lente et l'application moins réactive que si la base de données était située plus près, par exemple en Inde ou dans une autre partie de l'Asie.

Concevoir des solutions fiables

Les sujets suivants améliorent ou affectent la fiabilité de votre application :

Activer le mode hors connexion

Les SDK Firebase assurent la persistance des données hors connexion. Si le l'application sur l'appareil de l'utilisateur ne peut pas se connecter à Firestore, l'application reste utilisable en travaillant avec des données mises en cache localement. Cela garantit l'accès aux données, même lorsque les utilisateurs rencontrent des connexions Internet irrégulières ou perdent complètement l'accès pendant plusieurs heures ou jours. Pour en savoir plus sur mode hors connexion, consultez la section Activer les données hors connexion.

Comprendre les nouvelles tentatives automatiques

Les SDK Firebase se chargent de relancer les opérations et de rétablir les connexions interrompues. Cela permet de contourner les erreurs temporaires causées par le redémarrage des serveurs ou les problèmes de réseau entre le client et la base de données.

Choisir entre des emplacements régionaux et multirégionaux

Il y a plusieurs compromis au moment de choisir entre une région et multirégionaux. La principale différence réside dans la façon dont les données sont répliquées. Ce garantit les garanties de disponibilité de votre application. Une instance multirégionale permet d'accroître la fiabilité de diffusion et la durabilité de vos données. le compromis est le coût.

Comprendre le système de requêtes en temps réel

Les requêtes en temps réel, également appelées écouteurs d'instantanés, permettent à l'application d'écouter les modifications apportées à la base de données et de recevoir des notifications à faible latence dès que les données changent. Une application peut obtenir le même résultat en interrogeant périodiquement la base de données pour obtenir des mises à jour, mais cette méthode est souvent plus lente, plus coûteuse et nécessite plus de code. Pour obtenir des exemples de configuration et d'utilisation des requêtes en temps réel, consultez la section Obtenir des mises à jour en temps réel. Les sections suivantes le fonctionnement des écouteurs d'instantanés, pour faire évoluer les requêtes en temps réel tout en préservant les performances.

Imaginons deux utilisateurs qui se connectent à Firestore via une application de messagerie créée avec l'un des SDK mobiles.

Le client A écrit dans la base de données pour ajouter et mettre à jour des documents dans une collection. appelé chatroom:

collection chatroom:
    document message1:
      from: 'Sparky'
      message: 'Welcome to Firestore!'

    document message2:
      from: 'Santa'
      message: 'Presents are coming'

Le client B écoute les mises à jour dans la même collection à l'aide d'un écouteur d'instantanés. Le client B reçoit une notification immédiate chaque fois qu'un nouveau message est créé. Le diagramme suivant présente l'architecture d'un écouteur d'instantané :

Architecture d'une connexion d'écouteur d'instantanés

La séquence d'événements suivante se produit lorsque le client B connecte un écouteur d'instantané à la base de données :

  1. Le client B ouvre une connexion à Firestore et enregistre un en appelant onSnapshot(collection("chatroom")) via le SDK Firebase. Cet écouteur peut rester actif pendant des heures.
  2. L'interface Firestore interroge le système de stockage sous-jacent pour démarrer l'ensemble de données. Il charge l'ensemble complet des résultats des documents correspondants. Nous appelons cela une requête de sondage. Le système évalue ensuite les règles de sécurité Firebase de la base de données pour vérifier que l'utilisateur peut accéder à ces données. Si l'utilisateur est autorisé, renvoie les données à l'utilisateur.
  3. La requête du client B passe alors en mode écoute. L'écouteur s'enregistre auprès d'un gestionnaire d'abonnement et attend les mises à jour des données.
  4. Le client A envoie désormais une opération d'écriture pour modifier un document.
  5. La base de données valide la modification du document dans son système de stockage.
  6. Sur le plan transactionnel, le système valide la même mise à jour dans un journal de modifications interne. Le journal des modifications établit un ordre strict des modifications au fur et à mesure qu'elles se produisent.
  7. Le journal des modifications distribue ensuite les données mises à jour à un pool d'abonnements. et des gestionnaires de projet.
  8. Un outil de mise en correspondance des requêtes inversées s'exécute pour voir si le document mis à jour correspond les écouteurs d'instantanés actuellement enregistrés. Dans cet exemple, le document correspond à l'écouteur d'instantané du client B. Comme son nom l'indique, vous pouvez penser à l'outil de mise en correspondance des requêtes inverse comme une requête de base de données normale, mais dans l'inverse. Au lieu de parcourir les documents pour trouver ceux qui correspondent à une requête, il effectue une recherche efficace pour trouver celles qui correspondent à un document entrant. Après avoir trouvé une correspondance, le système transmet le document en question aux écouteurs d'instantanés. Le système évalue ensuite les règles de sécurité Firebase de la base de données. pour vous assurer que seuls les utilisateurs autorisés reçoivent les données.
  9. Le système transfère la mise à jour du document au SDK sur l'appareil du client B. le rappel onSnapshot se déclenche. Si la persistance locale est activée, le SDK applique également la mise à jour au cache local.

Un élément clé de l'évolutivité de Firestore dépend de la distribution ramifiée le journal des modifications vers les gestionnaires d'abonnement et les serveurs frontend. La diffusion permet à une seule modification de données de se propager efficacement pour répondre à des millions de requêtes en temps réel et d'utilisateurs connectés. En exécutant de nombreux réplicas de tous ces composants dans plusieurs zones (ou plusieurs régions en cas de déploiement multirégional), Firestore offre une haute disponibilité et une évolutivité.

Notez que toutes les opérations de lecture provenant des SDK mobiles et Web suivez le modèle ci-dessus. Ils effectuent une requête d'interrogation suivie du mode écoute. pour maintenir des garanties de cohérence. Cela s'applique également aux écouteurs en temps réel, pour récupérer un document requêtes ponctuelles. Vous pouvez penser à les récupérations de documents et les requêtes one-shot en tant qu'écouteurs d'instantanés à courte durée de vie s'accompagnent de contraintes similaires en termes de performances.

Appliquer les bonnes pratiques pour le scaling des requêtes en temps réel

Appliquez les bonnes pratiques suivantes pour concevoir des requêtes en temps réel évolutives.

Comprendre le trafic d'écriture élevé dans le système

Cette section vous aide à comprendre comment le système répond à un nombre croissant de requêtes d'écriture.

Les journaux de modifications Firestore qui pilotent les requêtes en temps réel automatiquement à mesure que le trafic d'écriture augmente. À mesure que le taux d'écriture d'une base de données dépasse ce qu'un seul serveur peut gérer, le journal des modifications est réparti sur plusieurs serveurs, et le traitement des requêtes commence à consommer des données de plusieurs gestionnaires d'abonnements au lieu d'un seul. Du point de vue du client et du SDK, tout cela est transparent et aucune action n'est requise de la part de l'application lors des fractionnements. Le diagramme suivant montre comment les requêtes en temps réel évoluent :

Architecture de la distribution ramifiée des journaux de modifications

L'autoscaling vous permet d'augmenter votre trafic d'écriture sans limite, mais à mesure que le trafic augmente, le système peut mettre un certain temps à répondre. Suivez les recommandations de la règle des 5-5-5 pour éviter de créer un point chaud d'écriture. Key Visualizer est utile pour analyser les zones cliquables d'écriture.

De nombreuses applications ont une croissance organique prévisible, ce que Firestore peut sans précautions. Les charges de travail par lot, comme l'importation d'un ensemble de données, il peut augmenter les écritures trop rapidement. Lorsque vous concevez votre application, de l'origine de votre trafic d'écriture.

Comprendre l'interaction entre les écritures et les lectures

Le système de requête en temps réel est un peu comme un pipeline avec les lecteurs. Chaque fois qu'un document est créé, mis à jour ou supprimé, la modification est propagée du système de stockage vers l'emplacement actuellement enregistré pour les auditeurs. La structure du journal de modifications de Firestore garantit la cohérence, ce qui signifie que votre application ne reçoit jamais de notifications mises à jour dans le désordre par rapport au moment où la base de données a validé les données des modifications. Cela simplifie le développement d'applications en supprimant concernant la cohérence des données.

Ce pipeline connecté signifie qu'une opération d'écriture entraîne des hotspots ou un conflit de verrouillage peuvent affecter négativement les opérations de lecture. Lorsque les opérations d'écriture échouent ou sont limitées, une lecture peut se bloquer en attendant des données cohérentes du journal des modifications. Si cela se produit dans votre application, vous pouvez constater à la fois des opérations d'écriture lentes et des temps de réponse lents corrélés pour les requêtes. Pour éviter ce problème, il est essentiel de réduire le nombre de points d'accès.

Limitez la taille des documents et des opérations d'écriture

Lorsque vous créez des applications avec des écouteurs d'instantanés, vous voulez généralement que les utilisateurs rapidement des changements de données. Pour ce faire, essayez de garder les choses simples. La peut transmettre à travers le système de petits documents contenant des dizaines de champs rapidement. Les documents volumineux comportant des centaines de champs et des données volumineuses prennent plus de temps à traiter.

De même, privilégiez les opérations d'écriture et de validation courtes et rapides pour réduire la latence. Les lots volumineux peuvent vous offrir un débit plus élevé du point de vue de l'auteur, mais ils peuvent en réalité augmenter le délai de notification pour les écouteurs d'instantanés. Cette méthode est souvent paradoxale par rapport à l'utilisation d'autres systèmes de base de données où vous pouvez utiliser le traitement par lot pour améliorer les performances.

Utiliser des écouteurs efficaces

À mesure que les taux d'écriture de votre base de données augmentent, Firestore répartit le traitement des données sur plusieurs serveurs. L'algorithme de partitionnement de Firestore tente de regrouper les données d'une même collection ou d'un même groupe de collections sur le même serveur de journal des modifications. La le système tente de maximiser le débit d'écriture possible tout en conservant le nombre de serveurs impliqués dans le traitement d'une requête le plus faible possible.

Toutefois, certains modèles peuvent toujours entraîner un comportement non optimal pour les écouteurs d'instantanés. Par exemple, si votre application stocke la plupart de ses données dans une grande collection, l'écouteur peut avoir besoin de se connecter à de nombreux serveurs pour recevoir toutes les données dont il a besoin. Cela reste vrai même si vous appliquez un filtre de requête. Se connecter à de nombreux serveurs augmente le risque de réponses plus lentes.

Pour éviter ces réponses plus lentes, concevez votre schéma et votre application de sorte que le système peuvent servir des écouteurs sans passer sur de nombreux serveurs différents. Il peut être préférable de diviser vos données en collections plus petites avec des taux d'écriture plus faibles.

Cela s'apparente à une réflexion sur les requêtes axées sur les performances dans une base de données relationnelle nécessitant des analyses complètes de table. Dans une relation de base de données, une requête nécessitant une analyse complète de la table équivaut à écouteur d'instantanés qui surveille une collection dont la perte d'utilisateurs est élevée. Son fonctionnement peut être lent par rapport à une requête que la base de données peut servir à l'aide d'un index plus spécifique. Une requête avec un indice plus spécifique est comme un écouteur d'instantané qui surveille un seul document ou une collection qui change moins souvent. Vous devez charger tester votre application pour mieux comprendre le comportement et les besoins de votre cas d'utilisation.

Maintenir la rapidité des requêtes d'attente active

Un autre élément clé des requêtes en temps réel responsives consiste à s'assurer que la requête de sondage pour démarrer les données est rapide et efficace. La première fois qu'un nouvel écouteur d'instantané se connecte, il doit charger l'ensemble de résultats complet et l'envoyer à l'appareil de l'utilisateur. Des requêtes lentes rendent votre application moins réactives. Cela inclut, par exemple, les requêtes qui tentent de lire de nombreux documents ou les requêtes qui n'utilisent pas les index appropriés.

Dans certains cas, un écouteur peut également passer d'un état d'écoute à un état de sondage. Cela se produit automatiquement et de manière transparente pour les SDK et votre application. Les conditions suivantes peuvent déclencher un état de sondage :

  • Le système rééquilibre un journal des modifications en raison de variations de la charge.
  • Les points d'accès entraînent des échecs ou des retards d'écriture dans la base de données.
  • Les redémarrages temporaires du serveur affectent temporairement les écouteurs.

Si vos requêtes de sondage sont suffisamment rapides, un état de sondage devient transparent pour les utilisateurs de votre application.

Privilégier les écouteurs durables

Ouvrir et maintenir les écouteurs en vie le plus longtemps possible est souvent le moyen le plus rentable de créer une application qui utilise Firestore. Lorsque vous utilisez Firestore, vous êtes facturé pour les documents renvoyés à votre application et non pour la maintenance d'une connexion ouverte. Un écouteur d'instantanés de longue durée lit uniquement les données dont il a besoin pour traiter la requête tout au long de sa durée de vie. Ce comprend une opération d'interrogation initiale, suivie de notifications lorsque les données change réellement. En revanche, les requêtes ponctuelles relisent les données qui n'ont peut-être pas changé depuis la dernière exécution de la requête par l'application.

Si votre application doit consommer un débit de données élevé, les écouteurs d'instantanés peuvent ne pas être adaptés. Par exemple, si votre cas d'utilisation envoie de nombreux documents par seconde via une connexion pendant une longue période, il peut être préférable d'opter pour des requêtes ponctuelles exécutées à une fréquence plus faible.

Étape suivante