Pakiet Admin SDK to zestaw bibliotek serwera, który umożliwia interakcję z Firebase z uprzywilejowanych środowisk w celu wykonywania działań, takich jak:
- Odczytuj i zapisuj dane bazy danych czasu rzeczywistego z pełnymi uprawnieniami administratora.
- Programowo wysyłaj wiadomości Firebase Cloud Messaging przy użyciu prostego, alternatywnego podejścia do protokołów serwera Firebase Cloud Messaging.
- Generuj i weryfikuj tokeny autoryzacji Firebase.
- Uzyskaj dostęp do zasobów Google Cloud, takich jak zasobniki Cloud Storage i bazy danych Cloud Firestore, powiązane z Twoimi projektami Firebase.
- Utwórz własną uproszczoną konsolę administracyjną, aby wykonywać takie czynności, jak wyszukiwanie danych użytkownika lub zmiana adresu e-mail użytkownika w celu uwierzytelnienia.
Jeśli chcesz używać zestawu Node.js SDK jako klienta do uzyskiwania dostępu przez użytkownika końcowego (na przykład w aplikacji Node.js na komputerze stacjonarnym lub w aplikacji IoT), w przeciwieństwie do dostępu administratora z uprzywilejowanego środowiska (takiego jak serwer), zamiast tego postępuj zgodnie z instrukcjami dotyczącymi konfigurowania klienta JavaScript SDK .
Oto macierz funkcji pokazująca, jakie funkcje Firebase są obsługiwane w każdym języku:
Aby dowiedzieć się więcej o integracji Admin SDK dla tych zastosowań, zapoznaj się z odpowiednią dokumentacją Realtime Database , FCM , Authentication , Remote Config i Cloud Storage . Pozostała część tej strony dotyczy podstawowej konfiguracji pakietu Admin SDK.
Wymagania wstępne
Upewnij się, że masz aplikację serwera.
Upewnij się, że Twój serwer działa w zależności od używanego pakietu Admin SDK:
- Admin Node.js SDK — Node.js 14+
- Admin Java SDK — Java 8+
- Admin Python SDK — Python 3.6+ (zalecany Python 3.7+)
- Admin Go SDK — Go 1.15+
- Admin .NET SDK — .NET Framework 4.6.1+ lub .NET Standard 2.0 dla .Net Core 2.0+
Skonfiguruj projekt Firebase i konto usługi
Aby korzystać z pakietu Firebase Admin SDK, potrzebujesz:
- Projekt Firebase.
- Konto usługi Firebase Admin SDK do komunikacji z Firebase. To konto usługi jest tworzone automatycznie podczas tworzenia projektu Firebase lub dodawania Firebase do projektu Google Cloud.
- Plik konfiguracyjny z poświadczeniami Twojego konta usługi.
Jeśli nie masz jeszcze projektu Firebase, musisz go utworzyć w konsoli Firebase . Odwiedź stronę Projekty Firebase, aby dowiedzieć się więcej o projektach Firebase.
Dodaj SDK
Jeśli konfigurujesz nowy projekt, musisz zainstalować zestaw SDK dla wybranego języka.
Node.js
Pakiet Firebase Admin Node.js SDK jest dostępny na npm. Jeśli nie masz jeszcze pliku package.json
, utwórz go za pomocą npm init
. Następnie zainstaluj pakiet firebase-admin
npm i zapisz go w pliku package.json
:
npm install firebase-admin --save
Aby użyć modułu w swojej aplikacji, require
go z dowolnego pliku JavaScript:
const { initializeApp } = require('firebase-admin/app');
Jeśli używasz ES2015, możesz import
moduł:
import { initializeApp } from 'firebase-admin/app';
Jawa
Pakiet Firebase Admin Java SDK jest publikowany w centralnym repozytorium Maven. Aby zainstalować bibliotekę, zadeklaruj ją jako zależność w pliku build.gradle
:
dependencies {
implementation 'com.google.firebase:firebase-admin:9.1.1'
}
Jeśli używasz Mavena do budowania aplikacji, możesz dodać następującą zależność do pliku pom.xml
:
<dependency>
<groupId>com.google.firebase</groupId>
<artifactId>firebase-admin</artifactId>
<version>9.1.1</version>
</dependency>
Pyton
Pakiet Firebase Admin Python SDK jest dostępny przez pip . Możesz zainstalować bibliotekę dla wszystkich użytkowników za pomocą sudo
:
sudo pip install firebase-admin
Lub możesz zainstalować bibliotekę tylko dla bieżącego użytkownika, przekazując flagę --user
:
pip install --user firebase-admin
Iść
Pakiet Go Admin SDK można zainstalować za pomocą narzędzia go get
:
# Install as a module dependency
go get firebase.google.com/go/v4
# Install to $GOPATH
go get firebase.google.com/go
C#
Pakiet .NET Admin SDK można zainstalować za pomocą menedżera pakietów .NET:
Install-Package FirebaseAdmin -Version 2.3.0
Alternatywnie zainstaluj go za pomocą narzędzia wiersza polecenia dotnet
:
dotnet add package FirebaseAdmin --version 2.3.0
Lub możesz go zainstalować, dodając następujący wpis odwołania do pakietu do pliku .csproj
:
<ItemGroup>
<PackageReference Include="FirebaseAdmin" Version="2.3.0" />
</ItemGroup>
Zainicjuj zestaw SDK
Po utworzeniu projektu Firebase możesz zainicjować pakiet SDK za pomocą Google Application Default Credentials . Ponieważ wyszukiwanie domyślnych danych logowania jest w środowiskach Google w pełni zautomatyzowane i nie wymaga podawania zmiennych środowiskowych ani innej konfiguracji, ten sposób inicjowania pakietu SDK jest zdecydowanie zalecany w przypadku aplikacji działających w środowiskach Google, takich jak Cloud Run, App Engine i Cloud Functions.
Aby opcjonalnie określić opcje inicjalizacji usług, takich jak Baza danych czasu rzeczywistego, Magazyn w chmurze lub Funkcje w chmurze, użyj zmiennej środowiskowej FIREBASE_CONFIG
. Jeśli zawartość zmiennej FIREBASE_CONFIG
zaczyna się od {
, zostanie przeanalizowana jako obiekt JSON. W przeciwnym razie zestaw SDK zakłada, że ciąg jest ścieżką do pliku JSON zawierającego opcje.
Node.js
const app = initializeApp();
Jawa
FirebaseApp.initializeApp();
Pyton
default_app = firebase_admin.initialize_app()
Iść
app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
C#
FirebaseApp.Create();
Po zainicjowaniu możesz używać pakietu Admin SDK do wykonywania następujących typów zadań:
- Zaimplementuj niestandardowe uwierzytelnianie
- Zarządzaj użytkownikami uwierzytelniania Firebase
- Odczytywanie i zapisywanie danych z bazy danych czasu rzeczywistego
- Wysyłaj wiadomości Firebase Cloud Messaging
Używanie tokenu odświeżania OAuth 2.0
Pakiet Admin SDK zapewnia również poświadczenia, które umożliwiają uwierzytelnianie za pomocą tokena odświeżania Google OAuth2 :
Node.js
const myRefreshToken = '...'; // Get refresh token from OAuth2 flow
initializeApp({
credential: refreshToken(myRefreshToken),
databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});
Jawa
FileInputStream refreshToken = new FileInputStream("path/to/refreshToken.json");
FirebaseOptions options = FirebaseOptions.builder()
.setCredentials(GoogleCredentials.fromStream(refreshToken))
.setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
.build();
FirebaseApp.initializeApp(options);
Pyton
cred = credentials.RefreshToken('path/to/refreshToken.json')
default_app = firebase_admin.initialize_app(cred)
Iść
opt := option.WithCredentialsFile("path/to/refreshToken.json")
config := &firebase.Config{ProjectID: "my-project-id"}
app, err := firebase.NewApp(context.Background(), config, opt)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
C#
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.FromFile("path/to/refreshToken.json"),
});
Zainicjuj pakiet SDK w środowiskach innych niż Google
Jeśli pracujesz w środowisku serwera innym niż Google, w którym domyślne wyszukiwanie danych logowania nie może być w pełni zautomatyzowane, możesz zainicjować pakiet SDK przy użyciu wyeksportowanego pliku klucza konta usługi.
Projekty Firebase obsługują konta usług Google , których możesz używać do wywoływania interfejsów API serwera Firebase z serwera aplikacji lub zaufanego środowiska. Jeśli tworzysz kod lokalnie lub wdrażasz aplikację lokalnie, możesz użyć poświadczeń uzyskanych za pośrednictwem tego konta usługi, aby autoryzować żądania serwera.
Aby uwierzytelnić konto usługi i autoryzować dostęp do usług Firebase, musisz wygenerować plik klucza prywatnego w formacie JSON.
Aby wygenerować plik klucza prywatnego dla swojego konta usługi:
W konsoli Firebase otwórz Ustawienia > Konta usług .
Kliknij Generuj nowy klucz prywatny , a następnie potwierdź, klikając Generuj klucz .
Bezpiecznie przechowuj plik JSON zawierający klucz.
W przypadku autoryzacji za pośrednictwem konta usługi masz dwie możliwości podania poświadczeń aplikacji. Możesz ustawić zmienną środowiskową GOOGLE_APPLICATION_CREDENTIALS lub jawnie przekazać ścieżkę do klucza konta usługi w kodzie. Pierwsza opcja jest bezpieczniejsza i zdecydowanie zalecana.
Aby ustawić zmienną środowiskową:
Ustaw zmienną środowiskową GOOGLE_APPLICATION_CREDENTIALS na ścieżkę do pliku JSON zawierającego klucz konta usługi. Ta zmienna dotyczy tylko bieżącej sesji powłoki, więc jeśli otworzysz nową sesję, ustaw tę zmienną ponownie.
Linux lub macOS
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
Okna
Z PowerShellem:
$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"
Po wykonaniu powyższych kroków domyślne dane logowania aplikacji (ADC) mogą niejawnie określić Twoje dane logowania, umożliwiając korzystanie z danych logowania do konta usługi podczas testowania lub uruchamiania w środowiskach innych niż Google.
Zainicjuj zestaw SDK, jak pokazano:
Node.js
initializeApp({
credential: applicationDefault(),
databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});
Jawa
FirebaseOptions options = FirebaseOptions.builder()
.setCredentials(GoogleCredentials.getApplicationDefault())
.setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
.build();
FirebaseApp.initializeApp(options);
Pyton
default_app = firebase_admin.initialize_app()
Iść
app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
C#
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.GetApplicationDefault(),
});
Zainicjuj wiele aplikacji
W większości przypadków wystarczy zainicjować tylko jedną, domyślną aplikację. Możesz uzyskać dostęp do usług poza tą aplikacją na dwa równoważne sposoby:
Node.js
// Initialize the default app
const defaultApp = initializeApp(defaultAppConfig);
console.log(defaultApp.name); // '[DEFAULT]'
// Retrieve services via the defaultApp variable...
let defaultAuth = getAuth(defaultApp);
let defaultDatabase = getDatabase(defaultApp);
// ... or use the equivalent shorthand notation
defaultAuth = getAuth();
defaultDatabase = getDatabase();
Jawa
// Initialize the default app
FirebaseApp defaultApp = FirebaseApp.initializeApp(defaultOptions);
System.out.println(defaultApp.getName()); // "[DEFAULT]"
// Retrieve services by passing the defaultApp variable...
FirebaseAuth defaultAuth = FirebaseAuth.getInstance(defaultApp);
FirebaseDatabase defaultDatabase = FirebaseDatabase.getInstance(defaultApp);
// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.getInstance();
defaultDatabase = FirebaseDatabase.getInstance();
Pyton
# Import the Firebase service
from firebase_admin import auth
# Initialize the default app
default_app = firebase_admin.initialize_app(cred)
print(default_app.name) # "[DEFAULT]"
# Retrieve services via the auth package...
# auth.create_custom_token(...)
Iść
// Initialize default app
app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
// Access auth service from the default app
client, err := app.Auth(context.Background())
if err != nil {
log.Fatalf("error getting Auth client: %v\n", err)
}
C#
// Initialize the default app
var defaultApp = FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.GetApplicationDefault(),
});
Console.WriteLine(defaultApp.Name); // "[DEFAULT]"
// Retrieve services by passing the defaultApp variable...
var defaultAuth = FirebaseAuth.GetAuth(defaultApp);
// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.DefaultInstance;
Niektóre przypadki użycia wymagają jednoczesnego utworzenia wielu aplikacji. Na przykład możesz chcieć odczytać dane z bazy danych czasu rzeczywistego jednego projektu Firebase i wybić niestandardowe tokeny dla innego projektu. Możesz też chcieć uwierzytelnić dwie aplikacje przy użyciu oddzielnych poświadczeń. Pakiet Firebase SDK umożliwia jednoczesne tworzenie wielu aplikacji, z których każda ma własne informacje konfiguracyjne.
Node.js
// Initialize the default app
initializeApp(defaultAppConfig);
// Initialize another app with a different config
var otherApp = initializeApp(otherAppConfig, 'other');
console.log(getApp().name); // '[DEFAULT]'
console.log(otherApp.name); // 'other'
// Use the shorthand notation to retrieve the default app's services
const defaultAuth = getAuth();
const defaultDatabase = getDatabase();
// Use the otherApp variable to retrieve the other app's services
const otherAuth = getAuth(otherApp);
const otherDatabase = getDatabase(otherApp);
Jawa
// Initialize the default app
FirebaseApp defaultApp = FirebaseApp.initializeApp(defaultOptions);
// Initialize another app with a different config
FirebaseApp otherApp = FirebaseApp.initializeApp(otherAppConfig, "other");
System.out.println(defaultApp.getName()); // "[DEFAULT]"
System.out.println(otherApp.getName()); // "other"
// Use the shorthand notation to retrieve the default app's services
FirebaseAuth defaultAuth = FirebaseAuth.getInstance();
FirebaseDatabase defaultDatabase = FirebaseDatabase.getInstance();
// Use the otherApp variable to retrieve the other app's services
FirebaseAuth otherAuth = FirebaseAuth.getInstance(otherApp);
FirebaseDatabase otherDatabase = FirebaseDatabase.getInstance(otherApp);
Pyton
# Initialize the default app
default_app = firebase_admin.initialize_app(cred)
# Initialize another app with a different config
other_app = firebase_admin.initialize_app(cred, name='other')
print(default_app.name) # "[DEFAULT]"
print(other_app.name) # "other"
# Retrieve default services via the auth package...
# auth.create_custom_token(...)
# Use the `app` argument to retrieve the other app's services
# auth.create_custom_token(..., app=other_app)
Iść
// Initialize the default app
defaultApp, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
// Initialize another app with a different config
opt := option.WithCredentialsFile("service-account-other.json")
otherApp, err := firebase.NewApp(context.Background(), nil, opt)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
// Access Auth service from default app
defaultClient, err := defaultApp.Auth(context.Background())
if err != nil {
log.Fatalf("error getting Auth client: %v\n", err)
}
// Access auth service from other app
otherClient, err := otherApp.Auth(context.Background())
if err != nil {
log.Fatalf("error getting Auth client: %v\n", err)
}
C#
// Initialize the default app
var defaultApp = FirebaseApp.Create(defaultOptions);
// Initialize another app with a different config
var otherApp = FirebaseApp.Create(otherAppConfig, "other");
Console.WriteLine(defaultApp.Name); // "[DEFAULT]"
Console.WriteLine(otherApp.Name); // "other"
// Use the shorthand notation to retrieve the default app's services
var defaultAuth = FirebaseAuth.DefaultInstance;
// Use the otherApp variable to retrieve the other app's services
var otherAuth = FirebaseAuth.GetAuth(otherApp);
Ustaw zakresy dla bazy danych czasu rzeczywistego i uwierzytelniania
Jeśli używasz maszyny wirtualnej Google Compute Engine z domyślnymi poświadczeniami aplikacji Google dla bazy danych czasu rzeczywistego lub uwierzytelniania, pamiętaj o ustawieniu odpowiednich zakresów dostępu . W przypadku bazy danych czasu rzeczywistego i uwierzytelniania potrzebne są zakresy kończące się na userinfo.email
i cloud-platform
lub firebase.database
. Aby sprawdzić istniejące zakresy dostępu i je zmienić, uruchom następujące polecenia za pomocą narzędzia gcloud .
gcloud
# Check the existing access scopes
gcloud compute instances describe [INSTANCE_NAME] --format json
# The above command returns the service account information. For example:
"serviceAccounts": [
{
"email": "your.gserviceaccount.com",
"scopes": [
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/userinfo.email"
]
}
],
# Stop the VM, then run the following command, using the service account
# that gcloud returned when you checked the scopes.
gcloud compute instances set-service-account [INSTANCE_NAME] --service-account "your.gserviceaccount.com" --scopes "https://www.googleapis.com/auth/firebase.database,https://www.googleapis.com/auth/userinfo.email"
Testowanie z poświadczeniami użytkownika końcowego gcloud
Podczas lokalnego testowania pakietu Admin SDK przy użyciu domyślnych danych logowania aplikacji Google uzyskanych za pomocą polecenia gcloud auth application-default login
wymagane są dodatkowe zmiany w celu korzystania z uwierzytelniania Firebase z następujących powodów:
- Uwierzytelnianie Firebase nie akceptuje danych logowania użytkownika końcowego gcloud wygenerowanych przy użyciu identyfikatora klienta gcloud OAuth.
- Uwierzytelnianie Firebase wymaga podania identyfikatora projektu podczas inicjalizacji dla tego typu danych logowania użytkownika końcowego.
Aby obejść ten problem, możesz wygenerować domyślne dane logowania aplikacji Google w gcloud przy użyciu własnego identyfikatora klienta OAuth 2.0 . Identyfikator klienta OAuth musi być typem aplikacji aplikacji klasycznej .
gcloud
gcloud auth application-default login --client-id-file=[/path/to/client/id/file]
Identyfikator projektu można określić bezpośrednio podczas inicjowania aplikacji lub po prostu użyć zmiennej środowiskowej GOOGLE_CLOUD_PROJECT
. Ta ostatnia pozwala uniknąć konieczności wprowadzania jakichkolwiek dodatkowych zmian w celu przetestowania kodu.
Aby jawnie określić identyfikator projektu:
Node.js
import { initializeApp, applicationDefault } from 'firebase-admin/app';
initializeApp({
credential: applicationDefault(),
projectId: '<FIREBASE_PROJECT_ID>',
});
Jawa
FirebaseOptions options = FirebaseOptions.builder()
.setCredentials(GoogleCredentials.getApplicationDefault())
.setProjectId("<FIREBASE_PROJECT_ID>")
.build();
FirebaseApp.initializeApp(options);
Pyton
app_options = {'projectId': '<FIREBASE_PROJECT_ID>'}
default_app = firebase_admin.initialize_app(options=app_options)
Iść
config := &firebase.Config{ProjectID: "<FIREBASE_PROJECT_ID>"}
app, err := firebase.NewApp(context.Background(), config)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
C#
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.GetApplicationDefault(),
ProjectId = "<FIREBASE_PROJECT_ID>",
});
Następne kroki
Dowiedz się więcej o Firebase:
Poznaj przykładowe aplikacje Firebase .
Zapoznaj się z otwartym kodem źródłowym w GitHub dla Node.js , Java i Python .
Przeczytaj posty na blogu jednego z twórców pakietu Admin SDK dotyczące pakietu Admin SDK. Na przykład: Dostęp do Firestore i Firebase przez serwer proxy .
Dodaj funkcje Firebase do swojej aplikacji:
- Napisz backend bezserwerowy za pomocą Cloud Functions .
- Przechowuj informacje za pomocą bazy danych czasu rzeczywistego lub danych blob za pomocą Cloud Storage .
- Otrzymuj powiadomienia za pomocą Cloud Messaging .