Dodawanie pakietu Firebase Admin SDK do serwera

Admin SDK to zestaw bibliotek serwera, które umożliwiają interakcję z Firebase w środowiskach uprzywilejowanych w celu wykonywania takich działań jak:

  • Wykonywanie zapytań i mutacji w usłudze Firebase SQL Connect na potrzeby zarządzania danymi zbiorczymi i innych operacji z pełnymi uprawnieniami administratora.
  • Odczytywanie i zapisywanie danych Realtime Database z pełnymi uprawnieniami administratora.
  • Programowe wysyłanie wiadomości Firebase Cloud Messaging za pomocą prostego, alternatywnego podejścia do protokołów serwera Firebase Cloud Messaging.
  • generować i weryfikować tokeny uwierzytelniania Firebase;
  • Dostęp do zasobów Google Cloud, takich jak Cloud Storage zasobniki i Cloud Firestore bazy danych powiązane z Twoimi projektami Firebase.
  • Utwórz własną uproszczoną konsolę administracyjną, aby wykonywać takie czynności jak wyszukiwanie danych użytkowników czy zmiana adresu e-mail użytkownika na potrzeby uwierzytelniania.

Jeśli chcesz używać pakietu SDK Node.js jako klienta do uzyskiwania dostępu przez użytkowników (np. w aplikacji na komputery lub urządzenia IoT w Node.js), a nie dostępu administracyjnego ze środowiska z uprawnieniami (np. serwera), postępuj zgodnie z instrukcjami konfigurowania pakietu SDK JavaScript klienta.

Poniżej znajdziesz tabelę funkcji, która pokazuje, które funkcje Firebase są obsługiwane w poszczególnych językach:

Funkcja Node.js Java Python Go C# Dart 
Tworzenie tokenów niestandardowych
Weryfikacja tokena tożsamości
Zarządzanie użytkownikami
Kontrolowanie dostępu za pomocą niestandardowych roszczeń
Unieważnienie tokena odświeżania
Importowanie użytkowników
Zarządzanie plikami cookie sesji
Generowanie linków do działań w e-mailach
Zarządzanie konfiguracjami dostawców SAML/OIDC
Obsługa wielu najemców
Firebase SQL Connect
Realtime Database *
Firebase Cloud Messaging
FCM Multicast
Zarządzaj FCM subskrypcjami tematów
Cloud Storage
Cloud Firestore
Kolejkowanie funkcji za pomocą Cloud Tasks
Zarządzanie projektami
Reguły zabezpieczeń
Zarządzanie modelami ML
Firebase Remote Config
Firebase App Check
Firebase Extensions
Firebase Phone Number Verification

Więcej informacji o integracji Admin SDK w tych przypadkach znajdziesz w odpowiedniej dokumentacji: Realtime Database, FCM, Authentication, Remote Config i Cloud Storage. Dalsza część tej strony dotyczy podstawowej konfiguracji Admin SDK.

Wymagania wstępne

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

  • Sprawdź, czy na serwerze działa odpowiedni system w zależności od używanego Admin SDK:

    • Pakiet SDK Node.js do administracji – Node.js 18 lub nowszy (zalecany Node.js 20 lub nowszy)
      Obsługa Node.js 18 została wycofana.
    • Admin Java SDK – Java 8 lub nowsza
    • Pakiet SDK administracji w Pythonie – Python 3.9 lub nowszy (zalecany Python 3.10 lub nowszy)
      Obsługa Pythona 3.9 została wycofana.
    • Admin Go SDK – Go 1.23 lub nowszy
    • Pakiet SDK administracyjny .NET – .NET Framework 4.6.2 lub nowszy albo .NET Standard 2.0 lub .NET 6.0 lub nowszy (zalecany .NET 8.0 lub nowszy)
      Obsługa .NET 6.0 i 7.0 została wycofana.
    • Eksperymentalny pakiet SDK do administracji w Dart – upewnij się, że serwer używa pakietu SDK w Dart w wersji 3.9 lub nowszej.

Skonfiguruj projekt w Firebase i konto usługi

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

  • Masz projekt Firebase.
  • Konto usługi pakietu Firebase Admin SDK do komunikacji z Firebase. To konto usługi jest tworzone automatycznie podczas tworzenia projektu w Firebase lub dodawania Firebase do projektu Google Cloud.
  • plik konfiguracyjny z danymi logowania do konta usługi;

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

Dodawanie SDK

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

Node.js

Pakiet Firebase Admin Node.js SDK jest dostępny w npm. Jeśli nie masz jeszcze pliku package.json, utwórz go za pomocą 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 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';

Java

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.8.0'
}

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

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

