Cloud Firestore-Datenpakete sind statische Datendateien, die von Ihnen aus Dokumenten- und Abfrage-Snapshots von Cloud Firestore erstellt und von Ihnen auf einem CDN, Hosting-Dienst oder einer anderen Lösung veröffentlicht werden. Datenpakete enthalten sowohl die Dokumente, die Sie Ihren Client-Apps bereitstellen möchten, als auch Metadaten zu den Abfragen, die sie generiert haben. Sie verwenden Client-SDKs, um Bundles über das Netzwerk oder aus dem lokalen Speicher herunterzuladen, und laden anschließend Bundle-Daten in den lokalen Cache von Cloud Firestore. Sobald ein Bundle geladen ist, kann eine Client-App Dokumente aus dem lokalen Cache oder dem Back-End abfragen.
Mit Datenpaketen können Ihre Apps die Ergebnisse häufiger Abfragen früher laden, da Dokumente beim Start verfügbar sind, ohne dass Aufrufe an das Cloud Firestore-Back-End erforderlich sind. Wenn Ergebnisse aus dem lokalen Cache geladen werden, profitieren Sie außerdem von reduzierten Zugriffskosten. Anstatt für eine Million App-Instanzen zu bezahlen, um die gleichen anfänglichen 100 Dokumente abzufragen, zahlen Sie nur für die Abfragen, die zum Bündeln dieser 100 Dokumente erforderlich sind.
Cloud Firestore-Datenpakete sind so konzipiert, dass sie gut mit anderen Firebase-Back-End-Produkten zusammenarbeiten. Sehen Sie sich eine integrierte Lösung an, in der Bundles von Cloud Functions erstellt und Benutzern mit Firebase Hosting bereitgestellt werden.
Die Verwendung eines Bundles mit Ihrer App umfasst drei Schritte:
- Erstellen des Bundles mit dem Admin SDK
- Bereitstellen des Pakets aus dem lokalen Speicher oder aus einem CDN
- Bundles im Client laden
Was ist ein Datenpaket?
Ein Datenpaket ist eine statische Binärdatei, die von Ihnen erstellt wurde, um ein oder mehrere Dokument- und/oder Abfrage-Snapshots zu packen, und aus der Sie benannte Abfragen extrahieren können. Wie wir weiter unten besprechen, können Sie mit serverseitigen SDKs Bundles erstellen, und Client-SDKs stellen Methoden bereit, mit denen Sie Bundles in den lokalen Cache laden können.
Benannte Abfragen sind eine besonders leistungsstarke Funktion von Bundles. Benannte Abfragen sind Query , die Sie aus einem Bundle extrahieren und dann sofort verwenden können, um Daten entweder aus dem Cache oder aus dem Back-End abzufragen, wie Sie es normalerweise in jedem Teil Ihrer App tun, der mit Cloud Firestore kommuniziert.
Aufbau von Datenbündeln auf dem Server
Mit dem Node.js- oder Java Admin-SDK haben Sie die vollständige Kontrolle darüber, was in den Paketen enthalten sein soll und wie sie bereitgestellt werden.
Node.js
var bundleId = "latest-stories";
var bundle = firestore.bundle(bundleId);
var docSnapshot = await firestore.doc('stories/stories').get();
var querySnapshot = await firestore.collection('stories').get();
// Build the bundle
// Note how querySnapshot is named "latest-stories-query"
var bundleBuffer = bundle.add(docSnapshot); // Add a document
.add('latest-stories-query', querySnapshot) // Add a named query.
.build()
Java
Firestore db = FirestoreClient.getFirestore(app);
// Query the 50 latest stories
QuerySnapshot latestStories = db.collection("stories")
.orderBy("timestamp", Direction.DESCENDING)
.limit(50)
.get()
.get();
// Build the bundle from the query results
FirestoreBundle bundle = db.bundleBuilder("latest-stories")
.add("latest-stories-query", latestStories)
.build();
Python
from google.cloud import firestore
from google.cloud.firestore_bundle import FirestoreBundle
db = firestore.Client()
bundle = FirestoreBundle("latest-stories")
doc_snapshot = db.collection("stories").document("news-item").get()
query = db.collection("stories")._query()
# Build the bundle
# Note how `query` is named "latest-stories-query"
bundle_buffer: str = bundle.add_document(doc_snapshot).add_named_query(
"latest-stories-query", query,
).build()
Bereitstellung von Datenpaketen
Sie können Bundles für Ihre Client-Apps von einem CDN bereitstellen oder sie beispielsweise von Cloud Storage herunterladen.
Angenommen, das im vorherigen Abschnitt erstellte Bundle wurde in einer Datei namens bundle.txt gespeichert und auf einem Server bereitgestellt. Diese Bundle-Datei ist wie jedes andere Asset, das Sie über das Internet bereitstellen können, wie hier für eine einfache Node.js Express-App gezeigt.
const fs = require('fs');
const server = require('http').createServer();
server.on('request', (req, res) => {
const src = fs.createReadStream('./bundle.txt');
src.pipe(res);
});
server.listen(8000);
Laden von Datenpaketen im Client
Sie laden Firestore-Bundles, indem Sie sie von einem Remote-Server abrufen, sei es durch eine HTTP-Anfrage, Aufrufen einer Speicher-API oder mithilfe einer anderen Technik zum Abrufen von Binärdateien in einem Netzwerk.
Nach dem Abrufen ruft Ihre App mit dem Cloud Firestore-Client-SDK die Methode loadBundle auf, die ein Aufgabenverfolgungsobjekt zurückgibt, dessen Abschluss Sie ähnlich wie den Status eines Promise überwachen können. Nach erfolgreichem Abschluss der Bundle-Ladeaufgabe sind Bundle-Inhalte im lokalen Cache verfügbar.
Netz
// If you are using module bundlers.
import firebase from "firebase/app";
import "firebase/firestore";
import "firebase/firestore/bundle"; // This line enables bundle loading as a side effect.
// ...
async function fetchFromBundle() {
// Fetch the bundle from Firebase Hosting, if the CDN cache is hit the 'X-Cache'
// response header will be set to 'HIT'
const resp = await fetch('/createBundle');
// Load the bundle contents into the Firestore SDK
await db.loadBundle(resp.body);
// Query the results from the cache
// Note: omitting "source: cache" will query the Firestore backend.
const query = await db.namedQuery('latest-stories-query');
const storiesSnap = await query.get({ source: 'cache' });
// Use the results
// ...
}Schnell
// Utility function for errors when loading bundles.
func bundleLoadError(reason: String) -> NSError {
return NSError(domain: "FIRSampleErrorDomain",
code: 0,
userInfo: [NSLocalizedFailureReasonErrorKey: reason])
}
// Loads a remote bundle from the provided url.
func fetchRemoteBundle(for firestore: Firestore,
from url: URL,
completion: @escaping ((Result<LoadBundleTaskProgress, Error>) -> ())) {
guard let inputStream = InputStream(url: url) else {
let error = self.bundleLoadError(reason: "Unable to create stream from the given url: \(url)")
completion(.failure(error))
return
}
// The return value of this function is ignored, but can be used for more granular
// bundle load observation.
let _ = firestore.loadBundle(inputStream) { (progress, error) in
switch (progress, error) {
case (.some(let value), .none):
if value.state == .success {
completion(.success(value))
} else {
let concreteError = self.bundleLoadError(
reason: "Expected bundle load to be completed, but got \(value.state) instead"
)
completion(.failure(concreteError))
}
case (.none, .some(let concreteError)):
completion(.failure(concreteError))
case (.none, .none):
let concreteError = self.bundleLoadError(reason: "Operation failed, but returned no error.")
completion(.failure(concreteError))
case (.some(let value), .some(let concreteError)):
let concreteError = self.bundleLoadError(
reason: "Operation returned error \(concreteError) with nonnull progress: \(value)"
)
completion(.failure(concreteError))
}
}
}
// Fetches a specific named query from the provided bundle.
func loadQuery(named queryName: String,
fromRemoteBundle bundleURL: URL,
with store: Firestore,
completion: @escaping ((Result<Query, Error>) -> ())) {
fetchRemoteBundle(for: store,
from: bundleURL) { (result) in
switch result {
case .success:
store.getQuery(named: queryName) { query in
if let query = query {
completion(.success(query))
} else {
completion(
.failure(
self.bundleLoadError(reason: "Could not find query named \(queryName)")
)
)
}
}
case .failure(let error):
completion(.failure(error))
}
}
}
// Load a query and fetch its results from a bundle.
func runStoriesQuery() {
let queryName = "latest-stories-query"
let firestore = Firestore.firestore()
let remoteBundle = URL(string: "https://example.com/createBundle")!
loadQuery(named: queryName,
fromRemoteBundle: remoteBundle,
with: firestore) { (result) in
switch result {
case .failure(let error):
print(error)
case .success(let query):
query.getDocuments { (snapshot, error) in
// handle query results
}
}
}
}Ziel c
// Utility function for errors when loading bundles.
- (NSError *)bundleLoadErrorWithReason:(NSString *)reason {
return [NSError errorWithDomain:@"FIRSampleErrorDomain"
code:0
userInfo:@{NSLocalizedFailureReasonErrorKey: reason}];
}
// Loads a remote bundle from the provided url.
- (void)fetchRemoteBundleForFirestore:(FIRFirestore *)firestore
fromURL:(NSURL *)url
completion:(void (^)(FIRLoadBundleTaskProgress *_Nullable,
NSError *_Nullable))completion {
NSInputStream *inputStream = [NSInputStream inputStreamWithURL:url];
if (inputStream == nil) {
// Unable to create input stream.
NSError *error =
[self bundleLoadErrorWithReason:
[NSString stringWithFormat:@"Unable to create stream from the given url: %@", url]];
completion(nil, error);
return;
}
[firestore loadBundleStream:inputStream
completion:^(FIRLoadBundleTaskProgress * _Nullable progress,
NSError * _Nullable error) {
if (progress == nil) {
completion(nil, error);
return;
}
if (progress.state == FIRLoadBundleTaskStateSuccess) {
completion(progress, nil);
} else {
NSError *concreteError =
[self bundleLoadErrorWithReason:
[NSString stringWithFormat:
@"Expected bundle load to be completed, but got %ld instead",
(long)progress.state]];
completion(nil, concreteError);
}
completion(nil, nil);
}];
}
// Loads a bundled query.
- (void)loadQueryNamed:(NSString *)queryName
fromRemoteBundleURL:(NSURL *)url
withFirestore:(FIRFirestore *)firestore
completion:(void (^)(FIRQuery *_Nullable, NSError *_Nullable))completion {
[self fetchRemoteBundleForFirestore:firestore
fromURL:url
completion:^(FIRLoadBundleTaskProgress *progress, NSError *error) {
if (error != nil) {
completion(nil, error);
return;
}
[firestore getQueryNamed:queryName completion:^(FIRQuery *query) {
if (query == nil) {
NSString *errorReason =
[NSString stringWithFormat:@"Could not find query named %@", queryName];
NSError *error = [self bundleLoadErrorWithReason:errorReason];
completion(nil, error);
return;
}
completion(query, nil);
}];
}];
}
- (void)runStoriesQuery {
NSString *queryName = @"latest-stories-query";
FIRFirestore *firestore = [FIRFirestore firestore];
NSURL *bundleURL = [NSURL URLWithString:@"https://example.com/createBundle"];
[self loadQueryNamed:queryName
fromRemoteBundleURL:bundleURL
withFirestore:firestore
completion:^(FIRQuery *query, NSError *error) {
// Handle query results
}];
}Kotlin+KTX
@Throws(IOException::class)
fun getBundleStream(urlString: String?): InputStream {
val url = URL(urlString)
val connection = url.openConnection() as HttpURLConnection
return connection.inputStream
}
@Throws(IOException::class)
fun fetchFromBundle() {
val bundleStream = getBundleStream("https://example.com/createBundle")
val loadTask = db.loadBundle(bundleStream)
// Chain the following tasks
// 1) Load the bundle
// 2) Get the named query from the local cache
// 3) Execute a get() on the named query
loadTask.continueWithTask<Query> { task ->
// Close the stream
bundleStream.close()
// Calling .result propagates errors
val progress = task.getResult(Exception::class.java)
// Get the named query from the bundle cache
db.getNamedQuery("latest-stories-query")
}.continueWithTask { task ->
val query = task.getResult(Exception::class.java)!!
// get() the query results from the cache
query.get(Source.CACHE)
}.addOnCompleteListener { task ->
if (!task.isSuccessful) {
Log.w(TAG, "Bundle loading failed", task.exception)
return@addOnCompleteListener
}
// Get the QuerySnapshot from the bundle
val storiesSnap = task.result
// Use the results
// ...
}
}Java
public InputStream getBundleStream(String urlString) throws IOException {
URL url = new URL(urlString);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
return connection.getInputStream();
}
public void fetchBundleFrom() throws IOException {
final InputStream bundleStream = getBundleStream("https://example.com/createBundle");
LoadBundleTask loadTask = db.loadBundle(bundleStream);
// Chain the following tasks
// 1) Load the bundle
// 2) Get the named query from the local cache
// 3) Execute a get() on the named query
loadTask.continueWithTask(new Continuation<LoadBundleTaskProgress, Task<Query>>() {
@Override
public Task<Query> then(@NonNull Task<LoadBundleTaskProgress> task) throws Exception {
// Close the stream
bundleStream.close();
// Calling getResult() propagates errors
LoadBundleTaskProgress progress = task.getResult(Exception.class);
// Get the named query from the bundle cache
return db.getNamedQuery("latest-stories-query");
}
}).continueWithTask(new Continuation<Query, Task<QuerySnapshot>>() {
@Override
public Task<QuerySnapshot> then(@NonNull Task<Query> task) throws Exception {
Query query = task.getResult(Exception.class);
// get() the query results from the cache
return query.get(Source.CACHE);
}
}).addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
@Override
public void onComplete(@NonNull Task<QuerySnapshot> task) {
if (!task.isSuccessful()) {
Log.w(TAG, "Bundle loading failed", task.getException());
return;
}
// Get the QuerySnapshot from the bundle
QuerySnapshot storiesSnap = task.getResult();
// Use the results
// ...
}
});
}C++
db->LoadBundle("bundle_name", [](const LoadBundleTaskProgress& progress) {
switch(progress.state()) {
case LoadBundleTaskProgress::State::kError: {
// The bundle load has errored. Handle the error in the returned future.
return;
}
case LoadBundleTaskProgress::State::kInProgress: {
std::cout << "Bytes loaded from bundle: " << progress.bytes_loaded()
<< std::endl;
break;
}
case LoadBundleTaskProgress::State::kSuccess: {
std::cout << "Bundle load succeeeded" << std::endl;
break;
}
}
}).OnCompletion([db](const Future<LoadBundleTaskProgress>& future) {
if (future.error() != Error::kErrorOk) {
// Handle error...
return;
}
const std::string& query_name = "latest_stories_query";
db->NamedQuery(query_name).OnCompletion([](const Future<Query>& query_future){
if (query_future.error() != Error::kErrorOk) {
// Handle error...
return;
}
const Query* query = query_future.result();
query->Get().OnCompletion([](const Future<QuerySnapshot> &){
// ...
});
});
});Beachten Sie, dass Sie, wenn Sie eine benannte Abfrage aus einem Bündel laden, das vor weniger als 30 Minuten erstellt wurde, nachdem Sie sie zum Lesen aus dem Backend und nicht aus dem Cache verwendet haben, nur für Datenbanklesevorgänge bezahlen müssen, die zum Aktualisieren von Dokumenten erforderlich sind, damit sie mit dem übereinstimmen, was im Backend gespeichert ist ; Das heißt, Sie zahlen nur für die Deltas.
Was als nächstes?
Weitere Informationen finden Sie in der Referenzdokumentation zur Datenbündel-API für die Clientseite ( Apple , Android , Web ) und die Serverseite ( Node.js ).
Wenn Sie es noch nicht getan haben, werfen Sie einen Blick auf die Cloud Functions- und Firebase-Hosting-Lösung zum Erstellen und Bereitstellen von Paketen .