תחילת העבודה עם 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. בוחרים מיקום למסד הנתונים.

   אם אתם לא מצליחים לבחור מיקום, סימן שהאפשרות location for default Google Cloud resources בפרויקט כבר מוגדרת. לחלק מהמשאבים בפרויקט (כמו המכונה 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 ו-App Engine: אי אפשר להשתמש ב-Cloud Firestore וב-Datastore באותו פרויקט, וזה עלול להשפיע על אפליקציות שמשתמשות ב-App Engine. כדאי לנסות להשתמש ב-Cloud Firestore בפרויקט אחר.

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

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

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

Web

1. פועלים לפי ההוראות להוספת Firebase לאפליקציית האינטרנט.
2. ערכת ה-SDK של Cloud Firestore זמינה כחבילת npm.

   npm install firebase@11.9.1 --save

   צריך לייבא גם את Firebase וגם את Cloud Firestore.

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

מחפשים ספריית Firestore קומפקטית, ודרוש לכם רק יכולות REST/CRUD פשוטות? כדאי לנסות את Firestore Lite SDK, שזמין רק דרך npm.

Web

1. פועלים לפי ההוראות להוספת Firebase לאפליקציית האינטרנט.
2. מוסיפים את הספריות Firebase ו-Cloud Firestore לאפליקציה:

   <script src="https://www.gstatic.com/firebasejs/11.9.1/firebase-app-compat.js"></script>
   <script src="https://www.gstatic.com/firebasejs/11.9.1/firebase-firestore-compat.js"></script>

   ערכת ה-SDK של Cloud Firestore זמינה גם כחבילת npm.

   npm install firebase@11.9.1 --save

   צריך לדרוש באופן ידני גם את Firebase וגם את Cloud Firestore.

   import firebase from "firebase/compat/app";
   // Required for side-effects
   import "firebase/firestore";

iOS+

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

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

במדריך ההתקנה מוסבר על הדרכים השונות להוספת ערכות SDK של Firebase לפרויקט שלכם ב-Apple, כולל ייבוא של מסגרות ישירות ושימוש ב-CocoaPods.

1. ב-Xcode, כשפרויקט האפליקציה פתוח, עוברים אל File > Swift Packages > Add Package Dependency.
2. כשמופיעה בקשה, מוסיפים את המאגר של Firebase SDK לפלטפורמות Apple:

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

הערה: בפרויקטים חדשים צריך להשתמש בגרסה שמוגדרת כברירת מחדל (העדכנית ביותר) של ה-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.15.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.4")
   }

   מחפשים מודול ספרייה ספציפי ל-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.

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

• האפשרות הזו נמצאת בקטע הגדרות הנגן > Android > הגדרות פרסום > Minify.
• האפשרויות עשויות להיות שונות בגרסאות שונות של Unity, לכן מומלץ לעיין במסמכי העזרה הרשמיים של Unity ובמדריך לניפוי באגים ב-Unity Build ב-Firebase.
• אם אחרי הפעלת המינימיזציה, מספר השיטות שמצוינות ב-reference עדיין חורג מהמגבלה, אפשרות נוספת היא להפעיל את 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 של מפתח חשבון שירות. אפשר ליצור קובץ מפתח בדף 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. מוסיפים את ספריית 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

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

מידע נוסף על Web API מודולרי שניתן לניפוי עצים ועל היתרונות שלו על פני API עם מרחבי שמות

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

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

מידע נוסף על Web API מודולרי שניתן לניפוי עצים ועל היתרונות שלו על פני API עם מרחבי שמות

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

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

קריאת נתונים

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

אפשר גם להשתמש ב-method‏ '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

מידע נוסף על Web API מודולרי שניתן לניפוי עצים ועל היתרונות שלו על פני API עם מרחבי שמות

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

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.

השלבים הבאים

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

• Codelabs – תוכלו ללמוד איך להשתמש ב-Cloud Firestore באפליקציה אמיתית באמצעות הקודלאב ל-Android, ל-iOS או ל-אינטרנט.
• מודל נתונים – מידע נוסף על המבנה של הנתונים ב-Cloud Firestore, כולל נתונים היררכיים ואוספים משניים.
• הוספת נתונים – מידע נוסף על יצירת נתונים ועדכון שלהם זמין במאמר Cloud Firestore.
• קבלת נתונים – מידע נוסף על אחזור נתונים.
• הרצת שאילתות פשוטות ומורכבות – איך מריצים שאילתות פשוטות ומורכבות.
• סידור והגבלה של שאילתות איך מסדרים ומגבילים את הנתונים שמוחזרים על ידי השאילתות.