Dzięki pakietowi Admin SDK możesz odczytywać i zapisywać dane bazy danych czasu rzeczywistego z pełnymi uprawnieniami administratora lub z bardziej szczegółowymi uprawnieniami ograniczonymi. W tym dokumencie przeprowadzimy Cię przez proces dodawania pakietu Firebase Admin SDK do projektu w celu uzyskania dostępu do bazy danych czasu rzeczywistego Firebase.
Konfiguracja pakietu SDK administratora
Aby rozpocząć korzystanie z bazy danych czasu rzeczywistego Firebase na serwerze, musisz najpierw skonfigurować pakiet Firebase Admin SDK w wybranym przez siebie języku.
Uwierzytelnianie Admin SDK
Zanim uzyskasz dostęp do bazy danych czasu rzeczywistego Firebase z serwera przy użyciu pakietu Firebase Admin SDK, musisz uwierzytelnić swój serwer w Firebase. Gdy uwierzytelniasz serwer, zamiast logować się przy użyciu poświadczeń konta użytkownika, tak jak w przypadku aplikacji klienckiej, uwierzytelniasz się za pomocą konta usługi , które identyfikuje Twój serwer w Firebase.
Podczas uwierzytelniania przy użyciu pakietu Firebase Admin SDK możesz uzyskać dwa różne poziomy dostępu:
Poziomy dostępu uwierzytelniania Firebase Admin SDK | |
---|---|
Uprawnienia administracyjne | Pełny dostęp do odczytu i zapisu do bazy danych projektu w czasie rzeczywistym. Używaj ostrożnie do wykonywania zadań administracyjnych, takich jak migracja danych lub restrukturyzacja, które wymagają nieograniczonego dostępu do zasobów projektu. |
Ograniczone przywileje | Dostęp do bazy danych czasu rzeczywistego projektu, ograniczony tylko do zasobów potrzebnych serwerowi. Ten poziom służy do wykonywania zadań administracyjnych, które mają dobrze zdefiniowane wymagania dotyczące dostępu. Na przykład podczas uruchamiania zadania podsumowania, które odczytuje dane z całej bazy danych, można zabezpieczyć się przed przypadkowymi zapisami, ustawiając regułę bezpieczeństwa tylko do odczytu, a następnie inicjując pakiet Admin SDK z uprawnieniami ograniczonymi przez tę regułę. |
Uwierzytelnij z uprawnieniami administratora
Gdy zainicjujesz pakiet Firebase Admin SDK przy użyciu poświadczeń konta usługi z rolą edytującego w projekcie Firebase, ta instancja ma pełny dostęp do odczytu i zapisu do bazy danych projektu w czasie rzeczywistym.
Jawa
// Fetch the service account key JSON file contents FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json"); // Initialize the app with a service account, granting admin privileges FirebaseOptions options = FirebaseOptions.builder() .setCredentials(GoogleCredentials.fromStream(serviceAccount)) // The database URL depends on the location of the database .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com") .build(); FirebaseApp.initializeApp(options); // As an admin, the app has access to read and write all data, regardless of Security Rules DatabaseReference ref = FirebaseDatabase.getInstance() .getReference("restricted_access/secret_document"); ref.addListenerForSingleValueEvent(new ValueEventListener() { @Override public void onDataChange(DataSnapshot dataSnapshot) { Object document = dataSnapshot.getValue(); System.out.println(document); } @Override public void onCancelled(DatabaseError error) { } });
Node.js
var admin = require("firebase-admin"); // Fetch the service account key JSON file contents var serviceAccount = require("path/to/serviceAccountKey.json"); // Initialize the app with a service account, granting admin privileges admin.initializeApp({ credential: admin.credential.cert(serviceAccount), // The database URL depends on the location of the database databaseURL: "https://DATABASE_NAME.firebaseio.com" }); // As an admin, the app has access to read and write all data, regardless of Security Rules var db = admin.database(); var ref = db.ref("restricted_access/secret_document"); ref.once("value", function(snapshot) { console.log(snapshot.val()); });
Pyton
import firebase_admin from firebase_admin import credentials from firebase_admin import db # Fetch the service account key JSON file contents cred = credentials.Certificate('path/to/serviceAccountKey.json') # Initialize the app with a service account, granting admin privileges firebase_admin.initialize_app(cred, { 'databaseURL': 'https://databaseName.firebaseio.com' }) # As an admin, the app has access to read and write all data, regradless of Security Rules ref = db.reference('restricted_access/secret_document') print(ref.get())
Iść
ctx := context.Background() conf := &firebase.Config{ DatabaseURL: "https://databaseName.firebaseio.com", } // Fetch the service account key JSON file contents opt := option.WithCredentialsFile("path/to/serviceAccountKey.json") // Initialize the app with a service account, granting admin privileges app, err := firebase.NewApp(ctx, conf, opt) if err != nil { log.Fatalln("Error initializing app:", err) } client, err := app.Database(ctx) if err != nil { log.Fatalln("Error initializing database client:", err) } // As an admin, the app has access to read and write all data, regradless of Security Rules ref := client.NewRef("restricted_access/secret_document") var data map[string]interface{} if err := ref.Get(ctx, &data); err != nil { log.Fatalln("Error reading from database:", err) } fmt.Println(data)
Uwierzytelniaj z ograniczonymi uprawnieniami
Zgodnie z najlepszą praktyką usługa powinna mieć dostęp tylko do zasobów, których potrzebuje. Aby uzyskać dokładniejszą kontrolę nad zasobami, do których ma dostęp instancja aplikacji Firebase, użyj unikalnego identyfikatora w Regułach bezpieczeństwa reprezentującego Twoją usługę. Następnie skonfiguruj odpowiednie reguły, które przyznają Twojej usłudze dostęp do potrzebnych jej zasobów. Na przykład:
{ "rules": { "public_resource": { ".read": true, ".write": true }, "some_resource": { ".read": "auth.uid === 'my-service-worker'", ".write": false }, "another_resource": { ".read": "auth.uid === 'my-service-worker'", ".write": "auth.uid === 'my-service-worker'" } } }
Następnie na swoim serwerze, podczas inicjowania aplikacji Firebase, użyj opcji databaseAuthVariableOverride
, aby zastąpić obiekt auth
używany przez reguły bazy danych. W tym niestandardowym obiekcie auth
ustaw pole uid
na identyfikator, którego użyłeś do reprezentowania swojej usługi w regułach bezpieczeństwa.
Jawa
// Fetch the service account key JSON file contents FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json"); // Initialize the app with a custom auth variable, limiting the server's access Map<String, Object> auth = new HashMap<String, Object>(); auth.put("uid", "my-service-worker"); FirebaseOptions options = new FirebaseOptions.Builder() .setCredential(FirebaseCredentials.fromCertificate(serviceAccount)) // The database URL depends on the location of the database .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com") .setDatabaseAuthVariableOverride(auth) .build(); FirebaseApp.initializeApp(options); // The app only has access as defined in the Security Rules DatabaseReference ref = FirebaseDatabase .getInstance() .getReference("/some_resource"); ref.addListenerForSingleValueEvent(new ValueEventListener() { @Override public void onDataChange(DataSnapshot dataSnapshot) { String res = dataSnapshot.getValue(); System.out.println(res); } });
Node.js
var admin = require("firebase-admin"); // Fetch the service account key JSON file contents var serviceAccount = require("path/to/serviceAccountKey.json"); // Initialize the app with a custom auth variable, limiting the server's access admin.initializeApp({ credential: admin.credential.cert(serviceAccount), // The database URL depends on the location of the database databaseURL: "https://DATABASE_NAME.firebaseio.com", databaseAuthVariableOverride: { uid: "my-service-worker" } }); // The app only has access as defined in the Security Rules var db = admin.database(); var ref = db.ref("/some_resource"); ref.once("value", function(snapshot) { console.log(snapshot.val()); });
Pyton
import firebase_admin from firebase_admin import credentials from firebase_admin import db # Fetch the service account key JSON file contents cred = credentials.Certificate('path/to/serviceAccountKey.json') # Initialize the app with a custom auth variable, limiting the server's access firebase_admin.initialize_app(cred, { 'databaseURL': 'https://databaseName.firebaseio.com', 'databaseAuthVariableOverride': { 'uid': 'my-service-worker' } }) # The app only has access as defined in the Security Rules ref = db.reference('/some_resource') print(ref.get())
Iść
ctx := context.Background() // Initialize the app with a custom auth variable, limiting the server's access ao := map[string]interface{}{"uid": "my-service-worker"} conf := &firebase.Config{ DatabaseURL: "https://databaseName.firebaseio.com", AuthOverride: &ao, } // Fetch the service account key JSON file contents opt := option.WithCredentialsFile("path/to/serviceAccountKey.json") app, err := firebase.NewApp(ctx, conf, opt) if err != nil { log.Fatalln("Error initializing app:", err) } client, err := app.Database(ctx) if err != nil { log.Fatalln("Error initializing database client:", err) } // The app only has access as defined in the Security Rules ref := client.NewRef("/some_resource") var data map[string]interface{} if err := ref.Get(ctx, &data); err != nil { log.Fatalln("Error reading from database:", err) } fmt.Println(data)
W niektórych przypadkach możesz chcieć ograniczyć pakiety Admin SDK, aby działały jako nieuwierzytelniony klient. Można to zrobić, podając wartość null
dla nadpisania zmiennej autoryzacji bazy danych.
Jawa
// Fetch the service account key JSON file contents FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json"); FirebaseOptions options = new FirebaseOptions.Builder() .setCredential(FirebaseCredentials.fromCertificate(serviceAccount)) // The database URL depends on the location of the database .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com") .setDatabaseAuthVariableOverride(null) .build(); FirebaseApp.initializeApp(options); // The app only has access to public data as defined in the Security Rules DatabaseReference ref = FirebaseDatabase .getInstance() .getReference("/public_resource"); ref.addListenerForSingleValueEvent(new ValueEventListener() { @Override public void onDataChange(DataSnapshot dataSnapshot) { String res = dataSnapshot.getValue(); System.out.println(res); } });
Node.js
var admin = require("firebase-admin"); // Fetch the service account key JSON file contents var serviceAccount = require("path/to/serviceAccountKey.json"); // Initialize the app with a null auth variable, limiting the server's access admin.initializeApp({ credential: admin.credential.cert(serviceAccount), // The database URL depends on the location of the database databaseURL: "https://DATABASE_NAME.firebaseio.com", databaseAuthVariableOverride: null }); // The app only has access to public data as defined in the Security Rules var db = admin.database(); var ref = db.ref("/public_resource"); ref.once("value", function(snapshot) { console.log(snapshot.val()); });
Pyton
import firebase_admin from firebase_admin import credentials from firebase_admin import db # Fetch the service account key JSON file contents cred = credentials.Certificate('path/to/serviceAccountKey.json') # Initialize the app with a None auth variable, limiting the server's access firebase_admin.initialize_app(cred, { 'databaseURL': 'https://databaseName.firebaseio.com', 'databaseAuthVariableOverride': None }) # The app only has access to public data as defined in the Security Rules ref = db.reference('/public_resource') print(ref.get())
Iść
ctx := context.Background() // Initialize the app with a nil auth variable, limiting the server's access var nilMap map[string]interface{} conf := &firebase.Config{ DatabaseURL: "https://databaseName.firebaseio.com", AuthOverride: &nilMap, } // Fetch the service account key JSON file contents opt := option.WithCredentialsFile("path/to/serviceAccountKey.json") app, err := firebase.NewApp(ctx, conf, opt) if err != nil { log.Fatalln("Error initializing app:", err) } client, err := app.Database(ctx) if err != nil { log.Fatalln("Error initializing database client:", err) } // The app only has access to public data as defined in the Security Rules ref := client.NewRef("/some_resource") var data map[string]interface{} if err := ref.Get(ctx, &data); err != nil { log.Fatalln("Error reading from database:", err) } fmt.Println(data)
Następne kroki
- Dowiedz się, jak ustrukturyzować dane w bazie danych czasu rzeczywistego.
- Skaluj dane w wielu instancjach bazy danych .
- Zapisz dane.
- Pobierać dane.
- Wyświetl swoją bazę danych w konsoli Firebase.