Python

Pakiet Firebase Admin Python SDK jest dostępny w pip. Bibliotekę możesz zainstalować dla wszystkich użytkowników za pomocą tego polecenia: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

Narzędzie Go Admin SDK 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.19.0

C#

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

Install-Package FirebaseAdmin -Version 3.5.0

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

dotnet add package FirebaseAdmin --version 3.5.0

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

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

Dart (eksperymentalny)

dart pub add firebase_admin_sdk

Aby użyć modułu w aplikacji, zaimportuj go w ten sposób:

import 'package:firebase_admin_sdk';

// Also import the separate Firestore package if you're interacting with Firestore.
import 'package:google_cloud_firestore/google_cloud_firestore.dart';

Inicjowanie pakietu SDK

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

Aby opcjonalnie określić opcje inicjowania usług, takich jak Realtime Database, Cloud Storage lub Cloud Functions, użyj zmiennej środowiskowej FIREBASE_CONFIG. Jeśli zawartość zmiennej FIREBASE_CONFIG zaczyna się od znaku {, zostanie ona przeanalizowana jako obiekt JSON. W przeciwnym razie pakiet SDK zakłada, że ciąg znaków jest ścieżką 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();

Dart (eksperymentalny)

final admin = FirebaseApp.initializeApp();

Po zainicjowaniu możesz użyć Admin SDK do wykonania tych typów zadań:

Korzystanie z tokena odświeżania OAuth 2.0

Admin SDK udostępnia też dane logowania, 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 = CredentialFactory.FromFile<UserCredential>("path/to/refreshToken.json").ToGoogleCredential(),
});

Inicjowanie pakietu SDK w środowiskach innych niż Google

Jeśli pracujesz w środowisku serwera innego niż Google, w którym domyślne wyszukiwanie danych logowania 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ługi 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ć danych logowania uzyskanych za pomocą tego konta usługi do autoryzowania żądań serwera.

Wszystkie konta usługi w projekcie w Firebase możesz wyświetlić na karcie Ustawienia > Konta usługi.

Aby uwierzytelnić konto usługi i przyznać mu uprawnienia 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 > kartę 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 możliwości przekazania danych logowania 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 jest stosowana tylko w 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

W PowerShell:

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

Po wykonaniu powyższych czynności domyślne uwierzytelnianie aplikacji (ADC) będzie mogło niejawnie określać Twoje dane logowania, co umożliwi Ci używanie danych logowania konta usługi podczas testowania lub uruchamiania 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ć jedną domyślną aplikację. Dostęp do usług 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;

W niektórych przypadkach musisz utworzyć kilka aplikacji jednocześnie. Możesz na przykład odczytywać dane z Realtime Database jednego projektu w Firebase i generować niestandardowe tokeny dla innego projektu. Możesz też chcieć uwierzytelnić 2 aplikacje za pomocą osobnych danych logowania. Pakiet SDK Firebase umożliwia tworzenie 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 Realtime Database i Authentication

Jeśli używasz maszyny wirtualnej Google Compute Engine z domyślnym uwierzytelnianiem aplikacji Google w przypadku Realtime Database lub Authentication, pamiętaj, aby ustawić odpowiednie zakresy dostępu. W przypadku Realtime Database i Authentication potrzebujesz zakresów kończących się na userinfo.email oraz cloud-platform lub firebase.database. Aby sprawdzić istniejące zakresy dostępu i je zmienić, uruchom te 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 z użyciem danych logowania użytkownika gcloud

Podczas testowania Admin SDK lokalnie za pomocą domyślnego uwierzytelniania aplikacji Google uzyskanego przez uruchomienie gcloud auth application-default login konieczne są dodatkowe zmiany, aby używać Firebase Authentication z tych powodów:

  • Firebase Authentication nie akceptuje danych logowania użytkownika gcloud wygenerowanych za pomocą identyfikatora klienta OAuth gcloud.
  • Firebase Authentication wymaga podania identyfikatora projektu podczas inicjowania tych typów danych logowania użytkownika.

Aby obejść ten problem, możesz wygenerować domyślne uwierzytelnianie aplikacji Google w gcloud, używając własnego identyfikatora klienta OAuth 2.0. Identyfikator klienta OAuth musi być typu Aplikacja na komputer.

gcloud

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

Identyfikator projektu możesz podać jawnie podczas inicjowania aplikacji lub po prostu użyć zmiennej środowiskowej GOOGLE_CLOUD_PROJECT. Dzięki temu nie musisz wprowadzać żadnych dodatkowych zmian, aby przetestować kod.

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 do aplikacji funkcje Firebase: