תחילת העבודה עם 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 Manager.

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

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

Web

  1. פועלים לפי ההוראות להוספת Firebase לאפליקציית האינטרנט.
  2. מוסיפים את ספריות Firebase ו-Cloud Firestore לאפליקציה: 
    <script src="https://www.gstatic.com/firebasejs/11.0.1/firebase-app-compat.js"></script>
<script src="https://www.gstatic.com/firebasejs/11.0.1/firebase-firestore-compat.js"></script>
     ערכת ה-SDK של Cloud Firestore זמינה גם כחבילת npm. 
    npm install firebase@11.0.1 --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.1 --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.5.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")
}

    כשמשתמשים ב-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. מהרמה הבסיסית (root) של פרויקט 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. מוסיפים את Firebase Admin SDK לאפליקציית 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. צריך להקטין את ה-build כדי למנוע את ההודעה Error while merging dex archives.

    • האפשרות הזו נמצאת בקטע הגדרות הנגן > Android > הגדרות פרסום > Minify.
    • האפשרויות עשויות להיות שונות בגרסאות שונות של Unity, לכן מומלץ לעיין במסמכי העזרה הרשמיים של Unity ובמדריך לניפוי באגים ב-Unity Build של Firebase.
    • אם אחרי הפעלת ההקטנה, מספר ה-methods שאפשר להפנות עדיין חורג מהמגבלה, אפשרות נוספת היא להפעיל את multidex ב:
      • mainTemplate.gradle אם האפשרות Custom Gradle Template (תבנית Gradle מותאמת אישית) מופעלת בקטע Player Settings (הגדרות הנגן)
      • או את הקובץ build.gradle ברמת המודול, אם משתמשים ב-Android Studio כדי ליצור את הפרויקט המיוצא.
Node.js
  1. מוסיפים לאפליקציה את Firebase Admin SDK: 
    npm install firebase-admin --save
  2. פועלים לפי ההוראות הבאות כדי לאתחל את Cloud Firestore עם פרטי הכניסה המתאימים בסביבה שלכם.
Go
  1. מוסיפים את Firebase Admin SDK לאפליקציה ב-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. אפשר ליצור קובץ מפתח בדף פרטי הכניסה של מסוף ה-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. אפשר ליצור קובץ מפתח בדף פרטי הכניסה של מסוף ה-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 של מפתח חשבון שירות. אפשר ליצור קובץ מפתח בדף פרטי הכניסה של מסוף ה-API. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור, אין צורך לאמת אם אתם מריצים את האפליקציה ב-App Engine או ב-Compute Engine, באמצעות אותו הפרויקט שבו אתם משתמשים עבור Cloud Firestore. אחרת, מגדירים חשבון שירות.
  2. מוסיפים את ספריית Ruby של Cloud Firestore לאפליקציה ב-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 בשרת שלכם, צריך להשתמש בחשבון שירות.

    במסוף Google Cloud, נכנסים אל IAM & admin > Service accounts. יוצרים מפתח פרטי חדש ושומרים את קובץ ה-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.

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

    נדרש אימות

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

    השלבים הבאים

    להעמיק את הידע בנושאים הבאים: