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 inclut des sujets avancés pour vous aider à 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 œuvre quelque chose, cela aide pour comprendre les contraintes des systèmes qui composent Firestore afin que votre application sans serveur évolue et fonctionne 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 proche 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 l'emplacement physique d'un utilisateur et Firestore l'emplacement de la base de données a une incidence sur la latence observée 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 l'application sur l'appareil de l'utilisateur ne peut pas se connecter à Firestore, elle reste utilisable en travaillant avec des données mises en cache localement. Cela garantit que les données même lorsque les utilisateurs ont des connexions Internet instables ou 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 s'occupent 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 un emplacement régional ou multirégional

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 modifications de la base de données et vous recevez des notifications à faible latence dès que les données des modifications. 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 des exemples de configuration et d'utilisation de requêtes en temps réel, consultez Obtenez des informations en temps réel. Les sections suivantes expliquent le fonctionnement des écouteurs d'instantanés et décrivent certaines bonnes pratiques pour faire évoluer les requêtes en temps réel tout en conservant 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ée 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 schéma suivant illustre l'architecture derrière un écouteur d'instantanés:

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

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

  1. Le client B ouvre une connexion à Firestore et enregistre un écouteur 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 amorcer l'ensemble de données. Elle charge l'ensemble des résultats documents. C'est ce que nous appelons une requête d'interrogation. Le système qui évalue la capacité de la base de données Règles de sécurité Firebase 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 avec un gestionnaire d'abonnement et attend les mises à jour des données.
  4. Le client A envoie maintenant 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 changelog. 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 inverse 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és 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. Lorsqu'une correspondance est trouvée, 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 nombreuses instances répliquées dans plusieurs zones (ou plusieurs régions dans le cas d'un emplacement déploiement), 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 les garanties de cohérence. Cela s'applique également aux écouteurs en temps réel, aux appels permettant de récupérer un document et aux requêtes ponctuelles. Vous pouvez considérer les récupérations de documents uniques et les requêtes ponctuelles comme des écouteurs d'instantanés de courte durée qui présentent des 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 génèrent les requêtes en temps réel se mettent automatiquement à l'échelle horizontalement à mesure que le trafic d'écriture augmente. Comme 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 de la requête commence consommer les données de plusieurs gestionnaires d'abonnement au lieu d'un seul. Depuis l' du point de vue du client et du SDK, tout est transparent, et aucune action n'est requise. de l'application en cas de fractionnement. Le schéma suivant montre comment des requêtes en temps réel:

Architecture du fan-out du journal des 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 un outil utile pour analyser les points chauds 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, gardez à l'esprit d'où provient votre trafic d'écriture.

Comprendre comment les écritures et les lectures interagissent

Vous pouvez considérer le système de requêtes en temps réel comme un pipeline reliant les opérations d'écriture aux lecteurs. Chaque fois qu'un document est créé, mis à jour ou supprimé, la modification se propage du système de stockage aux écouteurs actuellement enregistrés. 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 voir à la fois des opérations d'écriture lentes et des réponses lentes corrélées. 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 souhaitez généralement que les utilisateurs sachent rapidement que les données ont changé. 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 de validation et d'écriture courtes et rapides pour maintenir une latence faible. Les lots volumineux peuvent vous donner un débit plus élevé du point de vue du rédacteur. mais peut 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 bas possible.

Toutefois, certains schémas peuvent entraîner un comportement non optimal pour les instantanés pour les auditeurs. 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. Connexion... sur 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 revient à réfléchir aux requêtes de performances dans une base de données relationnelle qui nécessitent une analyse complète de la table. Dans une base de données relationnelle, une requête qui nécessite un balayage complet de la table équivaut à un écouteur d'instantané qui surveille une collection à forte rotation. 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 index plus spécifique s'apparente à un écouteur d'instantanés qui surveille une document unique ou une collection qui change moins souvent. Vous devez tester la charge de votre application pour mieux comprendre le comportement et les besoins de votre cas d'utilisation.

Accélérez les requêtes de sondage

Un autre élément clé des requêtes réactives en temps réel consiste à s'assurer que d'interrogation pour amorcer 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. Les requêtes lentes réduisent la réactivité de votre application. 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 fait automatiquement et est transparent pour SDK et votre application. Les conditions suivantes peuvent déclencher un état d'interrogation:

  • Le système rééquilibre un journal des modifications en raison de modifications 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 d'interrogation sont suffisamment rapides, l'état d'interrogation devient transparent. aux 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, les documents renvoyés à votre application vous sont facturés et non pour maintenir une connexion ouverte. Un écouteur d'instantané de longue durée ne lit que les données dont il a besoin pour diffuser 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 transmet de nombreux documents par seconde via une connexion pendant une longue période, il peut il est préférable d'opter pour des requêtes ponctuelles exécutées à une fréquence plus faible.

Étape suivante