Firestore : une plongée approfondie dans la base de données NoSQL de Firebase

Firestore, également connu sous le nom de Cloud Firestore, est la solution de base de données NoSQL de Google Firebase conçue pour fournir aux développeurs une plate-forme évolutive et polyvalente pour créer des applications Web et mobiles modernes. Firestore permet la synchronisation, le stockage et la récupération des données en temps réel tout en offrant des fonctionnalités puissantes, notamment une prise en charge hors ligne, une organisation hiérarchique des données et un ensemble complet de fonctionnalités de requête.

Firebase , une plate-forme de développement fournie par Google, propose une suite d'outils permettant de créer, gérer et déployer facilement des applications. Firestore fait partie de cette suite et agit comme une solution de base de données puissante et fiable qui simplifie le processus de persistance et de gestion des données dans les applications.

Avantages de Firestore

Firestore offre divers avantages aux développeurs, ce qui en fait un choix attractif pour gérer les données dans les applications Web et mobiles. Certains des avantages importants de Firestore incluent :

Synchronisation en temps réel

Les capacités de synchronisation en temps réel de Firestore permettent une transmission de données sans effort sur plusieurs appareils et plates-formes, garantissant que les mises à jour et modifications pertinentes sont instantanément reflétées pour tous les utilisateurs. Cette fonctionnalité de synchronisation aide les développeurs à créer des applications hautement interactives et collaboratives avec un minimum d'effort.

Assistance hors ligne

Firestore fournit une prise en charge hors ligne intégrée pour les applications Web et mobiles, permettant aux développeurs de créer des applications qui fonctionnent de manière transparente, même lorsque les utilisateurs ne sont pas connectés à Internet. Firestore met en cache les données localement sur les appareils et synchronise les mises à jour avec le serveur une fois la connexion restaurée.

Prise en charge complète des requêtes

Firestore propose une API de requête riche, permettant aux développeurs de créer des requêtes complexes qui filtrent, trient et manipulent facilement les données. Firestore prend également en charge la pagination basée sur le curseur, permettant aux applications de charger et d'afficher efficacement de grands ensembles de données.

Structure de données hiérarchique

Firestore utilise un modèle de données hiérarchique qui organise les données en collections et documents, s'adaptant à des structures de données complexes et imbriquées. Cette approche facilite la structuration et la gestion des données tout en offrant une grande flexibilité et évolutivité.

Forte évolutivité

Firestore est conçu pour une utilisation à grande échelle, gérant des millions de connexions simultanées et gérant de vastes ensembles de données sans compromettre les performances. Cette fonctionnalité fait de Firestore un choix viable pour les applications à fort trafic avec des exigences de performances exigeantes.

Modèle de données Firestore

Le modèle de données de Firestore est basé sur le concept de collections et de documents, qui assurent une organisation et une gestion hiérarchique des données. Cette section présentera les éléments clés du modèle de données de Firestore et expliquera leur fonctionnement.

Collections

Dans Firestore, les collections sont des conteneurs contenant des documents. Les collections aident à organiser les données de manière à faciliter leur interrogation et leur gestion. Les collections peuvent également contenir des sous-collections, permettant une subdivision plus poussée des regroupements logiques de données associées.

Documents

Les documents sont les enregistrements individuels dans Firestore qui contiennent les valeurs réelles des données. En général, les documents sont constitués de paires clé-valeur appelées champs, chacune avec un nom et une valeur correspondante. Firestore prend en charge différents types de données pour les champs, notamment les chaînes, les nombres, les booléens, les tableaux, les cartes, etc. Les documents dans Firestore peuvent être considérés comme des conteneurs pouvant contenir à la fois des données et des sous-collections. Cette structure imbriquée permet une plus grande flexibilité lors de la conception et de la gestion de structures de données complexes dans vos applications.

Source de l'image : Documentation Firebase

Organisation des données dans Firestore

Le modèle de données hiérarchique de Firestore permet aux développeurs de structurer et d'organiser leurs données de manière efficace et intuitive. Par exemple, une application de commerce électronique peut stocker ses données dans Firestore avec la structure suivante :

• Collection de produits
• Document produit
• Champ de nom
• Champ de prix
• Champ Catégorie
• Sous-collection d'avis
• Document de révision
• Champ de texte
• Champ de notation
• Champ Date

Dans cette structure, une collection Products contient des documents Product, chacun représentant un produit individuel. Ces documents contiennent des champs pour les informations sur le nom, le prix et la catégorie. Chaque document Produit possède une sous-collection Avis contenant des documents d'avis pour les avis sur les produits générés par les utilisateurs. En utilisant le modèle de données hiérarchique de Firestore, les développeurs peuvent créer et gérer facilement des structures de données complexes, garantissant ainsi que leurs applications restent performantes, évolutives et maintenables.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Configuration de Firestore dans vos applications

La configuration de Firestore dans vos applications est un processus simple. La première étape consiste à créer un projet Firebase, qui fournira un espace centralisé pour gérer tous les produits et services Firebase. Voici les étapes essentielles pour configurer Firestore :

1. Créer un projet Firebase : créez un compte Firebase, créez un nouveau projet ou utilisez-en un existant si vous en avez déjà un. Accédez à la console Firebase et suivez les instructions à l'écran.
2. Ajoutez Firestore à votre projet : Une fois votre projet configuré, cliquez sur la section « Base de données » dans le menu de gauche. Sélectionnez "Créer une base de données" et choisissez "Firestore" dans la fenêtre contextuelle. Suivez les options de configuration et créez une nouvelle instance de base de données Firestore dans votre projet Firebase.
3. Configurer le SDK Firebase : pour utiliser Firestore dans votre application Web ou mobile, vous devrez ajouter le SDK Firebase à votre projet. Vous pouvez trouver l'extrait de code de configuration du SDK dans la console Firebase sous « Paramètres du projet ». Le code de configuration comprendra la clé API unique de votre projet, le domaine d'authentification, l'ID du projet et d'autres paramètres requis pour se connecter aux services Firebase. Ajoutez l'extrait de code au projet HTML, JavaScript, Android ou iOS de votre application.
4. Initialiser Firestore : après avoir ajouté le SDK Firebase à votre projet, initialisez Firestore avec l'extrait de code suivant :
   Pour JavaScript :

    import { initializeApp } from 'firebase/app'; import { getFirestore } from 'firebase/firestore'; const firebaseApp = initializeApp({ apiKey: "[API_KEY]", authDomain: "[AUTH_DOMAIN]", projectId: "[PROJECT_ID]", ... }); const db = getFirestore(firebaseApp);

   Pour Android (Kotlin) :

    import com.google.firebase.FirebaseApp import com.google.firebase.firestore.FirebaseFirestore val firebaseApp = FirebaseApp.initializeApp(this) val db = FirebaseFirestore.getInstance()

   Pour iOS (Swift) :

    import FirebaseFirestore let db = Firestore.firestore()

5. Commencez à utiliser Firestore : une fois Firestore initialisé, vous pouvez désormais l'utiliser pour lire et écrire des données, configurer des écouteurs en temps réel et effectuer diverses opérations sur vos données.

Base de données en temps réel Firebase et Firestore

Firebase propose deux solutions de base de données : Firebase Realtime Database et Firestore. Bien que les deux bases de données offrent une synchronisation des données en temps réel et des SDK clients pour les plateformes Web et mobiles, elles diffèrent sur plusieurs aspects. Comparons les deux bases de données :

Modèle et structure de données

La base de données Firebase Realtime utilise un modèle de données de type JSON qui est une grande arborescence de nœuds. Ce modèle de données peut rendre difficile l'interrogation et la structuration de données complexes, en particulier pour les données hiérarchiques ou les tableaux imbriqués. Firestore, quant à lui, utilise un modèle de données hiérarchique avec des collections et des documents, offrant une manière plus intuitive de structurer et d'interroger les données. Le modèle de données Firestore permet des sous-collections imbriquées, ce qui peut aider à gérer plus efficacement les données complexes et imbriquées.

Capacités de requête

Firestore offre des fonctionnalités de requête plus complètes que la base de données en temps réel. Avec Firestore, les développeurs peuvent effectuer des requêtes complexes, telles que le chaînage de plusieurs clauses orderBy et Where, l'exécution d'opérations sur les tableaux et la pagination des résultats. En revanche, les capacités d'interrogation de la base de données en temps réel sont plus limitées, ce qui rend difficile l'exécution de requêtes ou de pagination complexes sans le coût de calcul supplémentaire et la complexité de la logique côté client ou côté serveur.

Évolutivité

Firestore est conçu pour les applications à l'échelle mondiale avec une forte évolutivité horizontale et la capacité de gérer des millions d'utilisateurs simultanés et des milliards de documents. La base de données en temps réel, bien qu'elle soit plus adaptée à certains cas, peut avoir du mal à évoluer sans recourir à des stratégies de partage de données. Firestore garantit un accès à faible latence et une réplication multirégionale automatique pour maintenir une disponibilité et une durabilité élevées, ce qui le rend adapté aux cas d'utilisation en entreprise et à fort trafic.

Tarifs

Les structures tarifaires de Firestore et de Realtime Database sont différentes. Les frais Firestore sont basés sur les lectures, écritures et suppressions de documents, ainsi que sur le stockage des données et l'utilisation du réseau. Les frais de base de données en temps réel sont basés sur la quantité de données stockées, le nombre de connexions à la base de données et l'utilisation du réseau. En fonction des modèles d'accès aux données et de l'utilisation de votre application, une seule base de données peut s'avérer plus rentable.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Alors que Firestore et Realtime Database offrent des capacités de synchronisation des données en temps réel, Firestore est plus adapté aux applications nécessitant des requêtes complexes, des structures de données hiérarchiques et des performances à l'échelle mondiale. La base de données en temps réel peut être plus adaptée aux cas d'utilisation plus simples, dans lesquels le modèle de données de type JSON et la structure tarifaire à moindre coût sont plus logiques.

Interroger des données dans Firestore

Firestore fournit un ensemble complet de fonctionnalités de requête, permettant aux développeurs de récupérer et de filtrer efficacement les données. Les requêtes de base incluent la récupération d'un seul document, la récupération d'une collection de documents et le filtrage des documents en fonction des valeurs de champ. Les requêtes plus avancées impliquent le tri, la limitation et la pagination des résultats. Explorons quelques requêtes Firestore courantes :

Récupérer un seul document

Pour récupérer un seul document par son identifiant, vous pouvez utiliser les extraits de code suivants :

 // JavaScript import { getDoc, doc } from 'firebase/firestore'; async function getDocument(documentId) { const documentRef = doc(db, 'collection_name', documentId); const documentSnapshot = await getDoc(documentRef); if (documentSnapshot.exists()) { console.log('Document data:', documentSnapshot.data()); } else { console.log('No such document'); } }

Récupérer une collection de documents

Pour récupérer tous les documents d'une collection, utilisez les extraits de code suivants :

 // JavaScript import { getDocs, collection } from 'firebase/firestore'; async function getAllDocuments() { const collectionRef = collection(db, 'collection_name'); const querySnapshot = await getDocs(collectionRef); querySnapshot.forEach((doc) => { console.log(doc.id, '=>', doc.data()); }); }

Filtrage des documents

Firestore vous permet de filtrer les documents en fonction d'une ou plusieurs conditions de champ. Les extraits de code suivants montrent comment filtrer les documents en fonction d'un seul champ :

 // JavaScript import { query, where, getDocs, collection } from 'firebase/firestore'; async function getFilteredDocuments() { const collectionRef = collection(db, 'collection_name'); const q = query(collectionRef, where('field_name', '==', 'value')); const querySnapshot = await getDocs(q); querySnapshot.forEach((doc) => { console.log(doc.id, '=>', doc.data()); }); }

Tri et pagination des documents

Pour trier et paginer les résultats, vous pouvez utiliser les méthodes orderBy, limit et startAfter ou startAt. Voici comment trier et paginer des documents :

 // JavaScript import { query, orderBy, limit, getDocs, collection, startAfter } from 'firebase/firestore'; async function getSortedAndPaginatedDocuments(lastVisible) { const collectionRef = collection(db, 'collection_name'); const q = query( collectionRef, orderBy('field_name', 'asc'), startAfter(lastVisible), limit(10) ); const querySnapshot = await getDocs(q); querySnapshot.forEach((doc) => { console.log(doc.id, '=>', doc.data()); }); }

Ce ne sont là que quelques exemples des capacités de requête que Firestore offre aux développeurs, facilitant ainsi l'accès et le filtrage des données selon les besoins de diverses applications.

Règles de sécurité Firestore

Les règles de sécurité Firestore constituent un moyen puissant de contrôler l'accès à vos données Firestore, en fonction de l'authentification des utilisateurs et de conditions personnalisées. En écrivant et en configurant des règles de sécurité, vous pouvez garantir que les utilisateurs ont uniquement accès aux ressources dont ils ont besoin, protégeant ainsi les informations sensibles et empêchant toute modification involontaire des données.

Les règles de sécurité dans Firestore sont stockées dans la console Firebase et déployées avec votre base de données Firestore. Ils utilisent une syntaxe personnalisée et peuvent être écrits et testés à partir de la console Firebase ou à l'aide d'un environnement de développement local. Pour démarrer avec les règles de sécurité Firestore, examinons quelques scénarios courants et comment les mettre en œuvre :

1. Autoriser l'accès en lecture aux données publiques : pour permettre à n'importe quel utilisateur de lire des données publiques, vous pouvez configurer une règle de sécurité qui accorde l'accès à une collection spécifique sans nécessiter d'authentification. rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /public_data/{document=**} { allow read; } } }
2. Restreindre l'accès en lecture aux utilisateurs authentifiés : Si vous souhaitez vous assurer que seuls les utilisateurs authentifiés peuvent lire certains documents, vous pouvez utiliser l'objet request.auth pour vérifier le statut d'authentification de l'utilisateur. rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /private_data/{document=**} { allow read: if request.auth != null; } } }
3. Autoriser l'accès en écriture aux données appartenant à l'utilisateur : pour accorder aux utilisateurs la possibilité de créer, mettre à jour ou supprimer leurs données, vous pouvez utiliser des règles de sécurité qui font correspondre l'ID utilisateur du document avec l'ID de l'utilisateur authentifié. rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /user_data/{userId}/{document=**} { allow write: if request.auth.uid == userId; } } }
4. Validation des données avant l'écriture : les règles de sécurité Firestore peuvent également appliquer la validation des données avant d'autoriser les opérations d'écriture. Par exemple, vous pouvez vous assurer que le nom d'affichage d'un utilisateur ne dépasse pas une limite de caractères spécifique. rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /user_profiles/{userId} { allow create, update: if request.auth.uid == userId && request.resource.data.displayName.size() < 30; } } }

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Ces exemples illustrent quelques cas d'utilisation courants des règles de sécurité Firestore, mais les possibilités sont presque infinies. Grâce à la syntaxe expressive et aux puissantes fonctionnalités de correspondance, vous pouvez créer des règles de sécurité complexes qui protègent vos données Firestore et maintiennent un environnement sécurisé.

Optimiser les performances de Firestore

Firestore est conçu pour offrir une synchronisation des données en temps réel rapide et fiable, mais il est essentiel d'optimiser les performances de votre base de données Firestore pour garantir la meilleure expérience utilisateur. Voici plusieurs conseils pour vous aider à tirer le meilleur parti de Firestore :

1. Opérations par lots : lorsque vous devez effectuer plusieurs opérations d'écriture sur une courte période, envisagez d'utiliser des écritures par lots pour regrouper les opérations. Les écritures par lots peuvent améliorer les performances en réduisant le nombre d'allers-retours entre votre client et le backend Firestore.
2. Limiter les résultats des requêtes : les performances de Firestore dépendent du nombre de documents renvoyés par vos requêtes. Pour améliorer les performances, utilisez la pagination pour limiter le nombre de documents renvoyés et demandez uniquement les données dont votre application a besoin.
3. Utiliser des données dénormalisées : dans certains cas, il peut être avantageux de stocker des données redondantes ou dénormalisées pour réduire le besoin de requêtes et de jointures complexes. En dupliquant les données dans des collections ou des documents associés, vous pouvez simplifier vos requêtes et réduire les lectures requises.
4. Optimisez le stockage des données : assurez-vous que vos données sont structurées efficacement et stockées de manière à minimiser les frais généraux. Cela peut inclure l'utilisation de noms de champs plus courts pour réduire la taille de stockage ou l'utilisation d'horodatages entiers au lieu de chaînes ISO pour les valeurs date-heure.
5. Mettre en cache les données sur le client : Pour améliorer la réactivité de vos applications, pensez à mettre en cache les données récupérées depuis Firestore côté client. Cela peut contribuer à réduire le recours à la synchronisation des données en temps réel et à minimiser le nombre de lectures Firestore requises pour les opérations courantes.
6. Surveiller les performances de Firestore : Firebase fournit des outils pour surveiller les performances de votre base de données Firestore, tels que le SDK Firebase Performance Monitoring. L'examen régulier de ces mesures peut aider à identifier les domaines potentiels d'optimisation et à garantir le bon fonctionnement de votre base de données.

En suivant ces conseils d'optimisation des performances et en surveillant votre utilisation de Firestore, vous pouvez vous assurer que vos applications basées sur Firestore offrent la meilleure expérience possible à vos utilisateurs.

Tarifs Firestore

Firestore fonctionne selon un modèle de tarification à l'utilisation, avec des coûts déterminés par l'utilisation de diverses ressources, notamment :

1. Stockage de documents : la quantité de données stockées dans vos documents Firestore a un impact sur les coûts, car le stockage vous est facturé par Go.
2. Lectures, écritures et suppressions de documents : avec Firestore, vous êtes facturé pour chaque opération de lecture, d'écriture et de suppression sur votre base de données. La surveillance du nombre d'opérations est cruciale pour contrôler les coûts à mesure que l'utilisation augmente.
3. Utilisation du réseau : Firestore facture le trafic réseau sortant au-delà d'un certain seuil. Ces frais dépendent de la quantité de données transférées et de la région de destination.

En plus de ces frais de paiement à l'utilisation, Firestore propose un niveau gratuit généreux dans le cadre du plan gratuit Firebase, qui comprend :

• 1 Gio de stockage
• 50 000 lectures de documents par jour
• 20 000 écritures de documents par jour
• 20 000 documents supprimés par jour
• 10 Gio d'utilisation du réseau par mois

Le modèle tarifaire de Firestore permet flexibilité et évolutivité à mesure que les exigences de votre application évoluent. Il est crucial de surveiller votre utilisation et d'optimiser votre mise en œuvre de Firestore pour équilibrer performances et rentabilité.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

En comprenant les règles de sécurité de Firestore, en optimisant ses performances et en gérant efficacement les coûts, vous pouvez tirer le meilleur parti de cette puissante solution de base de données NoSQL dans vos applications Firebase. N'oubliez pas d'envisager d'intégrer Firestore à AppMaster pour une expérience efficace de création d'applications sans code .

Cas d'utilisation de Firestore

Les fonctionnalités puissantes de Firestore, la synchronisation des données en temps réel et l'architecture évolutive en font une solution idéale pour un large éventail d'applications et de secteurs :

• Applications collaboratives : la synchronisation en temps réel de Firestore le rend parfait pour créer des outils collaboratifs tels que des logiciels de gestion de projet, des applications de messagerie et des éditeurs de documents partagés où les utilisateurs ont besoin d'un accès instantané aux informations mises à jour.
• Applications de jeux : les structures de données hiérarchiques et en temps réel fournies par Firestore en font un choix approprié pour créer des applications de jeux en ligne multijoueurs et gérer efficacement l'état du jeu.
• Plateformes de commerce électronique : Firestore peut aider les propriétaires de boutiques en ligne à gérer de vastes catalogues de produits, à suivre l'inventaire et à enregistrer les données des utilisateurs (telles que les paniers d'achat, l'historique des commandes et les profils utilisateur). Cela permet une expérience d’achat personnalisée et une évolution transparente à mesure que l’entreprise se développe.
• Internet des objets (IoT) : la capacité de Firestore à stocker et synchroniser les données des appareils connectés en temps réel en fait un choix fiable pour les applications IoT , permettant aux développeurs de suivre et d'analyser facilement les flux de données provenant de capteurs et d'autres appareils IoT.
• Systèmes de gestion de contenu (CMS) : Firestore est un magasin de données idéal pour créer des solutions CMS personnalisées avec des fonctionnalités en temps réel, des capacités d'interrogation avancées et de puissants contrôles d'accès, simplifiant la gestion du contenu des sites Web et des applications.
• Analyse et surveillance : Firestore peut être intégré à un backend pour les applications de surveillance et d'analyse afin de visualiser, regrouper et analyser les données entrantes en temps réel tout en appliquant des fonctions d'interrogation complexes.

Intégration de Firestore avec AppMaster

Pour simplifier et accélérer davantage la création et la maintenance d'applications, vous pouvez intégrer de manière transparente Firestore en tant que solution principale de stockage de données dans vos applications AppMaster. AppMaster fournit une plate no-code qui permet aux utilisateurs de créer des applications backend, Web et mobiles sans écrire une ligne de code.

L'intégration avec Firestore peut être réalisée via l'API REST et WSS Endpoints, permettant aux développeurs d'accéder et de gérer efficacement les données Firestore avec la plateforme AppMaster. En combinant la puissante synchronisation des données en temps réel de Firestore avec l'interface drag-and-drop d' AppMaster, des modèles de données flexibles et des systèmes de conception visuelle, vous pouvez créer des applications Web et mobiles professionnelles et conviviales 10 fois plus rapidement et 3 fois plus cher. efficace que les méthodes de développement traditionnelles.

De plus, AppMaster propose Business Process (BP) Designer , qui permet aux utilisateurs de créer visuellement une logique d'application backend, Web ou mobile sans codage manuel. La combinaison de Firestore avec AppMaster permet une synchronisation en temps réel, élimine la dette technique et supprime les dépendances coûteuses liées au codage manuel, rendant Firestore plus polyvalent que jamais.

Conclusion

Google Firestore est une solution de base de données NoSQL puissante, évolutive et flexible qui profite au développement d'applications modernes, notamment la synchronisation des données en temps réel et la prise en charge hors ligne. Son modèle de données hiérarchique, ses puissantes capacités d'interrogation et ses règles de sécurité en font un choix attrayant pour les développeurs à la recherche d'une solution de données complète pour leurs applications Web et mobiles.

En intégrant Firestore à la plateforme no-code AppMaster, vous pouvez tirer parti de ses fonctionnalités avancées tout en bénéficiant de la simplicité, de la rapidité et de la rentabilité d'un environnement de développement no-code. En combinant la puissance de Firestore avec les systèmes de conception visuelle d' AppMaster, les modèles de données flexibles et Business Process Designer, vous pouvez créer efficacement des applications hautes performances qui répondent à la sphère numérique en constante évolution d'aujourd'hui.