Ce guide de démarrage rapide explique comment configurer Cloud Firestore, ajouter des données, puis afficher les données que vous venez d'ajouter dans la console Firebase.
Créer une base de données Cloud Firestore
Si vous ne l'avez pas encore fait, créez un projet Firebase dans la console Firebase en cliquant sur Ajouter un projet, puis en suivant les instructions à l'écran pour créer un projet Firebase ou pour ajouter les services Firebase à un projet Google Cloud existant.
Ouvrez votre projet dans la console Firebase. Dans le panneau de gauche, développez Build (Créer), puis sélectionnez Base de données Firestore.
Cliquez sur Créer une base de données.
Sélectionnez un emplacement pour la base de données.
Si vous ne parvenez pas à sélectionner un emplacement, c'est que l'emplacement des ressources Google Cloud par défaut de votre projet a déjà été défini. Certaines ressources de votre projet (comme l'instance Cloud Firestore par défaut) partagent une dépendance de localisation commune. Leur emplacement peut être défini lors de la création du projet ou lors de la configuration d'un autre service qui partage cette dépendance de localisation.
Sélectionnez un mode de démarrage pour votre Cloud Firestore Security Rules:
- Mode test
Convient pour se familiariser avec les bibliothèques clientes mobiles et Web, mais permet à tout le monde de lire et d'écraser les données. Lorsque vous aurez terminé les tests, passez en revue la section Sécuriser les données.
Pour commencer à utiliser le Web, les plates-formes Apple ou le SDK Android, sélectionnez le mode test.
- Mode verrouillé
Refuse toutes les lectures et écritures des clients mobiles et Web. Vos serveurs d'applications authentifiés (C#, Go, Java, Node.js, PHP, Python ou Ruby) peuvent toujours accéder à votre base de données.
Pour commencer à utiliser la bibliothèque cliente du serveur C#, Go, Java, Node.js, PHP, Python ou Ruby, sélectionnez le mode verrouillé.
Votre ensemble initial de Cloud Firestore Security Rules s'appliquera à votre base de données Cloud Firestore par défaut. Si vous créez plusieurs bases de données pour votre projet, vous pouvez déployer Cloud Firestore Security Rules pour chacune d'elles.
Cliquez sur Créer.
Lorsque vous activez Cloud Firestore, cela active également l'API dans Cloud API Manager.
Configurer l'environnement de développement
Ajoutez les dépendances et les bibliothèques clientes requises pour votre application.
Web
- Suivez les instructions pour ajouter Firebase à votre application Web.
- Ajoutez les bibliothèques Firebase et Cloud Firestore à votre application:
Le SDK Cloud Firestore est également disponible en tant que package npm.<script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-app-compat.js"></script> <script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-firestore-compat.js"></script>
Vous devez charger manuellement Firebase et Cloud Firestore.npm install firebase@11.0.2 --save
import firebase from "firebase/compat/app"; // Required for side-effects import "firebase/firestore";
Web
- Suivez les instructions pour ajouter Firebase à votre application Web.
-
Le SDK Cloud Firestore est disponible en tant que package npm.
Vous devez importer à la fois Firebase et Cloud Firestore.npm install firebase@11.0.2 --save
import { initializeApp } from "firebase/app"; import { getFirestore } from "firebase/firestore";
iOS+
Suivez les instructions pour ajouter Firebase à votre application Apple.
Utilisez Swift Package Manager pour installer et gérer les dépendances Firebase.
- Dans Xcode, à partir de votre projet d'application ouvert, accédez à File > Swift Packages > Add Package Dependency (Fichier > Packages Swift > Ajouter une dépendance de package).
- Lorsque vous y êtes invité, ajoutez le dépôt du SDK des plates-formes Firebase pour Apple :
- Choisissez la bibliothèque Firestore.
- Lorsque vous avez terminé, Xcode commence à résoudre et à télécharger automatiquement vos dépendances en arrière-plan.
https://github.com/firebase/firebase-ios-sdk
Android
- Suivez les instructions pour ajouter Firebase à votre application Android.
- À l'aide de la nomenclature (BoM) Firebase Android, déclarez la dépendance pour la bibliothèque Cloud Firestore pour Android dans votre fichier Gradle de module (au niveau de l'application) (généralement
app/build.gradle.kts
ouapp/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:33.6.0")) // Declare the dependency for the Cloud Firestore library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-firestore") }
Si vous suivez la nomenclature (BoM) Firebase Android, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Alternative) Declarez les dépendances de la bibliothèque Firebase sans utiliser BoM.
Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.
Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons vivement d'utiliser BoM pour gérer les versions de la bibliothèque, ce qui garantit que toutes les versions sont compatibles.
dependencies { // Declare the dependency for the Cloud Firestore library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-firestore:25.1.1") }
Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir de la version d'octobre 2023, les développeurs Kotlin et Java peuvent dépendre du module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).
Dart
- Si ce n'est pas déjà fait, configurez et initialisez Firebase dans votre application Flutter.
- À partir de la racine de votre projet Flutter, exécutez la commande suivante pour installer le plug-in:
flutter pub add cloud_firestore
- Une fois cette étape terminée, reconstruisez votre application Flutter:
flutter run
- Facultatif:améliorez les temps de compilation iOS et macOS en incluant le framework précompilé.
Actuellement, le SDK Firestore pour iOS dépend d'un code dont la compilation dans Xcode peut prendre plus de cinq minutes. Pour réduire considérablement les temps de compilation, vous pouvez utiliser une version précompilée en ajoutant cette ligne au bloc
target 'Runner' do
de votre fichier Podfile:target 'Runner' do use_frameworks! use_modular_headers! pod 'FirebaseFirestore', :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git', :tag => 'IOS_SDK_VERSION' flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) target 'RunnerTests' do inherit! :search_paths end end
Remplacez IOS_SDK_VERSION par la version du SDK Firebase pour iOS spécifiée dans le fichier
firebase_sdk_version.rb
defirebase_core
. Si vous n'utilisez pas la dernière version defirebase_core
, recherchez ce fichier dans le cache de votre package Pub local (généralement~/.pub-cache
).Assurez-vous également d'avoir mis à niveau CocoaPods vers la version 1.9.1 ou ultérieure:
gem install cocoapods
Pour en savoir plus, consultez ce problème sur GitHub.
Java
- Ajoutez le SDK Firebase Admin à votre application :
-
Avec Gradle :
compile 'com.google.firebase:firebase-admin:1.32.0'
-
Avec Maven :
<dependency> <groupId>com.google.firebase</groupId> <artifactId>firebase-admin</artifactId> <version>1.32.0</version> </dependency>
-
Avec Gradle :
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
Python
- Ajoutez le SDK Firebase Admin à votre application Python:
pip install --upgrade firebase-admin
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
C++
- Suivez les instructions pour ajouter Firebase à votre projet C++.
- Interface C++ pour Android.
- Dépendances Gradle. Ajoutez les éléments suivants à votre fichier Gradle (généralement
app/build.gradle
) de votre module (au niveau de l'application) :android.defaultConfig.externalNativeBuild.cmake { arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir" } apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle" firebaseCpp.dependencies { // earlier entries auth firestore }
- Dépendances binaires. De même, la méthode recommandée pour obtenir les dépendances binaires consiste à ajouter ce qui suit à votre fichier
CMakeLists.txt
:add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL) set(firebase_libs firebase_auth firebase_firestore firebase_app) # Replace the target name below with the actual name of your target, # for example, "native-lib". target_link_libraries(${YOUR_TARGET_NAME_HERE} "${firebase_libs}")
- Pour configurer l'intégration au bureau, consultez la section Ajouter Firebase à votre projet C++.
Unity
- Suivez les instructions pour ajouter Firebase à votre projet Unity.
- Utilisez l'interface Unity pour configurer votre projet afin de réduire les builds Android.
- Vous trouverez cette option dans Player Settings > Android > Publishing Settings > Minify (Paramètres du lecteur > Android > Paramètres de publication > Minification).
- Les options peuvent varier selon les versions d'Unity. Consultez donc la documentation officielle d'Unity et le guide de débogage de la compilation Firebase Unity.
-
Si, après avoir activé la minification, le nombre de méthodes référencées dépasse toujours la limite, vous pouvez également activer
multidex
dans :-
mainTemplate.gradle
si l'option Modèle Gradle personnalisé sous Paramètres du lecteur est activée -
ou le fichier
build.gradle
au niveau du module, si vous utilisez Android Studio pour compiler le projet exporté.
-
Vous devez réduire la compilation pour éviter le message Error while merging dex archives
.
Node.js
-
Ajoutez le SDK Firebase Admin à votre application:
npm install firebase-admin --save
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
Accéder
- Ajoutez le SDK Firebase Admin à votre application Go:
go get firebase.google.com/go
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
PHP
-
Les bibliothèques clientes de serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les identifiants par défaut de l'application Google pour l'authentification.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
GOOGLE_APPLICATION_CREDENTIALS
pour qu'elle pointe vers un fichier de clé de compte de service JSON. Vous pouvez créer un fichier de clés sur la page Identifiants de la console API.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- Dans votre environnement de production, vous n'avez pas besoin de vous authentifier si vous exécutez votre application sur App Engine ou Compute Engine, à l'aide du même projet que celui que vous utilisez pour Cloud Firestore. Sinon, configurez un compte de service.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
- Installez et activez l'extension gRPC pour PHP. Vous en aurez besoin pour utiliser la bibliothèque cliente.
-
Ajoutez la bibliothèque PHP Cloud Firestore à votre application :
composer require google/cloud-firestore
C#
-
Les bibliothèques clientes de serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les identifiants par défaut de l'application Google pour l'authentification.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
GOOGLE_APPLICATION_CREDENTIALS
pour qu'elle pointe vers un fichier de clé de compte de service JSON. Vous pouvez créer un fichier de clés sur la page Identifiants de la console API.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- Dans votre environnement de production, vous n'avez pas besoin de vous authentifier si vous exécutez votre application sur App Engine ou Compute Engine, à l'aide du même projet que celui que vous utilisez pour Cloud Firestore. Sinon, configurez un compte de service.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
-
Ajoutez la bibliothèque C# Cloud Firestore à votre application dans le fichier
.csproj
:<ItemGroup> <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" /> </ItemGroup>
-
Ajoutez le code ci-dessous dans le fichier
Program.cs
:using Google.Cloud.Firestore;
Ruby
-
Les bibliothèques clientes de serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C# et Ruby) utilisent les identifiants par défaut de l'application Google pour l'authentification.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
GOOGLE_APPLICATION_CREDENTIALS
pour qu'elle pointe vers un fichier de clé de compte de service JSON. Vous pouvez créer un fichier de clés sur la page Identifiants de la console API.export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
- Dans votre environnement de production, vous n'avez pas besoin de vous authentifier si vous exécutez votre application sur App Engine ou Compute Engine, à l'aide du même projet que celui que vous utilisez pour Cloud Firestore. Sinon, configurez un compte de service.
-
Pour vous authentifier à partir de votre environnement de développement, définissez la variable d'environnement
-
Ajoutez la bibliothèque Ruby Cloud Firestore à votre application dans le
Gemfile
:gem "google-cloud-firestore"
-
Installez les dépendances du
Gemfile
avec la commande :bundle install
(Facultatif) Prototypage et test avec Firebase Local Emulator Suite
Pour les développeurs mobiles, avant de parler de la façon dont votre application écrit et lit à partir de Cloud Firestore, présentons un ensemble d'outils que vous pouvez utiliser pour prototyper et tester la fonctionnalité Cloud Firestore : Firebase Local Emulator Suite. Si vous essayez différents modèles de données, optimisez vos règles de sécurité ou cherchez à trouver le moyen le plus économique d'interagir avec le backend, il peut être judicieux de pouvoir travailler en local sans déployer de services en ligne.
Un émulateur Cloud Firestore fait partie de Local Emulator Suite, ce qui permet à votre application d'interagir avec le contenu et la configuration de votre base de données émulée, ainsi que, éventuellement, avec vos ressources de projet émulées (fonctions, autres bases de données et règles de sécurité).
Pour utiliser l'émulateur Cloud Firestore, procédez comme suit:
- Ajoutez une ligne de code à la configuration de test de votre application pour vous connecter à l'émulateur.
- À partir de la racine du répertoire de votre projet local, exécutez
firebase emulators:start
. - Effectuer des appels à partir du code de prototype de votre application à l'aide d'un SDK de plate-forme Cloud Firestore, comme d'habitude.
Un tutoriel détaillé impliquant Cloud Firestore et Cloud Functions est disponible. Nous vous conseillons également de consulter la présentation de Local Emulator Suite.
Initialiser Cloud Firestore
Initialisez une instance de Cloud Firestore:
Web
import { initializeApp } from "firebase/app"; import { getFirestore } from "firebase/firestore"; // TODO: Replace the following with your app's Firebase project configuration // See: https://support.google.com/firebase/answer/7015592 const firebaseConfig = { FIREBASE_CONFIGURATION }; // Initialize Firebase const app = initializeApp(firebaseConfig); // Initialize Cloud Firestore and get a reference to the service const db = getFirestore(app);
Remplacez FIREBASE_CONFIGURATION par l'firebaseConfig
de votre application Web.
Pour conserver les données lorsque l'appareil perd sa connexion, consultez la documentation Activer les données hors connexion.
Web
import firebase from "firebase/app"; import "firebase/firestore"; // TODO: Replace the following with your app's Firebase project configuration // See: https://support.google.com/firebase/answer/7015592 const firebaseConfig = { FIREBASE_CONFIGURATION }; // Initialize Firebase firebase.initializeApp(firebaseConfig); // Initialize Cloud Firestore and get a reference to the service const db = firebase.firestore();
Remplacez FIREBASE_CONFIGURATION par l'firebaseConfig
de votre application Web.
Pour conserver les données lorsque l'appareil perd sa connexion, consultez la documentation Activer les données hors connexion.
Swift
import FirebaseCore import FirebaseFirestore
FirebaseApp.configure() let db = Firestore.firestore()
Objective-C
@import FirebaseCore; @import FirebaseFirestore; // Use Firebase library to configure APIs [FIRApp configure];
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
Kotlin+KTX
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Java
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
Dart
db = FirebaseFirestore.instance;
Java
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour obtenir une référence complète, consultez la section Initialiser le SDK Admin.import com.google.auth.oauth2.GoogleCredentials; import com.google.cloud.firestore.Firestore; import com.google.firebase.FirebaseApp; import com.google.firebase.FirebaseOptions; // Use the application default credentials GoogleCredentials credentials = GoogleCredentials.getApplicationDefault(); FirebaseOptions options = new FirebaseOptions.Builder() .setCredentials(credentials) .setProjectId(projectId) .build(); FirebaseApp.initializeApp(options); Firestore db = FirestoreClient.getFirestore();
Pour utiliser le SDK Admin Firebase sur votre propre serveur, utilisez un compte de service.
Accédez à IAM et administration > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
import com.google.auth.oauth2.GoogleCredentials; import com.google.cloud.firestore.Firestore; import com.google.firebase.FirebaseApp; import com.google.firebase.FirebaseOptions; // Use a service account InputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json"); GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount); FirebaseOptions options = new FirebaseOptions.Builder() .setCredentials(credentials) .build(); FirebaseApp.initializeApp(options); Firestore db = FirestoreClient.getFirestore();
Python
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour obtenir une référence complète, consultez la section Initialiser le SDK Admin.import firebase_admin from firebase_admin import firestore # Application Default credentials are automatically created. app = firebase_admin.initialize_app() db = firestore.client()
Vous pouvez également utiliser des identifiants par défaut d'application existants pour initialiser le SDK.
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore # Use the application default credentials. cred = credentials.ApplicationDefault() firebase_admin.initialize_app(cred) db = firestore.client()
Pour utiliser le SDK Admin Firebase sur votre propre serveur, utilisez un compte de service.
Accédez à IAM et administration > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore # Use a service account. cred = credentials.Certificate('path/to/serviceAccount.json') app = firebase_admin.initialize_app(cred) db = firestore.client()
Python
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour obtenir une référence complète, consultez la section Initialiser le SDK Admin.import firebase_admin from firebase_admin import firestore_async # Application Default credentials are automatically created. app = firebase_admin.initialize_app() db = firestore_async.client()
Vous pouvez également utiliser des identifiants par défaut d'application existants pour initialiser le SDK.
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore_async # Use the application default credentials. cred = credentials.ApplicationDefault() firebase_admin.initialize_app(cred) db = firestore_async.client()
Pour utiliser le SDK Admin Firebase sur votre propre serveur, utilisez un compte de service.
Accédez à IAM et administration > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore_async # Use a service account. cred = credentials.Certificate('path/to/serviceAccount.json') app = firebase_admin.initialize_app(cred) db = firestore_async.client()
C++
// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance(). App::Create(); Firestore* db = Firestore::GetInstance();
Node.js
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour obtenir une référence complète, consultez la section Initialiser le SDK Admin.-
Initialisation sur Cloud Functions
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
initializeApp(); const db = getFirestore();
-
Initialisation sur Google Cloud
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
initializeApp({ credential: applicationDefault() }); const db = getFirestore();
-
Initialiser sur votre propre serveur
Pour utiliser le SDK Admin Firebase sur votre propre serveur (ou tout autre environnement Node.js), utilisez un compte de service. Accédez à IAM et administration > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
const serviceAccount = require('./path/to/serviceAccountKey.json'); initializeApp({ credential: cert(serviceAccount) }); const db = getFirestore();
Accéder
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Vous trouverez ci-dessous les méthodes les plus courantes. Pour obtenir une référence complète, consultez la section Initialiser le SDK Admin.import ( "log" firebase "firebase.google.com/go" "google.golang.org/api/option" ) // Use the application default credentials ctx := context.Background() conf := &firebase.Config{ProjectID: projectID} app, err := firebase.NewApp(ctx, conf) if err != nil { log.Fatalln(err) } client, err := app.Firestore(ctx) if err != nil { log.Fatalln(err) } defer client.Close()
Pour utiliser le SDK Admin Firebase sur votre propre serveur, utilisez un compte de service.
Accédez à IAM et administration > Comptes de service dans la console Google Cloud. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
import ( "log" firebase "firebase.google.com/go" "google.golang.org/api/option" ) // Use a service account ctx := context.Background() sa := option.WithCredentialsFile("path/to/serviceAccount.json") app, err := firebase.NewApp(ctx, nil, sa) if err != nil { log.Fatalln(err) } client, err := app.Firestore(ctx) if err != nil { log.Fatalln(err) } defer client.Close()
PHP
PHP
Pour en savoir plus sur l'installation et la création d'un client Cloud Firestore, consultez la page Bibliothèques clientes Cloud Firestore.
Unity
using Firebase.Firestore; using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C#
C#
Pour en savoir plus sur l'installation et la création d'un client Cloud Firestore, consultez la page Bibliothèques clientes Cloud Firestore.
Ruby
Ajouter des données
Cloud Firestore stocke les données dans des documents, qui sont eux-mêmes stockés dans des collections. Cloud Firestore crée implicitement les collections et les documents nécessaires la première fois qu'une donnée est ajoutée à un document. Vous n'avez pas besoin de créer explicitement les collections ni les documents.
Créez une collection et un document à l'aide de l'exemple de code ci-dessous.
Web
import { collection, addDoc } from "firebase/firestore"; try { const docRef = await addDoc(collection(db, "users"), { first: "Ada", last: "Lovelace", born: 1815 }); console.log("Document written with ID: ", docRef.id); } catch (e) { console.error("Error adding document: ", e); }
Web
db.collection("users").add({ first: "Ada", last: "Lovelace", born: 1815 }) .then((docRef) => { console.log("Document written with ID: ", docRef.id); }) .catch((error) => { console.error("Error adding document: ", error); });
Swift
// Add a new document with a generated ID do { let ref = try await db.collection("users").addDocument(data: [ "first": "Ada", "last": "Lovelace", "born": 1815 ]) print("Document added with ID: \(ref.documentID)") } catch { print("Error adding document: \(error)") }
Objective-C
// Add a new document with a generated ID __block FIRDocumentReference *ref = [[self.db collectionWithPath:@"users"] addDocumentWithData:@{ @"first": @"Ada", @"last": @"Lovelace", @"born": @1815 } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error adding document: %@", error); } else { NSLog(@"Document added with ID: %@", ref.documentID); } }];
Kotlin+KTX
// Create a new user with a first and last name val user = hashMapOf( "first" to "Ada", "last" to "Lovelace", "born" to 1815, ) // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener { documentReference -> Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}") } .addOnFailureListener { e -> Log.w(TAG, "Error adding document", e) }
Java
// Create a new user with a first and last name Map<String, Object> user = new HashMap<>(); user.put("first", "Ada"); user.put("last", "Lovelace"); user.put("born", 1815); // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener(new OnSuccessListener<DocumentReference>() { @Override public void onSuccess(DocumentReference documentReference) { Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId()); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error adding document", e); } });
Dart
// Create a new user with a first and last name final user = <String, dynamic>{ "first": "Ada", "last": "Lovelace", "born": 1815 }; // Add a new document with a generated ID db.collection("users").add(user).then((DocumentReference doc) => print('DocumentSnapshot added with ID: ${doc.id}'));
Java
Python
Python
C++
// Add a new document with a generated ID Future<DocumentReference> user_ref = db->Collection("users").Add({{"first", FieldValue::String("Ada")}, {"last", FieldValue::String("Lovelace")}, {"born", FieldValue::Integer(1815)}}); user_ref.OnCompletion([](const Future<DocumentReference>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot added with ID: " << future.result()->id() << std::endl; } else { std::cout << "Error adding document: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Pour en savoir plus sur l'installation et la création d'un client Cloud Firestore, consultez la page Bibliothèques clientes Cloud Firestore.
Unity
DocumentReference docRef = db.Collection("users").Document("alovelace"); Dictionary<string, object> user = new Dictionary<string, object> { { "First", "Ada" }, { "Last", "Lovelace" }, { "Born", 1815 }, }; docRef.SetAsync(user).ContinueWithOnMainThread(task => { Debug.Log("Added data to the alovelace document in the users collection."); });
C#
Ruby
À présent, ajoutez un autre document à la collection users
. Notez que ce document contient une paire clé-valeur (deuxième prénom) qui n'est pas présente dans le premier document. Les documents d'une collection peuvent contenir différents ensembles d'informations.
Web
// Add a second document with a generated ID. import { addDoc, collection } from "firebase/firestore"; try { const docRef = await addDoc(collection(db, "users"), { first: "Alan", middle: "Mathison", last: "Turing", born: 1912 }); console.log("Document written with ID: ", docRef.id); } catch (e) { console.error("Error adding document: ", e); }
Web
// Add a second document with a generated ID. db.collection("users").add({ first: "Alan", middle: "Mathison", last: "Turing", born: 1912 }) .then((docRef) => { console.log("Document written with ID: ", docRef.id); }) .catch((error) => { console.error("Error adding document: ", error); });
Swift
// Add a second document with a generated ID. do { let ref = try await db.collection("users").addDocument(data: [ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912 ]) print("Document added with ID: \(ref.documentID)") } catch { print("Error adding document: \(error)") }
Objective-C
// Add a second document with a generated ID. __block FIRDocumentReference *ref = [[self.db collectionWithPath:@"users"] addDocumentWithData:@{ @"first": @"Alan", @"middle": @"Mathison", @"last": @"Turing", @"born": @1912 } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error adding document: %@", error); } else { NSLog(@"Document added with ID: %@", ref.documentID); } }];
Kotlin+KTX
// Create a new user with a first, middle, and last name val user = hashMapOf( "first" to "Alan", "middle" to "Mathison", "last" to "Turing", "born" to 1912, ) // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener { documentReference -> Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}") } .addOnFailureListener { e -> Log.w(TAG, "Error adding document", e) }
Java
// Create a new user with a first, middle, and last name Map<String, Object> user = new HashMap<>(); user.put("first", "Alan"); user.put("middle", "Mathison"); user.put("last", "Turing"); user.put("born", 1912); // Add a new document with a generated ID db.collection("users") .add(user) .addOnSuccessListener(new OnSuccessListener<DocumentReference>() { @Override public void onSuccess(DocumentReference documentReference) { Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId()); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error adding document", e); } });
Dart
// Create a new user with a first and last name final user = <String, dynamic>{ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912 }; // Add a new document with a generated ID db.collection("users").add(user).then((DocumentReference doc) => print('DocumentSnapshot added with ID: ${doc.id}'));
Java
Python
Python
C++
db->Collection("users") .Add({{"first", FieldValue::String("Alan")}, {"middle", FieldValue::String("Mathison")}, {"last", FieldValue::String("Turing")}, {"born", FieldValue::Integer(1912)}}) .OnCompletion([](const Future<DocumentReference>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot added with ID: " << future.result()->id() << std::endl; } else { std::cout << "Error adding document: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Pour en savoir plus sur l'installation et la création d'un client Cloud Firestore, consultez la page Bibliothèques clientes Cloud Firestore.
Unity
DocumentReference docRef = db.Collection("users").Document("aturing"); Dictionary<string, object> user = new Dictionary<string, object> { { "First", "Alan" }, { "Middle", "Mathison" }, { "Last", "Turing" }, { "Born", 1912 } }; docRef.SetAsync(user).ContinueWithOnMainThread(task => { Debug.Log("Added data to the aturing document in the users collection."); });
C#
Ruby
Lire des données
Utilisez la visionneuse de données de la console Firebase pour vérifier rapidement que vous avez bien ajouté des données à Cloud Firestore.
Vous pouvez également utiliser la méthode "get" pour récupérer l'ensemble de la collection.
Web
import { collection, getDocs } from "firebase/firestore"; const querySnapshot = await getDocs(collection(db, "users")); querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); });
Web
db.collection("users").get().then((querySnapshot) => { querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); }); });
Swift
do { let snapshot = try await db.collection("users").getDocuments() for document in snapshot.documents { print("\(document.documentID) => \(document.data())") } } catch { print("Error getting documents: \(error)") }
Objective-C
[[self.db collectionWithPath:@"users"] getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot, NSError * _Nullable error) { if (error != nil) { NSLog(@"Error getting documents: %@", error); } else { for (FIRDocumentSnapshot *document in snapshot.documents) { NSLog(@"%@ => %@", document.documentID, document.data); } } }];
Kotlin+KTX
db.collection("users") .get() .addOnSuccessListener { result -> for (document in result) { Log.d(TAG, "${document.id} => ${document.data}") } } .addOnFailureListener { exception -> Log.w(TAG, "Error getting documents.", exception) }
Java
db.collection("users") .get() .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() { @Override public void onComplete(@NonNull Task<QuerySnapshot> task) { if (task.isSuccessful()) { for (QueryDocumentSnapshot document : task.getResult()) { Log.d(TAG, document.getId() + " => " + document.getData()); } } else { Log.w(TAG, "Error getting documents.", task.getException()); } } });
Dart
await db.collection("users").get().then((event) { for (var doc in event.docs) { print("${doc.id} => ${doc.data()}"); } });
Java
Python
users_ref = db.collection("users") docs = users_ref.stream() for doc in docs: print(f"{doc.id} => {doc.to_dict()}")
Python
C++
Future<QuerySnapshot> users = db->Collection("users").Get(); users.OnCompletion([](const Future<QuerySnapshot>& future) { if (future.error() == Error::kErrorOk) { for (const DocumentSnapshot& document : future.result()->documents()) { std::cout << document << std::endl; } } else { std::cout << "Error getting documents: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Pour en savoir plus sur l'installation et la création d'un client Cloud Firestore, consultez la page Bibliothèques clientes Cloud Firestore.
Unity
CollectionReference usersRef = db.Collection("users"); usersRef.GetSnapshotAsync().ContinueWithOnMainThread(task => { QuerySnapshot snapshot = task.Result; foreach (DocumentSnapshot document in snapshot.Documents) { Debug.Log(String.Format("User: {0}", document.Id)); Dictionary<string, object> documentDictionary = document.ToDictionary(); Debug.Log(String.Format("First: {0}", documentDictionary["First"])); if (documentDictionary.ContainsKey("Middle")) { Debug.Log(String.Format("Middle: {0}", documentDictionary["Middle"])); } Debug.Log(String.Format("Last: {0}", documentDictionary["Last"])); Debug.Log(String.Format("Born: {0}", documentDictionary["Born"])); } Debug.Log("Read all data from the users collection."); });
C#
Ruby
Sécurisez vos données
Si vous utilisez le SDK pour les plates-formes Web, Android ou Apple, utilisez Firebase Authentication et Cloud Firestore Security Rules pour sécuriser vos données dans Cloud Firestore.
Voici quelques règles de base qui vous aideront à bien démarrer. Vous pouvez modifier les règles de sécurité de votre projet dans l'onglet Règles de la console.
Authentification requise
// Allow read/write access to a document keyed by the user's UID
service cloud.firestore {
match /databases/{database}/documents {
match /users/{uid} {
allow read, write: if request.auth != null && request.auth.uid == uid;
}
}
}
Mode verrouillé
// Deny read/write access to all users under any conditions
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if false;
}
}
}
Avant de déployer votre application Web, Android ou iOS en production, prenez également les mesures nécessaires pour vous assurer que seuls les clients de votre application peuvent accéder à vos données Cloud Firestore. Consultez la documentation sur App Check.
Si vous utilisez l'un des SDK serveur, utilisez Identity and Access Management (IAM) pour sécuriser vos données dans Cloud Firestore.
Regarder·un tutoriel vidéo
Pour obtenir des conseils précis sur les bibliothèques clientes mobiles Cloud Firestore, regardez l'un des tutoriels vidéos ci-dessous:
Web
iOS+
Android
Vous trouverez d'autres vidéos sur la chaîne YouTube de Firebase.
Étapes suivantes
Approfondissez vos connaissances sur les sujets suivants :
- Codelabs : découvrez comment utiliser Cloud Firestore dans une application réelle en suivant le codelab pour Android, iOS ou Web.
- Modèle de données : découvrez comment les données sont structurées dans Cloud Firestore, y compris les données hiérarchiques et les sous-collections.
- Ajouter des données : en savoir plus sur la création et la mise à jour de données dans Cloud Firestore.
- Obtenir des données : en savoir plus sur la récupération des données.
- Lancer des requêtes simples et des requêtes composées : en savoir plus sur l’exécution des requêtes simples et composées.
- Trier et limiter les requêtes : découvrez comment trier et limiter les données renvoyées par vos requêtes.