Ce guide de démarrage rapide vous montre 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 ce n'est déjà fait, créez un projet Firebase: dans la console Firebase , cliquez sur Ajouter un projet , puis suivez les instructions à l'écran pour créer un projet Firebase ou pour ajouter des services Firebase à un projet GCP existant.
Accédez à la section Cloud Firestore de la console Firebase . Vous serez invité à sélectionner un projet Firebase existant. Suivez le workflow de création de base de données.
Sélectionnez un mode de démarrage pour vos règles de sécurité Cloud Firestore:
- Mode d'essai
Idéal pour démarrer avec les bibliothèques clientes mobiles et Web, mais permet à quiconque de lire et d'écraser vos données. Après le test, assurez-vous de consulter la section Sécuriser vos données .
Pour démarrer avec le SDK Web, iOS ou 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 démarrer avec la bibliothèque cliente du serveur C #, Go, Java, Node.js, PHP, Python ou Ruby, sélectionnez le mode verrouillé.
Sélectionnez un emplacement pour votre base de données.
Ce paramètre d'emplacement est l'emplacement par défaut des ressources Google Cloud Platform (GCP) de votre projet. Notez que cet emplacement sera utilisé pour les services GCP de votre projet qui nécessitent un paramètre d'emplacement, en particulier votre bucket Cloud Storage par défaut et votre application App Engine (qui est requise si vous utilisez Cloud Scheduler).
Si vous ne parvenez pas à sélectionner un emplacement, votre projet dispose déjà d'un emplacement de ressource GCP par défaut. Il a été défini lors de la création du projet ou lors de la configuration d'un autre service nécessitant un paramètre d'emplacement.
Cliquez sur Terminé .
Lorsque vous activez Cloud Firestore, il active également l'API dans Cloud API Manager .
Configurez votre environnement de développement
Ajoutez les dépendances et bibliothèques clientes requises à votre application.
la toile
- Suivez les instructions pour ajouter Firebase à votre application Web .
- Ajoutez les bibliothèques Firebase et Cloud Firestore à votre application:
<script src="https://www.gstatic.com/firebasejs/8.2.9/firebase-app.js"></script> <script src="https://www.gstatic.com/firebasejs/8.2.9/firebase-firestore.js"></script>
Le SDK Cloud Firestore est également disponible sous forme de package npm.npm install firebase@8.2.9 --save
Vous devrez exiger manuellement Firebase et Cloud Firestore.const firebase = require("firebase"); // Required for side-effects require("firebase/firestore");
iOS
- Suivez les instructions pour ajouter Firebase à votre application iOS .
- Ajoutez le pod Cloud Firestore à votre
Podfile
pod 'Firebase/Firestore' # Optionally, include the Swift extensions if you're using Swift. pod 'FirebaseFirestoreSwift'
- Enregistrez le fichier et exécutez l'
pod install
.
Java
- Suivez les instructions pour ajouter Firebase à votre application Android .
- À l'aide de Firebase Android BoM , déclarez la dépendance de la bibliothèque Cloud Firestore Android dans le fichier Gradle de votre module (niveau application) (généralement
app/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:26.5.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' }
En utilisant Firebase Android BoM , votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Alternative) Déclarez 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 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 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:22.1.0' }
Kotlin + KTX
- Suivez les instructions pour ajouter Firebase à votre application Android .
- À l'aide de Firebase Android BoM , déclarez la dépendance de la bibliothèque Cloud Firestore Android dans votre fichier Gradle de module (au niveau de l'application) (généralement
app/build.gradle
).dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:26.5.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-ktx' }
En utilisant Firebase Android BoM , votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Alternative) Déclarez 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 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 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-ktx:22.1.0' }
Java
- Ajoutez le SDK Firebase Admin à votre application:
- Utilisation de Gradle:
compile 'com.google.firebase:firebase-admin:7.1.0'
- Utilisation de Maven:
<dependency> <groupId>com.google.firebase</groupId> <artifactId>firebase-admin</artifactId> <version>7.1.0</version> </dependency>
- Utilisation de Gradle:
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.
Python
- Ajoutez le SDK d'administration Firebase à votre application Python:
pip install --upgrade firebase-admin
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.
C ++
- Suivez les instructions pour ajouter Firebase à votre projet C ++ .
- Interface C ++ pour Android.
- Dépendances Gradle. Ajoutez ce qui suit à votre fichier Gradle de module (au niveau de l'application) (généralement
app/build.gradle
):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 est d'ajouter ce qui suit à votre
CMakeLists.txt
fichier: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 de bureau , consultez Ajouter Firebase à votre projet C ++ .
Unité
- Suivez les instructions pour ajouter Firebase à votre projet Unity .
- Interface Unity pour Android.
- Sélectionnez Fichier> Paramètres de construction
- Basculez 'Platform' sur 'Android' et cliquez sur 'Switch Platform'
- Cliquez sur "Paramètres du lecteur ..."
- Dans l'interface utilisateur principale de Unity, sous "Paramètres pour Android", sélectionnez "Paramètres de publication"
- Dans la section 'Minify', modifiez les paramètres Release et Debug de 'None' à 'ProGuard'
Lors de la création pour Android, activez ProGuarding pour éviter la limite Android DEX. Pour ce faire, dans l'éditeur Unity:
Node.js
- Ajoutez le SDK d'administration Firebase à votre application:
npm install firebase-admin --save
- Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les informations d'identification appropriées dans votre environnement.
Aller
- 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 informations d'identification appropriées dans votre environnement.
PHP
- Les bibliothèques clientes du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C # et Ruby) utilisent les informations d' identification 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é sur la page Informations d'identification 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, en utilisant le 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, dont vous 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 du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C # et Ruby) utilisent les informations d' identification 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é sur la page Informations d'identification 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, en utilisant le même projet 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
- Ajouter la bibliothèque Nuage Firestore C # pour votre application dans votre
.csproj
fichier:<ItemGroup> <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" /> </ItemGroup>
- Ajouter ce qui suit à votre
Program.cs
fichier:using Google.Cloud.Firestore;
Rubis
- Les bibliothèques clientes du serveur Cloud Firestore (Java, Node.js, Python, Go, PHP, C # et Ruby) utilisent les informations d' identification par défaut de l'application Google pour l'authentification.
- Pour vous authentifier depuis 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é sur la page Informations d'identification 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, en utilisant le même projet que celui que vous utilisez pour Cloud Firestore. Sinon, configurez un compte de service .
- Pour vous authentifier depuis votre environnement de développement, définissez la variable d'environnement
- Ajoutez la bibliothèque Cloud Firestore Ruby à votre application dans votre
Gemfile
:gem "google-cloud-firestore"
- Installez les dépendances de votre
Gemfile
utilisant:bundle install
Initialiser Cloud Firestore
Initialisez une instance de Cloud Firestore:
la toile
// Initialize Cloud Firestore through Firebase firebase.initializeApp({ apiKey: '### FIREBASE API KEY ###', authDomain: '### FIREBASE AUTH DOMAIN ###', projectId: '### CLOUD FIRESTORE PROJECT ID ###' }); var db = firebase.firestore();Les valeurs de `initializeApp` se trouvent dans` firebaseConfig` de votre application Web. Pour conserver les données lorsque l'appareil perd sa connexion, consultez la documentation Activer les données hors ligne .
Rapide
import Firebase FirebaseApp.configure() let db = Firestore.firestore()
Objectif c
@import Firebase; // Use Firebase library to configure APIs [FIRApp configure]; FIRFirestore *defaultFirestore = [FIRFirestore firestore];
Java
// Access a Cloud Firestore instance from your Activity FirebaseFirestore db = FirebaseFirestore.getInstance();
Kotlin + KTX
// Access a Cloud Firestore instance from your Activity val db = Firebase.firestore
Java
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Voici les méthodes les plus courantes. Pour une référence complète, consultez 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 Firebase Admin sur votre propre serveur, utilisez un compte de service .
Accédez à IAM et administration> Comptes de service dans la console Cloud Platform. 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. Voici les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .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, { 'projectId': project_id, }) db = firestore.client()
Pour utiliser le SDK Firebase Admin sur votre propre serveur, utilisez un compte de service .
Accédez à IAM et administration> Comptes de service dans la console Cloud Platform. 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') firebase_admin.initialize_app(cred) db = firestore.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. Voici les méthodes les plus courantes. Pour une référence complète, consultez Initialiser le SDK Admin .- Initialiser sur Cloud Functions
const admin = require('firebase-admin'); admin.initializeApp(); const db = admin.firestore();
- Initialiser sur Google Cloud Platform
const admin = require('firebase-admin'); admin.initializeApp({ credential: admin.credential.applicationDefault() }); const db = admin.firestore();
- Initialisez sur votre propre serveur
Pour utiliser le SDK Firebase Admin 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 Cloud Platform. Générez une nouvelle clé privée et enregistrez le fichier JSON. Utilisez ensuite le fichier pour initialiser le SDK:
const admin = require('firebase-admin'); const serviceAccount = require('./path/to/serviceAccountKey.json'); admin.initializeApp({ credential: admin.credential.cert(serviceAccount) }); const db = admin.firestore();
Aller
Le SDK Cloud Firestore est initialisé de différentes manières en fonction de votre environnement. Voici les méthodes les plus courantes. Pour une référence complète, consultez 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 Firebase Admin sur votre propre serveur, utilisez un compte de service .
Accédez à IAM et administration> Comptes de service dans la console Cloud Platform. 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
use Google\Cloud\Firestore\FirestoreClient; /** * Initialize Cloud Firestore with default project ID. * ``` * initialize(); * ``` */ function initialize() { // Create the Cloud Firestore client $db = new FirestoreClient(); printf('Created Cloud Firestore client with default project ID.' . PHP_EOL); }
Unité
using Firebase.Firestore; using Firebase.Extensions; FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C #
FirestoreDb db = FirestoreDb.Create(project); Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
Rubis
require "google/cloud/firestore" firestore = Google::Cloud::Firestore.new project_id: project_id puts "Created Cloud Firestore client with given project ID."
Ajouter des données
Cloud Firestore stocke les données dans des documents, qui sont stockés dans des collections. Cloud Firestore crée des collections et des documents implicitement la première fois que vous ajoutez des données au document. Vous n'avez pas besoin de créer explicitement des collections ou des documents.
Créez une nouvelle collection et un document à l'aide de l'exemple de code suivant.
la toile
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); });
Rapide
// Add a new document with a generated ID var ref: DocumentReference? = nil ref = db.collection("users").addDocument(data: [ "first": "Ada", "last": "Lovelace", "born": 1815 ]) { err in if let err = err { print("Error adding document: \(err)") } else { print("Document added with ID: \(ref!.documentID)") } }
Objectif 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); } }];
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); } });
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
DocumentReference docRef = db.collection("users").document("alovelace"); // Add document data with id "alovelace" using a hashmap Map<String, Object> data = new HashMap<>(); data.put("first", "Ada"); data.put("last", "Lovelace"); data.put("born", 1815); //asynchronously write data ApiFuture<WriteResult> result = docRef.set(data); // ... // result.get() blocks on response System.out.println("Update time : " + result.get().getUpdateTime());
Python
doc_ref = db.collection(u'users').document(u'alovelace') doc_ref.set({ u'first': u'Ada', u'last': u'Lovelace', u'born': 1815 })
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() << '\n'; } else { std::cout << "Error adding document: " << future.error_message() << '\n'; } });
Node.js
const docRef = db.collection('users').doc('alovelace'); await docRef.set({ first: 'Ada', last: 'Lovelace', born: 1815 });
Aller
_, _, err := client.Collection("users").Add(ctx, map[string]interface{}{ "first": "Ada", "last": "Lovelace", "born": 1815, }) if err != nil { log.Fatalf("Failed adding alovelace: %v", err) }
PHP
$docRef = $db->collection('users')->document('lovelace'); $docRef->set([ 'first' => 'Ada', 'last' => 'Lovelace', 'born' => 1815 ]); printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
Unité
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 #
DocumentReference docRef = db.Collection("users").Document("alovelace"); Dictionary<string, object> user = new Dictionary<string, object> { { "First", "Ada" }, { "Last", "Lovelace" }, { "Born", 1815 } }; await docRef.SetAsync(user);
Rubis
doc_ref = firestore.doc "#{collection_path}/alovelace" doc_ref.set( first: "Ada", last: "Lovelace", born: 1815 ) puts "Added data to the alovelace document in the users collection."
Ajoutez maintenant un autre document à la collection des users
. Notez que ce document inclut une paire clé-valeur (deuxième prénom) qui n'apparaît pas dans le premier document. Les documents d'une collection peuvent contenir différents ensembles d'informations.
la toile
// 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); });
Rapide
// Add a second document with a generated ID. ref = db.collection("users").addDocument(data: [ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912 ]) { err in if let err = err { print("Error adding document: \(err)") } else { print("Document added with ID: \(ref!.documentID)") } }
Objectif 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); } }];
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); } });
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
DocumentReference docRef = db.collection("users").document("aturing"); // Add document data with an additional field ("middle") Map<String, Object> data = new HashMap<>(); data.put("first", "Alan"); data.put("middle", "Mathison"); data.put("last", "Turing"); data.put("born", 1912); ApiFuture<WriteResult> result = docRef.set(data); System.out.println("Update time : " + result.get().getUpdateTime());
Python
doc_ref = db.collection(u'users').document(u'aturing') doc_ref.set({ u'first': u'Alan', u'middle': u'Mathison', u'last': u'Turing', u'born': 1912 })
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() << '\n'; } else { std::cout << "Error adding document: " << future.error_message() << '\n'; } });
Node.js
const aTuringRef = db.collection('users').doc('aturing'); await aTuringRef.set({ 'first': 'Alan', 'middle': 'Mathison', 'last': 'Turing', 'born': 1912 });
Aller
_, _, err = client.Collection("users").Add(ctx, map[string]interface{}{ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912, }) if err != nil { log.Fatalf("Failed adding aturing: %v", err) }
PHP
$docRef = $db->collection('users')->document('aturing'); $docRef->set([ 'first' => 'Alan', 'middle' => 'Mathison', 'last' => 'Turing', 'born' => 1912 ]); printf('Added data to the aturing document in the users collection.' . PHP_EOL);
Unité
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 #
DocumentReference docRef = db.Collection("users").Document("aturing"); Dictionary<string, object> user = new Dictionary<string, object> { { "First", "Alan" }, { "Middle", "Mathison" }, { "Last", "Turing" }, { "Born", 1912 } }; await docRef.SetAsync(user);
Rubis
doc_ref = firestore.doc "#{collection_path}/aturing" doc_ref.set( first: "Alan", middle: "Mathison", last: "Turing", born: 1912 ) puts "Added data to the aturing document in the users collection."
Lire les données
Pour vérifier rapidement que vous avez ajouté des données à Cloud Firestore, utilisez la visionneuse de données dans la console Firebase .
Vous pouvez également utiliser la méthode "get" pour récupérer la collection entière.
la toile
db.collection("users").get().then((querySnapshot) => { querySnapshot.forEach((doc) => { console.log(`${doc.id} => ${doc.data()}`); }); });
Rapide
db.collection("users").getDocuments() { (querySnapshot, err) in if let err = err { print("Error getting documents: \(err)") } else { for document in querySnapshot!.documents { print("\(document.documentID) => \(document.data())") } } }
Objectif 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); } } }];
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()); } } });
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
// asynchronously retrieve all users ApiFuture<QuerySnapshot> query = db.collection("users").get(); // ... // query.get() blocks on response QuerySnapshot querySnapshot = query.get(); List<QueryDocumentSnapshot> documents = querySnapshot.getDocuments(); for (QueryDocumentSnapshot document : documents) { System.out.println("User: " + document.getId()); System.out.println("First: " + document.getString("first")); if (document.contains("middle")) { System.out.println("Middle: " + document.getString("middle")); } System.out.println("Last: " + document.getString("last")); System.out.println("Born: " + document.getLong("born")); }
Python
users_ref = db.collection(u'users') docs = users_ref.stream() for doc in docs: print(f'{doc.id} => {doc.to_dict()}')
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 << '\n'; } } else { std::cout << "Error getting documents: " << future.error_message() << '\n'; } });
Node.js
const snapshot = await db.collection('users').get(); snapshot.forEach((doc) => { console.log(doc.id, '=>', doc.data()); });
Aller
iter := client.Collection("users").Documents(ctx) for { doc, err := iter.Next() if err == iterator.Done { break } if err != nil { log.Fatalf("Failed to iterate: %v", err) } fmt.Println(doc.Data()) }
PHP
$usersRef = $db->collection('users'); $snapshot = $usersRef->documents(); foreach ($snapshot as $user) { printf('User: %s' . PHP_EOL, $user->id()); printf('First: %s' . PHP_EOL, $user['first']); if (!empty($user['middle'])) { printf('Middle: %s' . PHP_EOL, $user['middle']); } printf('Last: %s' . PHP_EOL, $user['last']); printf('Born: %d' . PHP_EOL, $user['born']); printf(PHP_EOL); } printf('Retrieved and printed out all documents from the users collection.' . PHP_EOL);
Unité
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 #
CollectionReference usersRef = db.Collection("users"); QuerySnapshot snapshot = await usersRef.GetSnapshotAsync(); foreach (DocumentSnapshot document in snapshot.Documents) { Console.WriteLine("User: {0}", document.Id); Dictionary<string, object> documentDictionary = document.ToDictionary(); Console.WriteLine("First: {0}", documentDictionary["First"]); if (documentDictionary.ContainsKey("Middle")) { Console.WriteLine("Middle: {0}", documentDictionary["Middle"]); } Console.WriteLine("Last: {0}", documentDictionary["Last"]); Console.WriteLine("Born: {0}", documentDictionary["Born"]); Console.WriteLine(); }
Rubis
users_ref = firestore.col collection_path users_ref.get do |user| puts "#{user.document_id} data: #{user.data}." end
Sécurisez vos données
Si vous utilisez le SDK Web, Android ou iOS, utilisez l' authentification Firebase et les règles de sécurité Cloud Firestore pour sécuriser vos données dans Cloud Firestore.
Voici quelques ensembles de règles de base que vous pouvez utiliser pour commencer. Vous pouvez modifier vos règles de sécurité dans l' onglet Règles de la console.
Auth requise
// Allow read/write access on all documents to any user signed in to the application
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if request.auth != null;
}
}
}
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;
}
}
}
Mode d'essai
// Allow read/write access to all users under any conditions
// Warning: **NEVER** use this rule set in production; it allows
// anyone to overwrite your entire database.
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if true;
}
}
}
Si vous utilisez l'un des SDK du serveur, utilisez Identity and Access Management (IAM) pour sécuriser vos données dans Cloud Firestore.
Regardez un didacticiel vidéo
Pour obtenir des conseils détaillés sur la mise en route des bibliothèques clientes mobiles et Web Cloud Firestore, regardez l'un des didacticiels vidéo suivants:
Web v8
iOS
Android
Vous pouvez trouver plus de vidéos sur la chaîne YouTube Firebase.
Prochaines étapes
Approfondissez vos connaissances avec les sujets suivants:
- Codelabs - Apprenez à utiliser Cloud Firestore dans une vraie application 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 - Découvrez comment récupérer des données.
- Effectuer des requêtes simples et composées - Apprenez à exécuter des requêtes simples et composées.
- Ordonner et limiter les requêtes Découvrez comment commander et limiter les données renvoyées par vos requêtes.