Dodawanie pakietu Firebase Admin SDK do serwera

Pakiet Admin SDK to zestaw bibliotek serwera, który umożliwia interakcję z Firebase w środowiskach z podwyższonymi uprawnieniami w celu wykonywania działań takich jak:

  • Odczytywanie i zapisywanie danych w Bazie danych czasu rzeczywistego z pełnymi uprawnieniami administratora.
  • Automatyczne wysyłanie wiadomości Komunikacja w chmurze Firebase (FCM) przy użyciu prostego, alternatywnego podejścia do protokołów serwera Komunikacji w chmurze Firebase (FCM).
  • Wygeneruj i zweryfikuj tokeny uwierzytelniania Firebase.
  • Dostęp do zasobów Google Cloud, takich jak zasobniki Cloud Storage i bazy danych Cloud Firestore powiązane z projektami Firebase.
  • Utwórz własną, uproszczoną konsolę administracyjną, aby móc na przykład wyszukiwać dane użytkownika lub zmieniać jego adresy e-mail na potrzeby uwierzytelniania.

Jeśli chcesz używać pakietu SDK Node.js jako klienta dostępu użytkowników (np. w aplikacji komputerowej Node.js lub aplikacji IoT), a nie w przypadku dostępu administracyjnego ze środowiska z podwyższonymi uprawnieniami (np. serwera), wykonaj instrukcje konfigurowania pakietu SDK JavaScript klienta.

Oto tabela funkcji z funkcjami Firebase obsługiwanymi w poszczególnych językach:

Cecha Node.js Java Python Go C#
Generowanie tokenów niestandardowych
Weryfikacja tokena tożsamości
Zarządzanie użytkownikami
Kontrola dostępu za pomocą żądań niestandardowych
Odświeżanie unieważnienia tokena
Importowanie użytkowników
Zarządzanie plikami cookie sesji
Generowanie linków do działań związanych z e-mailami
Zarządzanie konfiguracjami dostawców SAML/OIDC
Obsługa wielu najemców
Baza danych czasu rzeczywistego *
Komunikacja w chmurze Firebase
Multicast FCM
Zarządzanie subskrypcjami tematów w FCM
Cloud Storage,
Cloud Firestore
Dodawanie funkcji do kolejki za pomocą Cloud Tasks
Zarządzanie projektami
Reguły zabezpieczeń
Zarządzanie modelami ML
Zdalna konfiguracja Firebase
Sprawdzanie aplikacji Firebase
Rozszerzenia Firebase

Więcej informacji o integracji pakietu Admin SDK w tych zastosowaniach znajdziesz w odpowiednich dokumentach Bazy danych czasu rzeczywistego, FCM, Uwierzytelnianie, Zdalnej konfiguracji i Cloud Storage. Pozostała część tej strony dotyczy podstawowej konfiguracji pakietu Admin SDK.

Wymagania wstępne

  • Upewnij się, że masz aplikację serwera.

  • W zależności od używanego pakietu Admin SDK sprawdź, czy serwer działa zgodnie z tymi instrukcjami:

    • Pakiet Admin Node.js SDK – Node.js 14+ (zalecamy Node.js w wersji 18 lub nowszej)
      Obsługa Node.js 14 i 16 została wycofana.
    • Admin Java SDK – Java 8 lub nowsza
    • Admin Python SDK – Python w wersji 3.7 lub nowszej (zalecamy Pythona w wersji 3.8 lub nowszej)
      Obsługa Pythona 3.7 została wycofana.
    • SDK Admin Go – Go w wersji 1.20 lub nowszej
    • Konsola administracyjna .NET SDK — .NET Framework 4.6.2 lub nowsza albo .NET Standard 2.0 dla .NET w wersji 6.0 lub nowszej

Konfigurowanie projektu Firebase i konta usługi

Aby korzystać z pakietu Firebase Admin SDK, musisz mieć:

  • Masz projekt Firebase.
  • konto usługi pakietu Firebase Admin SDK do komunikowania się z Firebase, To konto usługi jest tworzone automatycznie podczas tworzenia projektu Firebase lub dodawania Firebase do projektu Google Cloud.
  • Plik konfiguracji z danymi logowania do konta usługi.

Jeśli nie masz jeszcze projektu Firebase, musisz go utworzyć w konsoli Firebase. Więcej informacji o projektach Firebase znajdziesz w artykule Omówienie projektów Firebase.

