תחילת העבודה עם Cloud Firestore

במדריך למתחילים הזה נסביר איך מגדירים את Cloud Firestore, מוסיפים נתונים ומציגים את הנתונים שנוספו במסוף Firebase.

יצירת מסד נתונים של Cloud Firestore

  1. אם עדיין לא עשיתם זאת, יוצרים פרויקט ב-Firebase: במסוף Firebase, לוחצים על Add project (הוספת פרויקט) ופועלים לפי ההוראות במסך כדי ליצור פרויקט ב-Firebase או להוסיף שירותי Firebase לפרויקט Google Cloud קיים.

  2. פותחים את הפרויקט במסוף Firebase. בחלונית הימנית, מרחיבים את הקטע Build ובוחרים באפשרות Firestore database.

  3. לוחצים על Create database.

  4. בוחרים מיקום למסד הנתונים.

    אם לא ניתן לבחור מיקום, סימן שהמיקום של משאבי Google Cloud שמוגדרים כברירת מחדל בפרויקט כבר הוגדר. לחלק מהמשאבים בפרויקט (כמו מכונה Cloud Firestore שמוגדרת כברירת מחדל) יש תלות משותפת במיקום, ואפשר להגדיר את המיקום שלהם במהלך יצירת הפרויקט או במהלך הגדרת שירות אחר שיש לו את אותה תלות במיקום.

  5. בוחרים מצב התחלה ל-Cloud Firestore Security Rules:

    מצב בדיקה

    מתאים לתחילת העבודה עם ספריות הלקוח לנייד ולאינטרנט, אבל מאפשר לכל אחד לקרוא את הנתונים ולכתוב עליהם. אחרי הבדיקה, חשוב לקרוא את הקטע אבטחת הנתונים.

    כדי להתחיל בעבודה עם האינטרנט, פלטפורמות Apple או Android SDK, בוחרים במצב בדיקה.

    מצב נעילה

    דחייה של כל פעולות הקריאה והכתיבה מלקוחות בנייד ומלקוחות אינטרנט. שרתי האפליקציות המאומתים (C#‎,‏ Go,‏ Java,‏ Node.js,‏ PHP,‏ Python או Ruby) עדיין יכולים לגשת למסד הנתונים.

    כדי להתחיל לעבוד עם ספריית הלקוח של השרת ב-C#‎,‏ Go,‏ Java,‏ Node.js,‏ PHP,‏ Python או Ruby, בוחרים במצב נעול.

    הקבוצה הראשונית של Cloud Firestore Security Rules תחול על מסד הנתונים Cloud Firestore שמוגדר כברירת מחדל. אם יוצרים כמה מסדי נתונים לפרויקט, אפשר לפרוס את Cloud Firestore Security Rules לכל מסד נתונים.

  6. לוחצים על יצירה.

כשמפעילים את Cloud Firestore, ה-API מופעל גם במנהל Cloud API.

הגדרת סביבת הפיתוח

מוסיפים לאפליקציה את יחסי התלות ואת ספריות הלקוח הנדרשים.

Web

  1. פועלים לפי ההוראות להוספת Firebase לאפליקציית האינטרנט.
  2. מוסיפים לאפליקציה את הספריות Firebase ו-Cloud Firestore: 
    <script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-app-compat.js"></script>
<script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-firestore-compat.js"></script>
    ה-SDK של Cloud Firestore זמין גם כחבילת npm. 
    npm install firebase@11.0.2 --save
    צריך לדרוש באופן ידני גם את Firebase וגם את Cloud Firestore. 
    import firebase from "firebase/compat/app";
// Required for side-effects
import "firebase/firestore";

Web

  1. פועלים לפי ההוראות להוספת Firebase לאפליקציית האינטרנט.
  2. ערכת ה-SDK של Cloud Firestore זמינה כחבילת npm. 
    npm install firebase@11.0.2 --save
    תצטרכו לייבא גם את Firebase וגם את Cloud Firestore. 
    import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";
iOS+

פועלים לפי ההוראות להוספת Firebase לאפליקציה ל-Apple.

שימוש ב-Swift Package Manager כדי להתקין ולנהל יחסי תלות ב-Firebase.

  1. ב-Xcode, כשפרויקט האפליקציה פתוח, עוברים אל File > Swift Packages > Add Package Dependency.
  2. כשמופיעה בקשה, מוסיפים את המאגר של Firebase SDK לפלטפורמות Apple:
    3.   https://github.com/firebase/firebase-ios-sdk
  3. בוחרים את הספרייה של Firestore.
  4. בסיום, Xcode יתחיל לפתור את יחסי התלות ולהוריד אותם באופן אוטומטי ברקע.
Android
  1. פועלים לפי ההוראות להוספת Firebase לאפליקציה ל-Android.
  2. באמצעות Firebase Android BoM, מגדירים את התלות בספרייה Cloud Firestore ל-Android בקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל מדובר בקובץ app/build.gradle.kts או בקובץ app/build.gradle). 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.6.0"))

    // Declare the dependency for the Cloud Firestore library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-firestore")
}

    כשמשתמשים ב-Firebase Android BoM, תמיד נעשה שימוש בגרסאות תואמות של ספריות Firebase ל-Android באפליקציה.

    (חלופה) הצהרת יחסי תלות בספריות של Firebase בלי להשתמש ב-BoM

    אם בוחרים לא להשתמש ב-Firebase BoM, צריך לציין כל גרסה של ספריית Firebase בשורת התלות שלה.

    הערה: אם אתם משתמשים במספר ספריות של Firebase באפליקציה, מומלץ מאוד להשתמש ב-BoM כדי לנהל את הגרסאות של הספריות, וכך להבטיח שכל הגרסאות תואמות. 

    dependencies {
    // Declare the dependency for the Cloud Firestore library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-firestore:25.1.1")
}

    מחפשים מודול ספרייה ספציפי ל-Kotlin? החל מהגרסה שתפורסם באוקטובר 2023, מפתחי Kotlin ומפתחי Java יוכלו להסתמך על מודול הספרייה הראשי (פרטים נוספים זמינים בשאלות הנפוצות לגבי היוזמה הזו).

Dart

  1. אם עדיין לא עשיתם זאת, מגדירים ומפעילים את Firebase באפליקציית Flutter.
  2. כדי להתקין את הפלאגין, מריצים את הפקודה הבאה מהשורש של פרויקט Flutter: 
    flutter pub add cloud_firestore
  3. בסיום, יוצרים מחדש את אפליקציית Flutter: 
    flutter run
  4. אופציונלי: כדי לשפר את זמני ה-build של iOS ו-macOS, מוסיפים את המסגרת המתומצתת.

    נכון לעכשיו, ערכת ה-SDK של Firestore ל-iOS תלויה בקוד שיכול להימשך יותר מ-5 דקות ליצירה ב-Xcode. כדי לקצר את זמני ה-build באופן משמעותי, אפשר להשתמש בגרסה שעבר קומפילציה מראש. לשם כך, מוסיפים את השורה הבאה לבלוק target 'Runner' do ב-Podfile:

    target 'Runner' do
  use_frameworks!
  use_modular_headers!

  pod 'FirebaseFirestore',
    :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git',
    :tag => 'IOS_SDK_VERSION'

  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
  target 'RunnerTests' do
    inherit! :search_paths
  end
end

    מחליפים את הערך של IOS_SDK_VERSION בגרסה של Firebase iOS SDK שצוינה בקובץ firebase_sdk_version.rb של firebase_core. אם אתם לא משתמשים בגרסה האחרונה של firebase_core, חפשו את הקובץ הזה במטמון המקומי של חבילות Pub (בדרך כלל ~/.pub-cache).

    בנוסף, חשוב לוודא שדרגתם את CocoaPods לגרסה 1.9.1 ואילך: 

    gem install cocoapods

    מידע נוסף זמין בבעיה ב-GitHub.

Java
  1. מוסיפים את ה-SDK של Firebase לאדמינים לאפליקציה:
    • באמצעות Gradle: 
      compile 'com.google.firebase:firebase-admin:1.32.0'
    • באמצעות Maven: 
      <dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>1.32.0</version>
</dependency>
  2. פועלים לפי ההוראות הבאות כדי לאתחל את Cloud Firestore עם פרטי הכניסה המתאימים בסביבה שלכם.
Python
  1. מוסיפים את ה-SDK של Firebase לאדמינים לאפליקציית Python: 
    pip install --upgrade firebase-admin
  2. פועלים לפי ההוראות הבאות כדי לאתחל את Cloud Firestore עם פרטי הכניסה המתאימים בסביבה שלכם.
C++‎
  1. פועלים לפי ההוראות להוספת Firebase לפרויקט C++‎.
  2. ממשק C++ ל-Android
    • יחסי תלות ב-Gradle מוסיפים את הטקסט הבא לקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל 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
        }
    • יחסי תלות בין קבצים בינאריים באופן דומה, הדרך המומלצת לקבל את יחסי התלות הבינאריים היא להוסיף את הקוד הבא לקובץ CMakeLists.txt: 
              add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)
        set(firebase_libs firebase_auth firebase_firestore firebase_app)
        # Replace the target name below with the actual name of your target,
        # for example, "native-lib".
        target_link_libraries(${YOUR_TARGET_NAME_HERE} "${firebase_libs}")
  3. במאמר הוספת Firebase לפרויקט C++‎ מוסבר איך מגדירים שילוב למחשב.
Unity
  1. פועלים לפי ההוראות להוספת Firebase לפרויקט ב-Unity.
  2. משתמשים בממשק של Unity כדי להגדיר את הפרויקט לגרסת build ממוזערת ל-Android.

    3. כדי למנוע את ההודעה Error while merging dex archives, צריך לבצע אופטימיזציה של ה-build.

    • האפשרות הזו נמצאת בקטע הגדרות הנגן > Android > הגדרות פרסום > Minify.
    • האפשרויות עשויות להיות שונות בגרסאות שונות של Unity, לכן מומלץ לעיין במסמכי העזרה הרשמיים של Unity ובמדריך לניפוי באגים ב-Unity Build ב-Firebase.
    • אם אחרי הפעלת המינימיזציה מספר השיטות שמצוינות בהפניות עדיין חורג מהמגבלה, אפשרות אחרת היא להפעיל את multidex ב:
      • mainTemplate.gradle אם האפשרות Custom Gradle Template (תבנית Gradle מותאמת אישית) מופעלת בקטע Player Settings (הגדרות הנגן)
      • לחלופין, את הקובץ build.gradle ברמת המודול, אם משתמשים ב-Android Studio כדי ליצור את הפרויקט המיוצא.
Node.js
  1. מוסיפים את ה-SDK של Firebase לאדמינים לאפליקציה: 
    npm install firebase-admin --save
  2. פועלים לפי ההוראות הבאות כדי לאתחל את Cloud Firestore עם פרטי הכניסה המתאימים בסביבה שלכם.
Go
  1. מוסיפים את ה-SDK של Firebase לאדמינים לאפליקציית Go: 
    go get firebase.google.com/go
  2. פועלים לפי ההוראות הבאות כדי לאתחל את Cloud Firestore עם פרטי הכניסה המתאימים בסביבה שלכם.
PHP
  1. ספריות הלקוח של השרת Cloud Firestore (Java,‏ Node.js,‏ Python,‏ Go,‏ PHP,‏ C# ו-Ruby) משתמשות ב-Google Application Default Credentials לאימות.
    • כדי לבצע אימות מסביבת הפיתוח, מגדירים את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע לקובץ JSON של מפתח חשבון שירות. אפשר ליצור קובץ מפתח בדף Credentials במסוף API. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור, אין צורך לבצע אימות אם מריצים את האפליקציה ב-App Engine או ב-Compute Engine, באמצעות אותו פרויקט שבו משתמשים ב-Cloud Firestore. אחרת, מגדירים חשבון שירות.
  2. מתקינים ומפעילים את תוסף gRPC ל-PHP, שנחוץ כדי להשתמש בספריית הלקוח.
  3. מוסיפים לאפליקציה את ספריית PHP של Cloud Firestore: 
    composer require google/cloud-firestore
C#‎
  1. ספריות הלקוח של השרת Cloud Firestore (Java,‏ Node.js,‏ Python,‏ Go,‏ PHP,‏ C# ו-Ruby) משתמשות ב-Google Application Default Credentials לאימות.
    • כדי לבצע אימות מסביבת הפיתוח, מגדירים את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע לקובץ JSON של מפתח חשבון שירות. אפשר ליצור קובץ מפתח בדף Credentials במסוף API. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור, אין צורך לבצע אימות אם מריצים את האפליקציה ב-App Engine או ב-Compute Engine, באמצעות אותו פרויקט שבו משתמשים ב-Cloud Firestore. אחרת, מגדירים חשבון שירות.
  2. מוסיפים את ספריית Cloud Firestore ל-C# לאפליקציה בקובץ .csproj: 
    <ItemGroup>
  <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
</ItemGroup>
  3. מוסיפים את הטקסט הבא לקובץ Program.cs: 
    using Google.Cloud.Firestore;
Ruby
  1. ספריות הלקוח של השרת Cloud Firestore (Java,‏ Node.js,‏ Python,‏ Go,‏ PHP,‏ C# ו-Ruby) משתמשות ב-Google Application Default Credentials לאימות.
    • כדי לבצע אימות מסביבת הפיתוח, מגדירים את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע לקובץ JSON של מפתח חשבון שירות. אפשר ליצור קובץ מפתח בדף Credentials במסוף API. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור, אין צורך לבצע אימות אם מריצים את האפליקציה ב-App Engine או ב-Compute Engine, באמצעות אותו פרויקט שבו משתמשים ב-Cloud Firestore. אחרת, מגדירים חשבון שירות.
  2. מוסיפים את ספריית Cloud Firestore ל-Ruby לאפליקציה ב-Gemfile: 
    gem "google-cloud-firestore"
  3. מתקינים את שאר הספריות הדרושות לצורך יצירת ספריות הלקוח מ-Gemfile באמצעות: 
    bundle install

(אופציונלי) יצירת אב טיפוס ובדיקה באמצעות Firebase Local Emulator Suite

למפתחי אפליקציות לנייד: לפני שנדבר על האופן שבו האפליקציה שלכם כותבת ל-Cloud Firestore וקוראת ממנה, נציג לכם קבוצה של כלים שאפשר להשתמש בהם כדי ליצור אב טיפוס ולבדוק את הפונקציונליות של Cloud Firestore: Firebase Local Emulator Suite. אם אתם רוצים לנסות מודלים שונים של נתונים, לבצע אופטימיזציה של כללי האבטחה או למצוא את הדרך היעילה ביותר מבחינת עלות לאינטראקציה עם הקצה העורפי, יכול להיות שעבודה מקומית ללא פריסה של שירותים פעילים תהיה רעיון מצוין.

אמולטור של Cloud Firestore הוא חלק מ-Local Emulator Suite, שמאפשר לאפליקציה שלכם לקיים אינטראקציה עם תוכן ההגדרות של מסד הנתונים המאומלל, וגם עם משאבי הפרויקט המאומללים (פונקציות, מסדי נתונים אחרים וכללי אבטחה).

כדי להשתמש במהדמ של Cloud Firestore, צריך לבצע כמה שלבים פשוטים:

  1. הוספת שורת קוד להגדרות הבדיקה של האפליקציה כדי להתחבר למהדר.
  2. מריצים את firebase emulators:start ברמה הבסיסית של ספריית הפרויקט המקומית.
  3. ביצוע קריאות מקוד האב טיפוס של האפליקציה באמצעות SDK של פלטפורמת Cloud Firestore כרגיל.

יש הדרכה מפורטת שכוללת את Cloud Firestore ו-Cloud Functions. מומלץ גם לעיין במבוא ל-Local Emulator Suite.

אתחול של Cloud Firestore

מאתחלים מופע של Cloud Firestore:

Web

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = getFirestore(app);

מחליפים את FIREBASE_CONFIGURATION ב-firebaseConfig של אפליקציית האינטרנט.

כדי לשמור את הנתונים כשהמכשיר מאבד את החיבור, אפשר לעיין במסמכי העזרה בנושא הפעלת נתונים אופליין.

Web

import firebase from "firebase/app";
import "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
firebase.initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = firebase.firestore();

מחליפים את FIREBASE_CONFIGURATION ב-firebaseConfig של אפליקציית האינטרנט.

כדי לשמור את הנתונים כשהמכשיר מאבד את החיבור, אפשר לעיין במסמכי העזרה בנושא הפעלת נתונים אופליין.

Swift
הערה: המוצר הזה לא זמין ליעדים של watchOS ו-App Clip. 
import FirebaseCore
import FirebaseFirestore

FirebaseApp.configure()

let db = Firestore.firestore()
AppDelegate.swift
Objective-C
הערה: המוצר הזה לא זמין ליעדים של watchOS ו-App Clip. 
@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];
  
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
AppDelegate.m

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
DocSnippets.kt

Java

// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
DocSnippets.java

Dart

db = FirebaseFirestore.instance;
Java
ה-SDK של Cloud Firestore מופעל בדרכים שונות בהתאם לסביבה שלכם. בהמשך מפורטות השיטות הנפוצות ביותר. למידע מלא, ראו הפעלת Admin SDK.
  • איפוס ב-Google Cloud 
    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();
  • איך מפעילים את השירות בשרת משלכם

    כדי להשתמש ב-Firebase Admin SDK בשרת שלכם, צריך להשתמש בחשבון שירות.

    עוברים אל IAM & admin > Service accounts במסוף Google Cloud. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-JSON. לאחר מכן משתמשים בקובץ כדי לאתחל את ה-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
    ה-SDK של Cloud Firestore מופעל בדרכים שונות בהתאם לסביבה שלכם. בהמשך מפורטות השיטות הנפוצות ביותר. למידע מלא, ראו הפעלת Admin SDK.
  • איפוס ב-Google Cloud 
    import firebase_admin
from firebase_admin import firestore

# Application Default credentials are automatically created.
app = firebase_admin.initialize_app()
db = firestore.client()
    firestore.py

    אפשר להשתמש גם בפרטי כניסה ברירת המחדל הקיימים של האפליקציה כדי לאתחל את ה-SDK.

    import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore

# Use the application default credentials.
cred = credentials.ApplicationDefault()

firebase_admin.initialize_app(cred)
db = firestore.client()
    firestore.py
  • איך מפעילים את השירות בשרת משלכם

    כדי להשתמש ב-Firebase Admin SDK בשרת שלכם, צריך להשתמש בחשבון שירות.

    עוברים אל IAM & admin > Service accounts במסוף Google Cloud. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-JSON. לאחר מכן משתמשים בקובץ כדי לאתחל את ה-SDK: 

    import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore

# Use a service account.
cred = credentials.Certificate('path/to/serviceAccount.json')

app = firebase_admin.initialize_app(cred)

db = firestore.client()
    firestore.py

    • Python

    ה-SDK של Cloud Firestore מופעל בדרכים שונות בהתאם לסביבה שלכם. בהמשך מפורטות השיטות הנפוצות ביותר. למידע מלא, ראו הפעלת Admin SDK.
  • איפוס ב-Google Cloud 
    import firebase_admin
from firebase_admin import firestore_async

# Application Default credentials are automatically created.
app = firebase_admin.initialize_app()
db = firestore_async.client()
    firestore_async.py

    אפשר להשתמש גם בפרטי כניסה ברירת המחדל הקיימים של האפליקציה כדי לאתחל את ה-SDK.

    import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore_async

# Use the application default credentials.
cred = credentials.ApplicationDefault()

firebase_admin.initialize_app(cred)
db = firestore_async.client()
    firestore_async.py
  • איך מפעילים את השירות בשרת משלכם

    כדי להשתמש ב-Firebase Admin SDK בשרת שלכם, צריך להשתמש בחשבון שירות.

    עוברים אל IAM & admin > Service accounts במסוף Google Cloud. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-JSON. לאחר מכן משתמשים בקובץ כדי לאתחל את ה-SDK: 

    import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore_async

# Use a service account.
cred = credentials.Certificate('path/to/serviceAccount.json')

app = firebase_admin.initialize_app(cred)

db = firestore_async.client()
    firestore_async.py
    • C++‎
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();
    AppDelegate.mm
    Node.js
    ה-SDK של Cloud Firestore מופעל בדרכים שונות בהתאם לסביבה שלכם. בהמשך מפורטות השיטות הנפוצות ביותר. למידע מלא, ראו הפעלת Admin SDK.
    • איפוס ב-Cloud Functions 
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp();

const db = getFirestore();

      index.js
    • איפוס ב-Google Cloud 
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp({
  credential: applicationDefault()
});

const db = getFirestore();
      index.js
    • איך מפעילים את השירות בשרת משלכם

      כדי להשתמש ב-SDK של Firebase Admin בשרת שלכם (או בסביבת Node.js אחרת), צריך להשתמש בחשבון שירות. עוברים אל IAM & admin > Service accounts במסוף Google Cloud. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-JSON. לאחר מכן משתמשים בקובץ כדי לאתחל את ה-SDK: 

      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');

initializeApp({
  credential: cert(serviceAccount)
});

const db = getFirestore();

      index.js
    Go
    ה-SDK של Cloud Firestore מופעל בדרכים שונות בהתאם לסביבה שלכם. בהמשך מפורטות השיטות הנפוצות ביותר. למידע מלא, ראו הפעלת Admin SDK.
  • איפוס ב-Google Cloud 
    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()
  • איך מפעילים את השירות בשרת משלכם

    כדי להשתמש ב-Firebase Admin SDK בשרת שלכם, צריך להשתמש בחשבון שירות.

    עוברים אל IAM & admin > Service accounts במסוף Google Cloud. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-JSON. לאחר מכן משתמשים בקובץ כדי לאתחל את ה-SDK: 

    import (
  "log"

  firebase "firebase.google.com/go"
  "google.golang.org/api/option"
)

// Use a service account
ctx := context.Background()
sa := option.WithCredentialsFile("path/to/serviceAccount.json")
app, err := firebase.NewApp(ctx, nil, sa)
if err != nil {
  log.Fatalln(err)
}

client, err := app.Firestore(ctx)
if err != nil {
  log.Fatalln(err)
}
defer client.Close()
    • PHP

    PHP

    מידע נוסף על התקנה ויצירה של לקוח Cloud Firestore זמין במאמר ספריות לקוח של Cloud Firestore. 

    use Google\Cloud\Firestore\FirestoreClient;

/**
 * Initialize Cloud Firestore with default project ID.
 */
function setup_client_create(string $projectId = null)
{
    // Create the Cloud Firestore client
    if (empty($projectId)) {
        // The `projectId` 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.
        $db = new FirestoreClient();
        printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
    } else {
        $db = new FirestoreClient([
            'projectId' => $projectId,
        ]);
        printf('Created Cloud Firestore client with project ID: %s' . PHP_EOL, $projectId);
    }
}
    setup_client_create.php
    Unity
    using Firebase.Firestore;
using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    C#‎

    C#‎

    מידע נוסף על התקנה ויצירה של לקוח Cloud Firestore זמין במאמר ספריות לקוח של Cloud Firestore. 

    FirestoreDb db = FirestoreDb.Create(project);
Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Program.cs
    Ruby
    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."
    quickstart.rb

    הוספת נתונים

    Cloud Firestore מאחסן נתונים במסמכים, שמאוחסנים בקולקציות. Cloud Firestore יוצר אוספים ומסמכים באופן משתמע בפעם הראשונה שמוסיפים נתונים למסמך. אין צורך ליצור אוספים או מסמכים באופן מפורש.

    יוצרים אוסף ומסמך חדשים באמצעות הקוד לדוגמה הבא.

    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
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-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
    Objective-C
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-App Clip. 
    // 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);
      }
    }];
    ViewController.m

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

    Dart

    // Create a new user with a first and last name
final user = <String, dynamic>{
  "first": "Ada",
  "last": "Lovelace",
  "born": 1815
};

// Add a new document with a generated ID
db.collection("users").add(user).then((DocumentReference doc) =>
    print('DocumentSnapshot added with ID: ${doc.id}'));
    firestore.dart
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("alovelace")
doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py

    Python

    doc_ref = db.collection("users").document("alovelace")
await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py
    C++‎
    // Add a new document with a generated ID
Future<DocumentReference> user_ref =
    db->Collection("users").Add({{"first", FieldValue::String("Ada")},
                                 {"last", FieldValue::String("Lovelace")},
                                 {"born", FieldValue::Integer(1815)}});

user_ref.OnCompletion([](const Future<DocumentReference>& future) {
  if (future.error() == Error::kErrorOk) {
    std::cout << "DocumentSnapshot added with ID: " << future.result()->id()
              << std::endl;
  } else {
    std::cout << "Error adding document: " << future.error_message() << std::endl;
  }
});
    snippets.cpp
    Node.js
    const docRef = db.collection('users').doc('alovelace');

await docRef.set({
  first: 'Ada',
  last: 'Lovelace',
  born: 1815
});
    index.js
    Go
    _, _, 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)
}
    main.go
    PHP

    PHP

    מידע נוסף על התקנה ויצירה של לקוח Cloud Firestore זמין במאמר ספריות לקוח של Cloud Firestore. 

    $docRef = $db->collection('samples/php/users')->document('alovelace');
$docRef->set([
    'first' => 'Ada',
    'last' => 'Lovelace',
    'born' => 1815
]);
printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    setup_dataset.php
    Unity
    DocumentReference docRef = db.Collection("users").Document("alovelace");
Dictionary<string, object> user = new Dictionary<string, object>
{
	{ "First", "Ada" },
	{ "Last", "Lovelace" },
	{ "Born", 1815 },
};
docRef.SetAsync(user).ContinueWithOnMainThread(task => {
	Debug.Log("Added data to the alovelace document in the users collection.");
});
    C#‎
    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);
    Program.cs
    Ruby
    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."
    quickstart.rb

    עכשיו מוסיפים מסמך נוסף לאוסף users. שימו לב שהמסמך הזה כולל צמד מפתח/ערך (שם מרכזי) שלא מופיע במסמך הראשון. מסמכים באוסף יכולים להכיל קבוצות שונות של מידע.

    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
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-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
    Objective-C
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-App Clip. 
    // 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);
      }
    }];
    ViewController.m

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

    Dart

    // Create a new user with a first and last name
final user = <String, dynamic>{
  "first": "Alan",
  "middle": "Mathison",
  "last": "Turing",
  "born": 1912
};

// Add a new document with a generated ID
db.collection("users").add(user).then((DocumentReference doc) =>
    print('DocumentSnapshot added with ID: ${doc.id}'));
    firestore.dart
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("aturing")
doc_ref.set({"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912})
    snippets.py

    Python

    doc_ref = db.collection("users").document("aturing")
await doc_ref.set(
    {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
)
    snippets.py
    C++‎
    db->Collection("users")
    .Add({{"first", FieldValue::String("Alan")},
          {"middle", FieldValue::String("Mathison")},
          {"last", FieldValue::String("Turing")},
          {"born", FieldValue::Integer(1912)}})
    .OnCompletion([](const Future<DocumentReference>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot added with ID: "
                  << future.result()->id() << std::endl;
      } else {
        std::cout << "Error adding document: " << future.error_message()
                  << std::endl;
      }
    });
    snippets.cpp
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');

await aTuringRef.set({
  'first': 'Alan',
  'middle': 'Mathison',
  'last': 'Turing',
  'born': 1912
});
    index.js
    Go
    _, _, 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)
}
    main.go
    PHP

    PHP

    מידע נוסף על התקנה ויצירה של לקוח Cloud Firestore זמין במאמר ספריות לקוח של Cloud Firestore. 

    $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);
    setup_dataset.php
    Unity
    DocumentReference docRef = db.Collection("users").Document("aturing");
Dictionary<string, object> user = new Dictionary<string, object>
{
	{ "First", "Alan" },
	{ "Middle", "Mathison" },
	{ "Last", "Turing" },
	{ "Born", 1912 }
};
docRef.SetAsync(user).ContinueWithOnMainThread(task => {
	Debug.Log("Added data to the aturing document in the users collection.");
});
    C#‎
    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);
    Program.cs
    Ruby
    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."
    quickstart.rb

    קריאת נתונים

    אפשר להשתמש בחלון הצפייה בנתונים במסוף Firebase כדי לוודא במהירות שהוספתם נתונים ל-Cloud Firestore.

    אפשר גם להשתמש בשיטה 'get' כדי לאחזר את האוסף כולו.

    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
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-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
    Objective-C
    הערה: המוצר הזה לא זמין ליעדים של watchOS ו-App Clip. 
    [[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);
        }
      }
    }];
    ViewController.m

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

    Dart

    await db.collection("users").get().then((event) {
  for (var doc in event.docs) {
    print("${doc.id} => ${doc.data()}");
  }
});
    firestore.dart
    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"));
}
    Quickstart.java
    Python
    users_ref = db.collection("users")
docs = users_ref.stream()

for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py

    Python

    users_ref = db.collection("users")
docs = users_ref.stream()

async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py
    C++‎
    Future<QuerySnapshot> users = db->Collection("users").Get();
users.OnCompletion([](const Future<QuerySnapshot>& future) {
  if (future.error() == Error::kErrorOk) {
    for (const DocumentSnapshot& document : future.result()->documents()) {
      std::cout << document << std::endl;
    }
  } else {
    std::cout << "Error getting documents: " << future.error_message()
              << std::endl;
  }
});
    snippets.cpp
    Node.js
    const snapshot = await db.collection('users').get();
snapshot.forEach((doc) => {
  console.log(doc.id, '=>', doc.data());
});
    index.js
    Go
    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())
}
    main.go
    PHP

    PHP

    מידע נוסף על התקנה ויצירה של לקוח Cloud Firestore זמין במאמר ספריות לקוח של Cloud Firestore. 

    $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);
    setup_dataset_read.php
    Unity
    CollectionReference usersRef = db.Collection("users");
usersRef.GetSnapshotAsync().ContinueWithOnMainThread(task =>
{
  QuerySnapshot snapshot = task.Result;
  foreach (DocumentSnapshot document in snapshot.Documents)
  {
    Debug.Log(String.Format("User: {0}", document.Id));
    Dictionary<string, object> documentDictionary = document.ToDictionary();
    Debug.Log(String.Format("First: {0}", documentDictionary["First"]));
    if (documentDictionary.ContainsKey("Middle"))
    {
      Debug.Log(String.Format("Middle: {0}", documentDictionary["Middle"]));
    }

    Debug.Log(String.Format("Last: {0}", documentDictionary["Last"]));
    Debug.Log(String.Format("Born: {0}", documentDictionary["Born"]));
  }

  Debug.Log("Read all data from the users collection.");
});
    C#‎
    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();
}
    Program.cs
    Ruby
    users_ref = firestore.col collection_path
users_ref.get do |user|
  puts "#{user.document_id} data: #{user.data}."
end
    quickstart.rb

    אבטחת הנתונים

    אם אתם משתמשים ב-SDK לאינטרנט, ל-Android או לפלטפורמות של Apple, תוכלו להשתמש ב-Firebase Authentication וב-Cloud Firestore Security Rules כדי לאבטח את הנתונים ב-Cloud Firestore.

    ריכזנו כאן כמה קבוצות כללים בסיסיות שיעזרו לכם להתחיל. אפשר לשנות את כללי האבטחה בכרטיסייה 'כללים' במסוף.

    נדרש אימות

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

    מצב נעילה

    // Deny read/write access to all users under any conditions
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

    לפני שתפרסו את אפליקציית האינטרנט, אפליקציית Android או אפליקציית iOS בסביבת הייצור, חשוב גם לוודא שרק ללקוחות האפליקציה תהיה גישה לנתוני Cloud Firestore. כאן אפשר לקרוא מידע נוסף על App Check.

    אם אתם משתמשים באחת מערכות ה-SDK של השרת, תוכלו להשתמש בניהול זהויות והרשאות גישה (IAM) כדי לאבטח את הנתונים ב-Cloud Firestore.

    לצפייה בסרטון הדרכה

    כדי לקבל הנחיות מפורטות לתחילת העבודה עם Cloud Firestore ספריות הלקוח לנייד, אפשר לצפות באחד מסרטוני ההדרכה הבאים:

    אינטרנט
    iOS+
    Android

    סרטונים נוספים זמינים בערוץ YouTube של Firebase.

    השלבים הבאים

    כדי להרחיב את הידע שלכם, כדאי לעיין בנושאים הבאים: