Catch up on everthing we announced at this year's Firebase Summit. Learn more

Inizia con Cloud Firestore

Questo avvio rapido mostra come configurare Cloud Firestore, aggiungere dati, quindi visualizzare i dati appena aggiunti nella console Firebase.

Crea un database Cloud Firestore

  1. Se non l'hai già, creare un progetto Firebase: Nella console Firebase , scegliere Aggiungi progetto, quindi seguire le istruzioni sullo schermo per creare un progetto Firebase o per aggiungere servizi Firebase ad un progetto GCP esistente.

  2. Passare alla sezione di cloud FireStore della console Firebase . Ti verrà chiesto di selezionare un progetto Firebase esistente. Segui il flusso di lavoro di creazione del database.

  3. Seleziona una modalità di avvio per le regole di sicurezza di Cloud Firestore:

    Modalità di prova

    Ottimo per iniziare con le librerie client mobile e web, ma consente a chiunque di leggere e sovrascrivere i dati. Dopo aver testato, assicurati di rivedere il proteggere i dati sezione.

    Per iniziare con il Web, le piattaforme Apple o l'SDK Android, seleziona la modalità di prova.

    Modalità bloccata

    Nega tutte le operazioni di lettura e scrittura da client mobili e web. I tuoi server delle applicazioni autenticati (C#, Go, Java, Node.js, PHP, Python o Ruby) possono ancora accedere al tuo database.

    Per iniziare con la libreria client del server C#, Go, Java, Node.js, PHP, Python o Ruby, seleziona la modalità bloccata.

  4. Selezionare un percorso per il database.

    • Questa impostazione posizione è del progetto di default posizione risorsa Google Cloud Platform (GCP) . Si noti che questa posizione sarà utilizzata per i servizi GCP nel progetto che richiedono un'impostazione di località, in particolare, predefinito Cloud Storage secchio e la tua App Engine app (che è necessario se si utilizza nube di pianificazione).

    • Se non sei in grado di selezionare una posizione, il tuo progetto ha già una posizione predefinita per le risorse GCP. È stato impostato durante la creazione del progetto o durante la configurazione di un altro servizio che richiede un'impostazione della posizione.

  5. Fai clic su Fine.

Quando si attiva nube FireStore, consente anche l'API nel Manager API cloud .

Configura il tuo ambiente di sviluppo

Aggiungi le dipendenze richieste e le librerie client alla tua app.

Versione web 8

  1. Seguire le istruzioni per aggiungere la Firebase al vostro Web App .
  2. Aggiungere le librerie Firebase e Cloud Firestore per la vostra applicazione:
    <script src="https://www.gstatic.com/firebasejs/8.10.0/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/8.10.0/firebase-firestore.js"></script>
    The Cloud Firestore SDK è disponibile come pacchetto NPM anche.
    npm install firebase@8.10.0 --save
    
    sarà necessario richiedere manualmente sia Firebase e Cloud Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    

Versione web 9

  1. Seguire le istruzioni per aggiungere la Firebase al vostro Web App .
  2. L'SDK Cloud Firestore è disponibile come pacchetto npm.
    npm install firebase@9.4.1 --save
    
    sarà necessario importare sia Firebase e Cloud Firestore.
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";
    
iOS+
  1. Seguire le istruzioni per aggiungere la Firebase al vostro Apple App .
  2. Aggiungere il baccello cloud FireStore al vostro Podfile
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Salvare il file ed eseguire pod install .

Giava

  1. Seguire le istruzioni per aggiungere la Firebase per la vostra applicazione Android .
  2. Utilizzando la Firebase Android BoM , dichiarare la dipendenza per la libreria cloud FireStore Android nel modulo (a livello di app) File Gradle (di solito app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:29.0.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'
    }
    

    Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

    (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

    Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.

    Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono compatibili.

    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:24.0.0'
    }
    

Kotlin+KTX

  1. Seguire le istruzioni per aggiungere la Firebase per la vostra applicazione Android .
  2. Utilizzando la Firebase Android BoM , dichiarare la dipendenza per la libreria cloud FireStore Android nel modulo (a livello di app) File Gradle (di solito app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:29.0.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-ktx'
    }
    

    Usando il Firebase Android BoM , la vostra applicazione sarà sempre utilizzare versioni compatibili delle librerie Firebase Android.

    (Alternativa) Dichiarare Firebase dipendenze delle librerie senza utilizzare la distinta

    Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.

    Si noti che se si utilizzano più librerie Firebase nella vostra app, ti consigliamo di utilizzare la distinta di gestire versioni della libreria, che assicura che tutte le versioni sono compatibili.

    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-ktx:24.0.0'
    }
    
Giava
  1. Aggiungi l'SDK Firebase Admin alla tua app:
    • Utilizzando Gradle:
      compile 'com.google.firebase:firebase-admin:8.1.0'
      
    • Utilizzando Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>8.1.0</version>
      </dependency>
           
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
Pitone
  1. Aggiungere la Firebase Admin SDK per il vostro Python app:
    pip install --upgrade firebase-admin
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
C++
  1. Seguire le istruzioni per aggiungere la Firebase al progetto C ++ .
  2. Interfaccia C++ per Android.
    • Dipendenze Gradle. Aggiungere la seguente al modulo (a livello di app) File Gradle (di solito 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
              }
              
    • Dipendenze binarie. Allo stesso modo, il metodo consigliato per ottenere le dipendenze binarie è quello di aggiungere quanto segue al CMakeLists.txt del file:
              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. Per impostare l'integrazione del desktop, vedere Aggiungi Firebase al progetto C ++ .
Unità
  1. Seguire le istruzioni per aggiungere la Firebase al progetto Unity .
  2. Interfaccia Unity per Android.
  3. Quando si compila per Android, abilitare ProGuarding per evitare il limite DEX di Android. Per farlo, nell'editor di Unity:

    1. Seleziona File > Impostazioni build
    2. Passa da "Piattaforma" a "Android" e fai clic su "Cambia piattaforma"
    3. Fai clic su "Impostazioni giocatore..."
    4. Nell'interfaccia utente principale di Unity, in "Impostazioni per Android", seleziona "Impostazioni di pubblicazione"
    5. Nella sezione "Riduci", modifica le impostazioni di Rilascio e Debug da "Nessuno" a "ProGuard"
Nodo.js
  1. Aggiungere la Firebase Admin SDK per la vostra applicazione:
    npm install firebase-admin --save
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
andare
  1. Aggiungere la Firebase Admin SDK per il vostro Go app:
    go get firebase.google.com/go
    
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
PHP
  1. Le librerie cloud Firestore client del server (Java, Node.js, Python, Go, PHP, C #, e Ruby) l'utilizzo delle credenziali di Google applicazione predefinita per l'autenticazione.
    • Per autenticare dal proprio ambiente di sviluppo, impostare la GOOGLE_APPLICATION_CREDENTIALS variabile d'ambiente per puntare a un file di chiave account di servizio JSON. È possibile creare un file di chiave sulla pagina Credenziali console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario eseguire l'autenticazione se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. In caso contrario, impostare un account di servizio .
  2. Installare e attivare l' estensione gRPC per PHP, che sarà necessario per utilizzare la libreria client.
  3. Aggiungere la libreria cloud FireStore PHP per la vostra applicazione:
    composer require google/cloud-firestore
C#
  1. Le librerie cloud Firestore client del server (Java, Node.js, Python, Go, PHP, C #, e Ruby) l'utilizzo delle credenziali di Google applicazione predefinita per l'autenticazione.
    • Per autenticare dal proprio ambiente di sviluppo, impostare la GOOGLE_APPLICATION_CREDENTIALS variabile d'ambiente per puntare a un file di chiave account di servizio JSON. È possibile creare un file di chiave sulla pagina Credenziali console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario eseguire l'autenticazione se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. In caso contrario, impostare un account di servizio .
  2. Aggiungere la libreria cloud FireStore C # per la vostra applicazione nel .csproj di file:
    <ItemGroup>
      <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
    </ItemGroup>
  3. Aggiungere la seguente al Program.cs file:
    using Google.Cloud.Firestore;
Rubino
  1. Le librerie cloud Firestore client del server (Java, Node.js, Python, Go, PHP, C #, e Ruby) l'utilizzo delle credenziali di Google applicazione predefinita per l'autenticazione.
    • Per autenticare dal proprio ambiente di sviluppo, impostare la GOOGLE_APPLICATION_CREDENTIALS variabile d'ambiente per puntare a un file di chiave account di servizio JSON. È possibile creare un file di chiave sulla pagina Credenziali console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario eseguire l'autenticazione se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. In caso contrario, impostare un account di servizio .
  2. Aggiungere la libreria cloud FireStore Ruby per la vostra applicazione nel vostro Gemfile :
    gem "google-cloud-firestore"
  3. Installare le dipendenze dal Gemfile utilizzando:
    bundle install

(Facoltativo) Prototipo e test con Firebase Local Emulator Suite

Per gli sviluppatori di dispositivi mobili, prima di parlare di come la tua app scrive e legge da Cloud Firestore, introduciamo una serie di strumenti che puoi utilizzare per prototipare e testare la funzionalità di Cloud Firestore: Firebase Local Emulator Suite. Se stai provando diversi modelli di dati, ottimizzando le tue regole di sicurezza o lavorando per trovare il modo più conveniente per interagire con il back-end, essere in grado di lavorare localmente senza distribuire servizi live può essere un'ottima idea.

Un emulatore Cloud Firestore fa parte di Local Emulator Suite, che consente alla tua app di interagire con il contenuto e la configurazione del database emulato, nonché, facoltativamente, con le risorse del progetto emulato (funzioni, altri database e regole di sicurezza).

L'utilizzo dell'emulatore Cloud Firestore richiede solo pochi passaggi:

  1. Aggiunta di una riga di codice alla configurazione di test dell'app per connettersi all'emulatore.
  2. Dalla radice della directory progetto locale, in esecuzione firebase emulators:start .
  3. Effettuare chiamate dal codice prototipo della tua app utilizzando un SDK della piattaforma Cloud Firestore come di consueto.

Un dettagliato walkthrough che coinvolge cloud Firestore e cloud funzioni è disponibile. Si dovrebbe anche avere uno sguardo alla introduzione locale emulatore Suite .

Inizializza Cloud Firestore

Inizializza un'istanza di Cloud Firestore:

Versione web 9

// Initialize Cloud Firestore through Firebase
import { initializeApp } from "firebase/app"
import { getFirestore } from "firebase/firestore"
const firebaseApp = initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

const db = getFirestore();
I valori per `initializeApp` può essere trovato nel vostro web app ` firebaseConfig` . Per mantenere i dati quando il dispositivo perde la connessione, vedere la Abilita dati non in linea documentazione.

Versione web 8

// Initialize Cloud Firestore through Firebase
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

var db = firebase.firestore();
I valori per `initializeApp` può essere trovato nel vostro web app ` firebaseConfig` . Per mantenere i dati quando il dispositivo perde la connessione, vedere la Abilita dati non in linea documentazione.
Swift
Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
import Firebase
FirebaseApp.configure()

let db = Firestore.firestore()
Obiettivo-C
Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
@import Firebase;

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

Giava

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

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Giava
L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda dell'ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, vedere inizializzare l'Admin SDK .
  • Inizializzare sulla piattaforma 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();
    
  • Inizializza sul tuo server

    Per utilizzare il Firebase Admin SDK sul proprio server, utilizzare un account di servizio .

    Vai alla IAM e di amministrazione> Account di servizio nella Console Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizzare il file per inizializzare l'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();
    
  • Pitone
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda dell'ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, vedere inizializzare l'Admin SDK .
  • Inizializzare sulla piattaforma Google Cloud
    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, {
      'projectId': project_id,
    })
    
    db = firestore.client()
    
  • Inizializza sul tuo server

    Per utilizzare il Firebase Admin SDK sul proprio server, utilizzare un account di servizio .

    Vai alla IAM e di amministrazione> Account di servizio nella Console Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizzare il file per inizializzare l'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')
    firebase_admin.initialize_app(cred)
    
    db = firestore.client()
    
  • Pitone

    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda dell'ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, vedere inizializzare l'Admin SDK .
  • Inizializzare sulla piattaforma Google Cloud
    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, {
      'projectId': project_id,
    })
    
    db = firestore.AsyncClient()
    
  • Inizializza sul tuo server

    Per utilizzare il Firebase Admin SDK sul proprio server, utilizzare un account di servizio .

    Vai alla IAM e di amministrazione> Account di servizio nella Console Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizzare il file per inizializzare l'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')
    firebase_admin.initialize_app(cred)
    
    db = firestore.AsyncClient()
    
  • C++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    Nodo.js
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda dell'ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, vedere inizializzare l'Admin SDK .
    • Inizializzare sulle funzioni cloud
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
      initializeApp();
      
      const db = getFirestore();
      
    • Inizializzare su Google Cloud Platform
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
      initializeApp({
        credential: applicationDefault()
      });
      
      const db = getFirestore();
    • Inizializza sul tuo server

      Per utilizzare il Firebase Admin SDK sul proprio server (o qualsiasi altro ambiente Node.js), utilizzare un account di servizio . Vai alla IAM e di amministrazione> Account di servizio nella Console Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizzare il file per inizializzare l'SDK:

      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      initializeApp({
        credential: cert(serviceAccount)
      });
      
      const db = getFirestore();
      
    andare
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda dell'ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, vedere inizializzare l'Admin SDK .
  • Inizializzare sulla piattaforma 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()
    
  • Inizializza sul tuo server

    Per utilizzare il Firebase Admin SDK sul proprio server, utilizzare un account di servizio .

    Vai alla IAM e di amministrazione> Account di servizio nella Console Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizzare il file per inizializzare l'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
    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);
        }
    }
    Unità
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    C#
    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Rubino
    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."

    Aggiungi dati

    Cloud Firestore archivia i dati in Documenti, che sono archiviati in Raccolte. Cloud Firestore crea implicitamente raccolte e documenti la prima volta che aggiungi dati al documento. Non è necessario creare in modo esplicito raccolte o documenti.

    Crea una nuova raccolta e un documento utilizzando il codice di esempio seguente.

    Versione web 9

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

    Versione web 8

    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);
    });
    Swift
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    // Add a new document with a generated ID
    var ref: DocumentReference? = nil
    ref = db.collection("users").addDocument(data: [
        "first": "Ada",
        "last": "Lovelace",
        "born": 1815
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    Obiettivo-C
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    // 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);
          }
        }];

    Giava

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

    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)
        }
    Giava
    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());
    Pitone
    doc_ref = db.collection(u'users').document(u'alovelace')
    doc_ref.set({
        u'first': u'Ada',
        u'last': u'Lovelace',
        u'born': 1815
    })

    Pitone

    doc_ref = db.collection("users").document("alovelace")
    await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    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;
      }
    });
    Nodo.js
    const docRef = db.collection('users').doc('alovelace');
    
    await docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
    andare
    _, _, 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)
    }
    PHP
    $docRef = $db->collection('samples/php/users')->document('lovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    Unità
    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);
    Rubino
    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."

    Ora aggiungere un altro documento al users di raccolta. Notare che questo documento include una coppia chiave-valore (secondo nome) che non appare nel primo documento. I documenti di una raccolta possono contenere diversi set di informazioni.

    Versione web 9

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

    Versione web 8

    // 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);
    });
    Swift
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    // Add a second document with a generated ID.
    ref = db.collection("users").addDocument(data: [
        "first": "Alan",
        "middle": "Mathison",
        "last": "Turing",
        "born": 1912
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    Obiettivo-C
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    // 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);
          }
        }];

    Giava

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

    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)
        }
    Giava
    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());
    Pitone
    doc_ref = db.collection(u'users').document(u'aturing')
    doc_ref.set({
        u'first': u'Alan',
        u'middle': u'Mathison',
        u'last': u'Turing',
        u'born': 1912
    })

    Pitone

    doc_ref = db.collection("users").document("aturing")
    await doc_ref.set(
        {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
    )
    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;
          }
        });
    Nodo.js
    const aTuringRef = db.collection('users').doc('aturing');
    
    await aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
    andare
    _, _, 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)
    }
    PHP
    $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);
    Unità
    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);
    Rubino
    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."

    Leggi i dati

    Per rapidamente verificare che hai aggiunto i dati a Cloud FireStore, utilizza il visualizzatore dati nella console Firebase .

    Puoi anche utilizzare il metodo "get" per recuperare l'intera raccolta.

    Versione web 9

    import { collection, getDocs } from "firebase/firestore"; 
    
    const querySnapshot = await getDocs(collection(db, "users"));
    querySnapshot.forEach((doc) => {
      console.log(`${doc.id} => ${doc.data()}`);
    });

    Versione web 8

    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });
    Swift
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    db.collection("users").getDocuments() { (querySnapshot, err) in
        if let err = err {
            print("Error getting documents: \(err)")
        } else {
            for document in querySnapshot!.documents {
                print("\(document.documentID) => \(document.data())")
            }
        }
    }
    Obiettivo-C
    Nota: Questo prodotto non è disponibile su obiettivi clip watchos e App.
    [[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);
            }
          }
        }];

    Giava

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

    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)
            }
    Giava
    // 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"));
    }
    Pitone
    users_ref = db.collection(u'users')
    docs = users_ref.stream()
    
    for doc in docs:
        print(f'{doc.id} => {doc.to_dict()}')

    Pitone

    users_ref = db.collection("users")
    docs = users_ref.stream()
    
    async for doc in docs:
        print(f"{doc.id} => {doc.to_dict()}")
    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;
      }
    });
    Nodo.js
    const snapshot = await db.collection('users').get();
    snapshot.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
    andare
    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())
    }
    PHP
    $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);
    Unità
    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();
    }
    Rubino
    users_ref = firestore.col collection_path
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end

    Proteggi i tuoi dati

    Se si utilizza il Web, piattaforme Android, o SDK di Apple, utilizzare Firebase autenticazione e Firestore regole di sicurezza cloud per proteggere i dati in Cloud Firestore.

    Ecco alcuni set di regole di base che puoi utilizzare per iniziare. È possibile modificare le regole di sicurezza nella scheda Regole della console.

    Autenticazione richiesta

    // Allow read/write access on all documents to any user signed in to the application
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if request.auth != null;
        }
      }
    }
    

    Modalità bloccata

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

    Modalità di prova

    // Allow read/write access to all users under any conditions
    // Warning: **NEVER** use this rule set in production; it allows
    // anyone to overwrite your entire database.
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if true;
        }
      }
    }
    

    Prima di distribuire la tua app Web, Android o iOS in produzione, prendi anche provvedimenti per assicurarti che solo i client dell'app possano accedere ai dati di Cloud Firestore. Vedere il Controllo App documentazione.

    Se si utilizza uno dei SDK server, utilizzare Identity and Access Management (IAM) per proteggere i dati in Cloud Firestore.

    Guarda un video tutorial

    Per una guida dettagliata su come iniziare con le librerie client per dispositivi mobili di Cloud Firestore, guarda uno dei seguenti tutorial video:

    ragnatela
    iOS+
    Android

    Puoi trovare altri video nel Firebase canale YouTube .

    Prossimi passi

    Approfondisci le tue conoscenze con i seguenti argomenti:

    • Codelabs - Imparare a utilizzare il cloud FireStore in una vera e propria applicazione seguendo il codelab per Android , iOS o Web .
    • Modello di dati - Ulteriori informazioni su come i dati è strutturata in Cloud FireStore, compresi i dati gerarchici e sottoraccolte.
    • Aggiungere i dati - Ulteriori informazioni sulla creazione e l'aggiornamento dei dati in Cloud Firestore.
    • Ottenere dati - Per saperne di più su come recuperare i dati.
    • Eseguire query semplici e composti - Scopri come eseguire query semplici e composte.
    • Ordine e limite di query Ulteriori informazioni su come ordinare e limitare i dati restituiti dalla query.