Dodaj SDK

Jeśli konfigurujesz nowy projekt, musisz zainstalować pakiet SDK w wybranym języku.

Node.js

Pakiet SDK Firebase Admin Node.js jest dostępny w npm. Jeśli nie masz jeszcze pliku package.json, utwórz go w npm init. Następnie zainstaluj pakiet npm firebase-admin i zapisz go w package.json:

npm install firebase-admin --save

Aby użyć modułu w swojej aplikacji, require z dowolnego pliku JavaScript:

const { initializeApp } = require('firebase-admin/app');

Jeśli używasz wersji ES2015, możesz import moduł:

import { initializeApp } from 'firebase-admin/app';

Java

Pakiet Firebase Admin Java SDK jest opublikowany w centralnym repozytorium Maven. Aby zainstalować bibliotekę, zadeklaruj ją jako zależność w pliku build.gradle:

dependencies {
  implementation 'com.google.firebase:firebase-admin:9.3.0'
}

Jeśli do kompilowania aplikacji używasz narzędzia Maven, do pom.xml możesz dodać tę zależność:

<dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>9.3.0</version>
</dependency>

Python

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

Możesz też zainstalować bibliotekę tylko dla bieżącego użytkownika, przekazując flagę --user:

pip install --user firebase-admin

Go

Pakiet SDK Go Admin można zainstalować za pomocą narzędzia go get:

# Install the latest version:
go get firebase.google.com/go/v4@latest

# Or install a specific version:
go get firebase.google.com/go/v4@4.14.1

C#

Pakiet .NET Admin SDK można zainstalować za pomocą menedżera pakietów .NET:

Install-Package FirebaseAdmin -Version 3.0.0

Możesz też zainstalować go za pomocą narzędzia wiersza poleceń dotnet:

dotnet add package FirebaseAdmin --version 3.0.0

Możesz też zainstalować go, dodając do pliku .csproj ten wpis odwołania do pakietu:

<ItemGroup>
  <PackageReference Include="FirebaseAdmin" Version="3.0.0" />
</ItemGroup>

Inicjowanie pakietu SDK

Po utworzeniu projektu Firebase możesz zainicjować pakiet SDK za pomocą domyślnych danych logowania aplikacji Google. W środowiskach Google wyszukiwanie domyślnych danych logowania jest w pełni zautomatyzowane i nie trzeba podawać zmiennych środowiskowych ani innej konfiguracji, dlatego zdecydowanie zalecamy ten sposób inicjowania pakietu SDK w przypadku aplikacji działających w środowiskach Google, takich jak Cloud Run, App Engine i Cloud Functions.

Aby opcjonalnie określić opcje inicjowania usług, takich jak Baza danych czasu rzeczywistego, Cloud Storage czy Cloud Functions, użyj zmiennej środowiskowej FIREBASE_CONFIG. Jeśli zawartość zmiennej FIREBASE_CONFIG zaczyna się od {, jest ona analizowana jako obiekt JSON. W przeciwnym razie pakiet SDK zakłada, że ciąg znaków to ścieżka do pliku JSON zawierającego opcje.

Node.js

const app = initializeApp();

Java

FirebaseApp.initializeApp();

Python

default_app = firebase_admin.initialize_app()

Go

app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

C#

FirebaseApp.Create();

Po zainicjowaniu możesz wykonywać te rodzaje zadań za pomocą pakietu Admin SDK:

Używanie tokena odświeżania OAuth 2.0

Pakiet Admin SDK udostępnia też 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'
});

Java

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

Python

cred = credentials.RefreshToken('path/to/refreshToken.json')
default_app = firebase_admin.initialize_app(cred)

Go

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)
}
init.go

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 serwerowym innym niż Google, w którym nie można w pełni zautomatyzować wyszukiwania domyślnych danych logowania, możesz zainicjować pakiet SDK za pomocą wyeksportowanego pliku klucza konta usługi.

Projekty Firebase obsługują konta usługi Google, których możesz używać do wywoływania interfejsów API serwera Firebase z serwera aplikacji lub zaufanego środowiska. Jeśli programujesz kod lokalnie lub wdrażasz aplikację lokalnie, możesz autoryzować żądania do serwera za pomocą danych logowania uzyskanych z tego konta usługi.

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 konta usługi:

  1. W konsoli Firebase otwórz Ustawienia > Konta usługi.

  2. Kliknij Wygeneruj nowy klucz prywatny, a następnie potwierdź, klikając Wygeneruj klucz.

  3. Bezpiecznie przechowuj plik JSON zawierający klucz.

Podczas autoryzacji za pomocą konta usługi masz 2 opcje udostępniania danych logowania do aplikacji. Możesz ustawić zmienną środowiskową GOOGLE_APPLICATION_CREDENTIALS lub bezpośrednio 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 ma zastosowanie tylko do bieżącej sesji powłoki, więc jeśli otworzysz nową sesję, ustaw ją ponownie.

Linux lub macOS

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

Windows

Za pomocą PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Gdy wykonasz powyższe czynności, domyślne dane uwierzytelniające aplikacji (ADC) będą mogły niejawnie określić Twoje dane logowania. Dzięki temu możesz używać danych logowania do konta usługi podczas testowania lub uruchamiania aplikacji w środowiskach innych niż Google.

Zainicjuj pakiet SDK w ten sposób:

Node.js

initializeApp({
    credential: applicationDefault(),
    databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Java

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
    .build();

FirebaseApp.initializeApp(options);

Python

default_app = firebase_admin.initialize_app()

Go

app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ProjectId = "my-project-id",
});

FirebaseAppSnippets.cs

Inicjowanie wielu aplikacji

W większości przypadków wystarczy zainicjować tylko jedną, domyślną aplikację. Dostęp do usług w tej aplikacji można uzyskać na 2 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();

Java

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

Python

# 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(...)

Go

// 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)
}
init.go

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ą utworzenia wielu aplikacji jednocześnie. Możesz na przykład odczytać dane z Bazy danych czasu rzeczywistego jednego projektu Firebase i wygenerować tokeny niestandardowe dla innego. Możesz też uwierzytelnić 2 aplikacje za pomocą różnych danych logowania. Pakiet SDK Firebase umożliwia utworzenie wielu aplikacji jednocześnie, z których każda ma własne informacje o konfiguracji.

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

Java

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

Python

# 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)

Go

// 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)
}
init.go

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 logowania aplikacji Google na potrzeby uwierzytelniania lub bazy danych czasu rzeczywistego, ustaw też odpowiednie zakresy dostępu. Aby korzystać z uwierzytelniania i Bazy danych czasu rzeczywistego, potrzebujesz zakresów kończących się na userinfo.email i cloud-platform lub firebase.database. Aby sprawdzić i zmienić istniejące zakresy dostępu, 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 za pomocą danych logowania użytkownika w gcloud

Podczas lokalnego testowania pakietu Admin SDK za pomocą domyślnych danych uwierzytelniających aplikacji Google uzyskanych za pomocą funkcji gcloud auth application-default login musisz wprowadzić dodatkowe zmiany, aby korzystać z uwierzytelniania Firebase, ponieważ:

  • Uwierzytelnianie Firebase nie akceptuje danych logowania użytkownika gcloud wygenerowanych za pomocą identyfikatora klienta OAuth w gcloud.
  • Uwierzytelnianie Firebase wymaga podawania identyfikatora projektu podczas inicjowania tego typu danych logowania użytkownika.

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ć typu aplikacji komputerowej.

gcloud

gcloud auth application-default login --client-id-file=[/path/to/client/id/file]

Identyfikator projektu możesz określić bezpośrednio podczas inicjowania aplikacji lub po prostu użyć zmiennej środowiskowej GOOGLE_CLOUD_PROJECT. Dzięki temu nie musisz wprowadzać żadnych dodatkowych zmian w celu przetestowania kodu.

Aby wyraźnie określić identyfikator projektu:

Node.js

import { initializeApp, applicationDefault } from 'firebase-admin/app';

initializeApp({
  credential: applicationDefault(),
  projectId: '<FIREBASE_PROJECT_ID>',
});

Java

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setProjectId("<FIREBASE_PROJECT_ID>")
    .build();

FirebaseApp.initializeApp(options);

Python

app_options = {'projectId': '<FIREBASE_PROJECT_ID>'}
default_app = firebase_admin.initialize_app(options=app_options)

Go

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

Dalsze kroki

Więcej informacji o Firebase:

Dodaj funkcje Firebase do swojej aplikacji: