Dodaj pakiet SDK administratora Firebase do swojego serwera

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:

Funkcja Node.js Jawa Pyton Iść C#
Niestandardowe bicie tokenów
Weryfikacja tokena identyfikacyjnego
Zarządzanie użytkownikami
Kontroluj dostęp za pomocą niestandardowych oświadczeń
Odśwież unieważnienie tokenu
Importuj użytkowników
Zarządzanie plikami cookie sesji
Generowanie linków do działań e-mailowych
Zarządzanie konfiguracjami dostawców SAML/OIDC
Wsparcie dla wielu najemców
Baza danych czasu rzeczywistego *
Wiadomości w chmurze Firebase
Transmisja grupowa FCM
Zarządzaj subskrypcjami tematów FCM
Magazyn w chmurze
Chmura Firestore
Zarządzanie projektami
Zasady bezpieczeństwa
Zarządzanie modelami ML
Zdalna konfiguracja Firebase
Kontrola aplikacji Firebase
Rozszerzenia Firebase

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 Node.js SDK — Node.js 14+ (polecamy Node.js 16+)
      Obsługa Node.js 14 jest przestarzała.
    • Administracja Java SDK — Java 8+
    • Admin Python SDK — Python 3.7+ (polecamy Python 3.8+)
      Obsługa języka Python 3.7 jest przestarzała.
    • 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 ma potrzeby 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ń:

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 serwerowym innym 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:

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

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

  3. 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:

Dodaj funkcje Firebase do swojej aplikacji: