Admin SDK to zestaw bibliotek serwerowych, które umożliwiają interakcję z Firebase z uprzywilejowanych środowisk w celu wykonywania następujących czynności:
- Odczytuj i zapisuj dane bazy danych czasu rzeczywistego z pełnymi uprawnieniami administratora.
- Programowo wysyłaj wiadomości Firebase Cloud Messaging, korzystając z prostego, alternatywnego podejścia do protokołów serwera Firebase Cloud Messaging.
- Wygeneruj i zweryfikuj 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 na przykład wyszukiwać dane użytkownika lub zmieniać adres e-mail użytkownika w celu uwierzytelnienia.
Jeśli interesuje Cię używanie pakietu SDK Node.js jako klienta umożliwiającego dostęp użytkownika końcowego (na przykład w aplikacji komputerowej Node.js lub aplikacji IoT), zamiast dostępu administracyjnego z uprzywilejowanego środowiska (takiego jak serwer), możesz zamiast tego należy postępować 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 na temat integracji pakietu Admin SDK do tych zastosowań, zapoznaj się z odpowiednią dokumentacją Bazy danych czasu rzeczywistego , FCM , Uwierzytelnianie , Zdalna konfiguracja i Magazyn w chmurze . Pozostała część tej strony skupia się na podstawowej konfiguracji pakietu Admin SDK.
Warunki wstępne
Upewnij się, że masz aplikację serwerową.
Upewnij się, że na serwerze działają następujące elementy, w zależności od używanego pakietu Admin SDK:
- Admin SDK Node.js — Node.js 14+
- Administracja Java SDK — Java 8+
- Admin Python SDK — Python 3.6+ (polecamy Python 3.7+)
- Admin Go SDK — Przejdź do wersji 1.17+
- Admin .NET SDK — .NET Framework 4.6.1+ lub .NET Standard 2.0 dla .Net Core 2.0+
Skonfiguruj projekt i konto usługi Firebase
Aby korzystać z pakietu SDK administratora Firebase, będziesz potrzebować:
- Projekt Firebase.
- Konto usługi Firebase Admin SDK umożliwiające komunikację z Firebase. To konto usługi jest tworzone automatycznie podczas tworzenia projektu Firebase lub dodawania Firebase do projektu Google Cloud.
- Plik konfiguracyjny z danymi uwierzytelniającymi Twojego konta usługi.
Jeśli nie masz jeszcze projektu Firebase, musisz go utworzyć w konsoli Firebase . Odwiedź stronę Poznaj projekty Firebase, aby dowiedzieć się więcej o projektach Firebase.
Dodaj pakiet SDK
Jeśli konfigurujesz nowy projekt, musisz zainstalować SDK dla wybranego języka.
Node.js
Zestaw SDK administratora Firebase Node.js 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 SDK Java Firebase Admin 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.2.0'
}
Jeśli do budowy aplikacji używasz Mavena, możesz dodać następującą zależność do pliku pom.xml
:
<dependency>
<groupId>com.google.firebase</groupId>
<artifactId>firebase-admin</artifactId>
<version>9.2.0</version>
</dependency>
Pyton
Pakiet SDK Firebase Admin w języku Python jest dostępny za pośrednictwem pip . Możesz zainstalować bibliotekę dla wszystkich użytkowników za pomocą sudo
:
sudo pip install firebase-admin
Możesz też 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 install
:
# Install the latest version:
go install firebase.google.com/go/v4@latest
# Or install a specific version:
go install firebase.google.com/go/v4@4.13.0
C#
Zestaw .NET Admin SDK można zainstalować za pomocą menedżera pakietów .NET:
Install-Package FirebaseAdmin -Version 2.4.0
Alternatywnie zainstaluj go za pomocą narzędzia wiersza polecenia dotnet
:
dotnet add package FirebaseAdmin --version 2.4.0
Możesz też zainstalować go, dodając następujący wpis dotyczący pakietu do pliku .csproj
:
<ItemGroup>
<PackageReference Include="FirebaseAdmin" Version="2.4.0" />
</ItemGroup>
Zainicjuj zestaw SDK
Po utworzeniu projektu Firebase możesz zainicjować pakiet SDK przy użyciu domyślnych danych uwierzytelniających aplikacji Google . Ponieważ domyślne wyszukiwanie danych uwierzytelniających 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 dla usług, takich jak baza danych czasu rzeczywistego, Cloud Storage lub Cloud Functions, użyj zmiennej środowiskowej FIREBASE_CONFIG
. Jeśli zawartość zmiennej FIREBASE_CONFIG
zaczyna się od {
, zostanie ona przeanalizowana jako obiekt JSON. W przeciwnym razie zestaw SDK zakłada, że ciąg znaków 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 pakietu Admin SDK można używać do wykonywania następujących typów zadań:
- Zaimplementuj niestandardowe uwierzytelnianie
- Zarządzaj użytkownikami uwierzytelniania Firebase
- Odczytuj i zapisuj dane z bazy danych czasu rzeczywistego
- Wysyłaj wiadomości Firebase Cloud Messaging
Korzystanie z tokena odświeżania OAuth 2.0
Pakiet Admin SDK zapewnia również dane uwierzytelniające, 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 serwerów innych niż Google, w którym domyślne wyszukiwanie danych uwierzytelniających nie może być w pełni zautomatyzowane, możesz zainicjować pakiet SDK za pomocą 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ć je do dostępu 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 opcję Wygeneruj nowy klucz prywatny , a następnie potwierdź, klikając opcję Wygeneruj klucz .
Bezpiecznie przechowuj plik JSON zawierający klucz.
Podczas autoryzacji za pośrednictwem konta usługi masz dwie możliwości podania poświadczeń do 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ę 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 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 uwierzytelniające aplikacji (ADC) mogą niejawnie określić Twoje dane uwierzytelniające, umożliwiając korzystanie z danych uwierzytelniających 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(),
ProjectId = "my-project-id",
});
Zainicjuj wiele aplikacji
W większości przypadków wystarczy zainicjować tylko jedną domyślną aplikację. Dostęp do usług z poziomu tej aplikacji można uzyskać 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 utworzyć niestandardowe tokeny dla innego projektu. Możesz też chcieć uwierzytelnić dwie aplikacje przy użyciu oddzielnych poświadczeń. Pakiet SDK Firebase umożliwia jednoczesne tworzenie wielu aplikacji, każda z własnymi informacjami konfiguracyjnymi.
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 danymi uwierzytelniającymi aplikacji Google na potrzeby bazy danych w czasie rzeczywistym lub uwierzytelniania, pamiętaj o ustawieniu odpowiednich zakresów dostępu . W przypadku bazy danych w czasie rzeczywistym i uwierzytelniania potrzebne są zakresy kończące się na userinfo.email
i albo cloud-platform
albo firebase.database
. Aby sprawdzić istniejące zakresy dostępu i je zmienić, uruchom następujące polecenia za pomocą 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 przy użyciu danych logowania użytkownika końcowego gcloud
Podczas lokalnego testowania pakietu Admin SDK przy użyciu domyślnych danych uwierzytelniających aplikacji Google uzyskanych po uruchomieniu gcloud auth application-default login
, aby móc korzystać z uwierzytelniania Firebase, potrzebne są dodatkowe zmiany z następujących powodów:
- Uwierzytelnianie Firebase nie akceptuje danych uwierzytelniających użytkownika końcowego gcloud wygenerowanych przy użyciu identyfikatora klienta OAuth gcloud.
- Uwierzytelnianie Firebase wymaga podania identyfikatora projektu podczas inicjalizacji dla tego typu poświadczeń użytkownika końcowego.
Aby obejść ten problem, możesz wygenerować domyślne dane uwierzytelniające aplikacji Google w gcloud , korzystając z własnego identyfikatora klienta OAuth 2.0 . Identyfikator klienta OAuth musi być typem aplikacji aplikacji komputerowej .
gcloud
gcloud auth application-default login --client-id-file=[/path/to/client/id/file]
Możesz określić identyfikator projektu jawnie podczas inicjowania aplikacji lub po prostu użyć zmiennej środowiskowej GOOGLE_CLOUD_PROJECT
. To drugie pozwala uniknąć konieczności wprowadzania 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 serwisie GitHub dla Node.js , Java i Python .
Przeczytaj wpisy na blogu dotyczące pakietu Admin SDK, napisane przez jednego z twórców pakietu Admin SDK. Na przykład: Dostęp do Firestore i Firebase za pośrednictwem serwera proxy .
Dodaj funkcje Firebase do swojej aplikacji:
- Napisz backend bezserwerowy za pomocą Cloud Functions .
- Przechowuj informacje w bazie danych Realtime Database lub danych typu blob w Cloud Storage .
- Otrzymuj powiadomienia za pomocą usługi Cloud Messaging .