Premiers pas avec Cloud Firestore

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

  1. Si vous n'avez pas déjà, 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 d'ajouter des services Firebase à un projet GCP existant.

  2. Accédez à la section Nuage Firestore de la console Firebase . Vous serez invité à sélectionner un projet Firebase existant. Suivez le workflow de création de la base de données.

  3. Sélectionnez un mode de démarrage pour vos règles de sécurité Cloud Firestore :

    Mode d'essai

    Bon pour démarrer avec les bibliothèques clientes mobiles et Web, mais permet à n'importe qui de lire et d'écraser vos données. Après avoir testé, assurez - vous d'examiner la sécurité de vos données section.

    Pour commencer avec le Web, iOS ou Android SDK, 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 avec la bibliothèque cliente du serveur C#, Go, Java, Node.js, PHP, Python ou Ruby, sélectionnez le mode verrouillé.

  4. Sélectionnez un emplacement pour votre base de données.

    • Ce paramètre de votre emplacement est de projet par défaut de Google Cloud Platform (GCP) Emplacement des ressources . Notez que cet endroit sera utilisé pour les services de GCP dans votre projet qui nécessite un paramètre d'emplacement, en particulier, votre défaut Cloud Storage seau et votre App Engine application ( ce qui est nécessaire si vous utilisez Nuage 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 soit lors de la création du projet, soit lors de la configuration d'un autre service nécessitant un paramètre d'emplacement.

  5. Cliquez sur Terminé.

Lorsque vous activez Nuage Firestore, il permet également l'API dans l' API Cloud Manager .

Configurer votre environnement de développement

Ajoutez les dépendances et les bibliothèques clientes requises à votre application.

Web version 8

  1. Suivez les instructions pour ajouter Firebase à votre application Web .
  2. Ajouter les Firebase et Cloud bibliothèques FireStore à votre application:
    <script src="https://www.gstatic.com/firebasejs/9.1.0/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/9.1.0/firebase-firestore.js"></script>
    Cloud SDK Firestore est également disponible en tant que package NPM.
    npm install firebase@9.1.0 --save
    
    Vous aurez besoin d'exiger manuellement à la fois Firebase et Cloud Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    

Web version 9

  1. Suivez les instructions pour ajouter Firebase à votre application Web .
  2. Le SDK Cloud Firestore est disponible sous forme de package npm.
    npm install firebase@9.1.0 --save
    
    Vous aurez besoin d'importer à la fois Firebase et Cloud Firestore.
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";
    
iOS
  1. Suivez les instructions pour ajouter Firebase à votre application iOS .
  2. Ajouter le pod Nuage Firestore à votre Podfile
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Enregistrez le fichier et lancez pod install .

Java

  1. Suivez les instructions pour ajouter Firebase à votre application Android .
  2. Utilisation de la Firebase Android BoM , déclarer la dépendance de la bibliothèque - Cloud Firestore Android dans votre module (app-niveau) de fichier Gradle (généralement app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.4.1')
    
        // 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 le Firebase Android BoM , votre application utilise toujours des versions compatibles des bibliothèques Firebase Android.

    (Alternative) déclarer des dépendances de bibliothèque firebase sans utiliser la nomenclature

    Si vous choisissez de ne pas utiliser la nomenclature de Firebase, 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 fortement d' utiliser la BoM pour gérer les versions 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:23.0.3'
    }
    

Kotlin+KTX

  1. Suivez les instructions pour ajouter Firebase à votre application Android .
  2. Utilisation de la Firebase Android BoM , déclarer la dépendance de la bibliothèque - Cloud Firestore Android dans votre module (app-niveau) de fichier Gradle (généralement app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.4.1')
    
        // 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 le Firebase Android BoM , votre application utilise toujours des versions compatibles des bibliothèques Firebase Android.

    (Alternative) déclarer des dépendances de bibliothèque firebase sans utiliser la nomenclature

    Si vous choisissez de ne pas utiliser la nomenclature de Firebase, 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 fortement d' utiliser la BoM pour gérer les versions 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:23.0.3'
    }
    
Java
  1. Ajoutez le SDK Firebase Admin à votre application :
    • En utilisant Gradle:
      compile 'com.google.firebase:firebase-admin:8.1.0'
      
    • En utilisant Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>8.1.0</version>
      </dependency>
           
  2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
Python
  1. Ajouter le Firebase Administrateur SDK à votre application Python:
    pip install --upgrade firebase-admin
  2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
C++
  1. Suivez les instructions pour ajouter Firebase à votre projet C ++ .
  2. Interface C++ pour Android.
    • Dépendances de Gradle. Ajouter ce qui suit à votre module (app-niveau) de fichier Gradle (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}")
              
  3. Pour configurer l'intégration de bureau, voir Ajouter Firebase à votre projet C ++ .
Unité
  1. Suivez les instructions pour ajouter Firebase à votre projet Unity .
  2. Interface Unity pour Android.
  3. Lors de la création pour Android, activez ProGuarding pour éviter la limite Android DEX. Pour cela, dans l'éditeur Unity :

    1. Sélectionnez Fichier > Paramètres de construction
    2. Basculez « Plateforme » sur « Android » et cliquez sur « Changer de plate-forme »
    3. Cliquez sur « Paramètres du lecteur… »
    4. Dans l'interface utilisateur principale de Unity, sous "Paramètres pour Android", sélectionnez "Paramètres de publication"
    5. Dans la section « minifier », modifiez les paramètres de publication et de débogage de « aucun » à « ProGuard »
Node.js
  1. Ajouter le Firebase Administrateur SDK à votre application:
    npm install firebase-admin --save
  2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
Aller
  1. Ajouter le Firebase Administrateur SDK à votre application Go:
    go get firebase.google.com/go
    
  2. Suivez les instructions ci-dessous pour initialiser Cloud Firestore avec les identifiants appropriés dans votre environnement.
PHP
  1. Les bibliothèques clientes du serveur cloud FireStore (Java, Node.js, Python, Go, PHP, C # et Ruby) utiliser Google application Identifiants par défaut pour l' authentification.
    • Pour authentifier à partir de votre environnement de développement, définissez la GOOGLE_APPLICATION_CREDENTIALS variable d'environnement pour pointer vers un fichier clé de compte de service JSON. Vous pouvez créer un fichier clé sur l' API page Informations d'identification de la console .
      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. Dans le cas contraire, mettre en place un compte de service .
  2. Installez et activez l' extension de GRPC pour PHP, que vous aurez besoin d'utiliser la bibliothèque cliente.
  3. Ajouter la bibliothèque Nuage Firestore PHP à votre application:
    composer require google/cloud-firestore
C#
  1. Les bibliothèques clientes du serveur cloud FireStore (Java, Node.js, Python, Go, PHP, C # et Ruby) utiliser Google application Identifiants par défaut pour l' authentification.
    • Pour authentifier à partir de votre environnement de développement, définissez la GOOGLE_APPLICATION_CREDENTIALS variable d'environnement pour pointer vers un fichier clé de compte de service JSON. Vous pouvez créer un fichier clé sur l' API page Informations d'identification de la console .
      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. Dans le cas contraire, mettre en place un compte de service .
  2. 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>
  3. Ajouter ce qui suit à votre Program.cs fichier:
    using Google.Cloud.Firestore;
Rubis
  1. Les bibliothèques clientes du serveur cloud FireStore (Java, Node.js, Python, Go, PHP, C # et Ruby) utiliser Google application Identifiants par défaut pour l' authentification.
    • Pour authentifier à partir de votre environnement de développement, définissez la GOOGLE_APPLICATION_CREDENTIALS variable d'environnement pour pointer vers un fichier clé de compte de service JSON. Vous pouvez créer un fichier clé sur l' API page Informations d'identification de la console .
      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. Dans le cas contraire, mettre en place un compte de service .
  2. Ajouter la bibliothèque Nuage Firestore Ruby à votre application dans votre Gemfile :
    gem "google-cloud-firestore"
  3. Installez les dépendances de votre Gemfile en utilisant:
    bundle install

(Facultatif) Prototyper et tester 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, introduisons un ensemble d'outils que vous pouvez utiliser pour prototyper et tester les fonctionnalités de 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 le moyen le plus rentable d'interagir avec le back-end, pouvoir travailler localement sans déployer de services en direct peut être une excellente idée.

Un émulateur Cloud Firestore fait partie de la suite d'émulateurs locaux, qui permet à votre application d'interagir avec le contenu et la configuration de votre base de données émulée, ainsi qu'éventuellement avec vos ressources de projet émulées (fonctions, autres bases de données et règles de sécurité).

L'utilisation de l'émulateur Cloud Firestore ne nécessite que quelques étapes :

  1. Ajout d'une ligne de code à la configuration de test de votre application pour vous connecter à l'émulateur.
  2. A partir de la racine de votre répertoire local du projet, en cours d' exécution firebase emulators:start .
  3. Passer des appels à partir du code prototype de votre application à l'aide d'un SDK de la plate-forme Cloud Firestore, comme d'habitude.

Un détail soluce impliquant des fonctions cloud FireStore et de nuages est disponible. Vous devriez aussi jeter un oeil à l' adoption Emulator locale Suite .

Initialiser Cloud Firestore

Initialisez une instance de Cloud Firestore :

Web version 8

// 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 votre application web ` firebaseConfig` . Pour conserver les données lorsque l'appareil perd sa connexion, voir le Activer les données hors ligne la documentation.

Web version 9

// Initialize Cloud Firestore through Firebase
import { initializeApp } from "firebase/app"
import { getFirestore } from "firebase/firestore"
const firebaseApp = initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

const db = getFirestore();
Les valeurs de `initializeApp` se trouvent dans votre application web ` firebaseConfig` . Pour conserver les données lorsque l'appareil perd sa connexion, voir le Activer les données hors ligne la documentation.
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. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, voir Initialiser le Admin SDK .
  • Initialiser sur Google Cloud Platform
    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();
    
  • Initialiser sur votre propre serveur

    Pour utiliser le SDK Firebase administrateur sur votre propre serveur, utilisez un compte de service .

    Aller à IAM et admin> 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. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, voir Initialiser le Admin SDK .
  • Initialiser sur Google Cloud Platform
    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()
    
  • Initialiser sur votre propre serveur

    Pour utiliser le SDK Firebase administrateur sur votre propre serveur, utilisez un compte de service .

    Aller à IAM et admin> 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()
    
  • 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 une référence complète, voir Initialiser le Admin SDK .
  • Initialiser sur Google Cloud Platform
    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.AsyncClient()
    
  • Initialiser sur votre propre serveur

    Pour utiliser le SDK Firebase administrateur sur votre propre serveur, utilisez un compte de service .

    Aller à IAM et admin> 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.AsyncClient()
    
  • 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 une référence complète, voir Initialiser le Admin SDK .
    • Initialiser sur les fonctions de Cloud
      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();
    • Initialiser sur votre propre serveur

      Pour utiliser le SDK Firebase administrateur sur votre propre serveur (ou tout autre environnement Node.js), utilisez un compte de service . Aller à IAM et admin> 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. Vous trouverez ci-dessous les méthodes les plus courantes. Pour une référence complète, voir Initialiser le Admin SDK .
  • Initialiser sur Google Cloud Platform
    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()
    
  • Initialiser sur votre propre serveur

    Pour utiliser le SDK Firebase administrateur sur votre propre serveur, utilisez un compte de service .

    Aller à IAM et admin> 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.
     */
    function setup_client_create()
    {
        // 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"
    
    # The `project_id` parameter is optional and represents which project the
    # client will act on behalf of. If not supplied, the client falls back to the
    # default project inferred from the environment.
    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.

    Web version 9

    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 version 8

    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
    })

    Python

    doc_ref = db.collection("users").document("alovelace")
    await doc_ref.set({"first": "Ada", "last": "Lovelace", "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('samples/php/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."

    Maintenant , ajoutez un autre document à l' users collection. 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.

    Web version 9

    // 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 version 8

    // 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
    })

    Python

    doc_ref = db.collection("users").document("aturing")
    await doc_ref.set(
        {"first": "Alan", "middle": "Mathison", "last": "Turing", "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('samples/php/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 l'intégralité de la collection.

    Web version 9

    import { collection, getDocs } from "firebase/firestore"; 
    
    const querySnapshot = await getDocs(collection(db, "users"));
    querySnapshot.forEach((doc) => {
      console.log(`${doc.id} => ${doc.data()}`);
    });

    Web version 8

    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()}')

    Python

    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    async 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('samples/php/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 Web, Android ou iOS SDK, utilisez Firebase d' authentification et de Cloud FireStore Règles de sécurité pour sécuriser vos données en nuage 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.

    Authentification 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 serveurs SDKs, l' utilisation gestion des identités et des accès (IAM) pour sécuriser vos données en nuage Firestore.

    Regarder un didacticiel vidéo

    Pour obtenir des conseils détaillés sur la prise en main des bibliothèques clientes mobiles Cloud Firestore, regardez l'un des didacticiels vidéo suivants :

    iOS
    Android

    Vous pouvez trouver plus de vidéos dans la Firebase chaîne YouTube .

    Prochaines étapes

    Approfondissez vos connaissances avec les sujets suivants :

    • Codelabs - Apprenez à utiliser Nuage Firestore dans une véritable application en suivant la codelab pour Android , iOS ou Web .
    • Modèle de données - En savoir plus sur la structure des données du Cloud Firestore, y compris les données hiérarchiques et sous - collections.
    • Ajouter des données - En savoir plus sur la création et la mise à jour des données dans Cloud Firestore.
    • Obtenir des données - En savoir plus sur la façon de récupérer des données.
    • Effectuer des requêtes simples et composés - Apprenez à exécuter des requêtes simples et composés.
    • Requêtes de commande et de limiter savoir comment commander et limiter les données renvoyées par vos requêtes.