原生模式下的 Cloud Firestore 企业版现已推出！了解详情。

Premiers pas avec l'édition Enterprise de Cloud Firestore

Ce guide de démarrage rapide vous explique comment configurer Cloud Firestore Enterprise Edition, ajouter des données, puis utiliser les opérations de base ou les opérations de pipeline pour interroger les données que vous venez d'ajouter dans la console Firebase.

Cloud Firestore est compatible avec les SDK mobiles ou Web et les bibliothèques clientes serveur :

Cloud Firestore est compatible avec les SDK pour Android, iOS, le Web et plus encore. Combinés à Cloud Firestore Security Rules et Firebase Authentication, les SDK mobiles et Web sont compatibles avec les architectures d'applications sans serveur dans lesquelles les clients se connectent directement à votre base de données Cloud Firestore.
Cloud Firestore est compatible avec les bibliothèques clientes serveur pour Java, Node.js et Python. Utilisez ces bibliothèques clientes pour configurer des environnements serveur privilégiés avec un accès complet à votre base de données. Pour en savoir plus sur ces bibliothèques, consultez le guide de démarrage rapide pour les bibliothèques clientes serveur.

Créer une base de données Cloud Firestore Enterprise Edition

Si vous ne l'avez pas encore 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 ajouter des services Firebase à un projet Google Cloud existant.
Ouvrez votre projet dans la console Firebase. Dans le panneau de gauche, développez Créer, puis sélectionnez Base de données Firestore.
Cliquez sur Créer une base de données.
Sélectionnez Enterprise (Entreprise) pour le mode de base de données.
Sélectionnez Firestore en mode natif pour le mode de fonctionnement, qui est compatible avec les opérations de base et de pipeline.

Remarque : Vous pouvez créer une base de données en mode natif ou en mode de compatibilité MongoDB. Pour en savoir plus sur le mode de compatibilité MongoDB, consultez le guide de démarrage rapide pour créer des bases de données compatibles avec MongoDB.
Sélectionnez un emplacement pour la base de données.
Sélectionnez un mode de départ 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 SDK Web, Apple Platforms ou Android, sélectionnez le mode test.

Mode production

Refuse tous les accès en lecture et en écriture des clients mobiles et Web. Vos serveurs d'application authentifiés (Python) peuvent toujours accéder à votre base de données.

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.

Cloud Firestore et App Engine : grâce à la compatibilité avec plusieurs bases de données, vous pouvez utiliser à la fois Cloud Firestore Enterprise Edition et Datastore dans le même projet. Si vous utilisez App Engine, notez que seule la base de données (default) en mode standard avec les API Datastore ou Firestore en mode natif peut être utilisée avec App Engine.

Lorsque vous activez l'édition Cloud Firestore Enterprise, cela active également l'API dans le 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.

Le SDK Cloud Firestore est disponible en tant que package npm.

npm install firebase@12.9.0 --save

Vous devez importer Firebase et Cloud Firestore.

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 :

  https://github.com/firebase/firebase-ios-sdk

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.

Android

Suivez les instructions pour ajouter Firebase à votre application Android.
À l'aide de la nomenclature Firebase Android, déclarez la dépendance pour la bibliothèque Cloud Firestore pour Android dans le fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle.kts ou app/build.gradle).
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.8.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")
}
```
Avec la nomenclature Firebase Android, 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 le BoM

Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier la version de chaque bibliothèque Firebase sur 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 des bibliothèques, 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:26.1.0")
}
```
Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir de la version d'octobre 2023, les développeurs Kotlin et Java peuvent s'appuyer sur le module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).

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


// When initializing Firestore, remember to use the name of the database you created earlier:
const db = initializeFirestore(app, {}, 'your-new-enterprise-database');

Remplacez FIREBASE_CONFIGURATION par le 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()

// When initializing Firestore, remember to use the name of the database you created earlier:
let db = Firestore.firestore(database: "your-new-enterprise-database")

Kotlin

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
val firestore = FirebaseFirestore.getInstance("your-new-enterprise-database")

Java

// Access a Cloud Firestore instance from your Activity
// When initializing Firestore, remember to use the name of the database you created earlier:
FirebaseFirestore firestore = FirebaseFirestore.getInstance("your-new-enterprise-database");

Ajouter des données à l'aide des opérations Core

Pour explorer les opérations Core et de pipeline permettant d'interroger des données, ajoutez des données à votre base de données à l'aide des opérations Core.

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);
}add_ada_lovelace.js

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);
});test.firestore.js

Swift

Remarque : Ce produit n'est pas disponible sur les cibles watchOS et App Clip.

// 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)")
}ViewController.swift

Kotlin

// 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)
    }DocSnippets.kt

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);
            }
        });DocSnippets.java

À 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);
}add_alan_turing.js

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);
});test.firestore.js

Swift

Remarque : Ce produit n'est pas disponible sur les cibles watchOS et App Clip.

// 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)")
}ViewController.swift

Kotlin

// 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)
    }DocSnippets.kt

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);
            }
        });DocSnippets.java

Lire des données à l'aide d'opérations de base

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()}`);
});get_all_users.js

Web

db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});test.firestore.js

Swift

Remarque : Ce produit n'est pas disponible sur les cibles watchOS et App Clip.

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)")
}ViewController.swift

Kotlin

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)
    }DocSnippets.kt

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());
                }
            }
        });DocSnippets.java

Lire des données à l'aide d'opérations de pipeline

Vous pouvez désormais comparer l'expérience des requêtes de pipeline à celle des requêtes principales.

Web

// The import/require of "firebase/firestore/pipelines" has a side-effect
// of extending the Firestore class with the `.pipeline()` method.
// Without this import/require, you will not be able to create a Pipeline.
// import { execute } from "firebase/firestore/pipelines";
const readDataPipeline = db.pipeline()
  .collection("users");

// Execute the pipeline and handle the result
try {
  const querySnapshot = await execute(readDataPipeline);
  querySnapshot.results.forEach((result) => {
    console.log(`${result.id} => ${result.data()}`);
  });
} catch (error) {
    console.error("Error getting documents: ", error);
}test.firestore.js

Swift

do {
  // Initialize a Firestore Pipeline instance and specify the "users" collection as the
  // input stage.
  let snapshot = try await db.pipeline()
    .collection("users")
    .execute() // Execute the pipeline to retrieve documents.

  // Iterate through the documents in the pipeline results, similar to a regular query
  // snapshot.
  for result in snapshot.results {
    print("\(result.id ?? "no ID") => \(result.data)")
  }
} catch {
  print("Error getting documents with pipeline: \(error)")
}PipelineSnippets.swift

Kotlin

val readDataPipeline = db.pipeline()
    .collection("users")

// Execute the pipeline and handle the result
readDataPipeline.execute()
    .addOnSuccessListener { result ->
        for (document in result) {
            println("${document.getId()} => ${document.getData()}")
        }
    }
    .addOnFailureListener { exception ->
        println("Error getting documents: $exception")
    }DocSnippets.kt

Java

Pipeline readDataPipeline = db.pipeline()
.collection("users");

readDataPipeline.execute()
.addOnSuccessListener(new OnSuccessListener<Pipeline.Snapshot>() {
    @Override
    public void onSuccess(Pipeline.Snapshot snapshot) {
        for (PipelineResult result : snapshot.getResults()) {
            System.out.println(result.getId() + " => " + result.getData());
        }
    }
})
.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        System.out.println("Error getting documents: " + e);
    }
});

Sécuriser vos données pour les SDK mobiles et Web

Si vous utilisez le SDK des 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 production

// 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 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.

Étapes suivantes

Approfondissez vos connaissances sur les opérations Core et de pipeline en consultant les sujets suivants :

En savoir plus sur l'interrogation avec les opérations de base
En savoir plus sur l'envoi de requêtes avec les opérations de pipeline

Premiers pas avec l'édition Enterprise de Cloud Firestore Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Créer une base de données Cloud Firestore Enterprise Edition

Configurer l'environnement de développement

Web

iOS+

Android

Initialiser Cloud Firestore

Web

Swift

Kotlin

Java

Ajouter des données à l'aide des opérations Core

Web

Web

Swift

Kotlin

Java

Web

Web

Swift

Kotlin

Java

Lire des données à l'aide d'opérations de base

Web

Web

Swift

Kotlin

Java

Lire des données à l'aide d'opérations de pipeline

Web

Swift

Kotlin

Java

Sécuriser vos données pour les SDK mobiles et Web

Authentification requise

Mode production

Étapes suivantes

Premiers pas avec l'édition Enterprise de Cloud Firestore