Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Dodaj pakiet Firebase Admin SDK do swojego serwera

Admin SDK to zestaw bibliotek serwerowych, które umożliwiają interakcję z Firebase z uprzywilejowanych środowisk w celu wykonywania takich czynności, jak:

  • Odczytuj i zapisuj dane Bazy danych czasu rzeczywistego z pełnymi uprawnieniami administratora.
  • Programistyczne wysyłanie wiadomości Firebase Cloud Messaging przy użyciu prostego, alternatywnego podejścia do protokołów serwera Firebase Cloud Messaging.
  • Generuj i weryfikuj tokeny uwierzytelniania 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 jesteś zainteresowany użyciem SDK Node.js jako klienta dla dostępu użytkownika końcowego (na przykład w aplikacji desktopowej lub aplikacji IoT Node.js), w przeciwieństwie do dostępu administracyjnego z uprzywilejowanego środowiska (takiego jak serwer), możesz należy zamiast postępować zgodnie z instrukcjami konfigurowania klienta JavaScript SDK .

Oto macierz funkcji pokazujący, jakie funkcje Firebase są obsługiwane w każdym języku:

Funkcja Node.js Jawa Pyton Udać się C#
Wybijanie niestandardowych tokenów
Weryfikacja tokena identyfikacyjnego
Zarządzanie użytkownikami
Kontroluj dostęp za pomocą oświadczeń niestandardowych
Odśwież token Odwołania
Importuj użytkowników
Zarządzanie plikami cookie sesji
Generowanie linków akcji e-mail
Zarządzanie konfiguracjami dostawców SAML/OIDC
Wsparcie dla wielu najemców
Baza danych czasu rzeczywistego *
Wiadomości w chmurze Firebase
Multiemisja FCM
Zarządzaj subskrypcjami tematów FCM
Magazyn w chmurze
Cloud Firestore
Zarządzanie projektami
Zasady bezpieczeństwa
Zarządzanie modelami ML
Zdalna konfiguracja Firebase
Sprawdzanie aplikacji Firebase

Aby dowiedzieć się więcej na temat integracji Admin SDK dla tych zastosowań, patrz odpowiednie bazy danych w czasie rzeczywistym , FCM , uwierzytelnianie , Remote Config i Cloud Storage dokumentacji. Pozostała część tej strony skupia się na podstawowej konfiguracji pakietu Admin SDK.

Wymagania wstępne

  • Upewnij się, że masz aplikację serwerową.

  • Upewnij się, że na Twoim serwerze działają następujące elementy w zależności od używanego pakietu Admin SDK:

    • Admin SDK Node.js — Node.js 12+
    • Admin Java SDK — Java 7+ (zalecana Java 8+)
      Obsługa Java 7 jest przestarzała.
    • Admin Python SDK — Python 3.6+
    • Admin Przejdź SDK — Przejdź 1.11+
    • Admin .NET SDK — .NET Framework 4.5+ lub .Net Core 1.5+

Skonfiguruj projekt i konto usługi Firebase

Aby korzystać z pakietu Firebase Admin SDK, potrzebujesz:

  • Projekt Firebase
  • Konto usługi do komunikacji z Firebase
  • Plik konfiguracyjny z danymi logowania konta usługi

Jeżeli nie masz jeszcze projekt Firebase, trzeba utworzyć w konsoli Firebase . Wizyta Zrozum Firebase Projekty aby dowiedzieć się więcej o projektach Firebase.

Dodaj pakiet SDK

Jeśli konfigurujesz nowy projekt, musisz zainstalować pakiet SDK dla wybranego języka.

Node.js

Pakiet SDK Firebase Admin Node.js jest dostępny w npm. Jeżeli nie masz jeszcze package.json pliku, utwórz je poprzez npm init . Następnie zainstalować firebase-admin pakiet npm i zapisać go na dysku package.json :

$ npm install firebase-admin --save

Aby korzystać z modułu w aplikacji, require to od każdego pliku javascript:

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

Jeśli używasz ES2015 można import moduł:

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

Jawa

Pakiet Firebase Admin Java SDK jest publikowany w centralnym repozytorium Maven. Aby zainstalować bibliotekę, zadeklarować go jako zależność w swoim build.gradle pliku:

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

Jeśli używasz Maven do budowania aplikacji, można dodać następującą zależność do pom.xml :

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

Pyton

Firebase Admin Python SDK jest dostępny poprzez pip . Można zainstalować bibliotekę dla wszystkich użytkowników poprzez sudo :

$ sudo pip install firebase-admin

Czy można zainstalować bibliotekę tylko dla bieżącego użytkownika poprzez przepuszczenie --user flagę:

$ pip install --user firebase-admin

Udać się

Go Admin SDK można zainstalować przy użyciu go get narzędzia:

# Install as a module dependency
$ go get firebase.google.com/go/v4

# Install to $GOPATH
$ go get firebase.google.com/go

C#

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

$ Install-Package FirebaseAdmin -Version 2.2.0

Alternatywnie, należy zainstalować go za pomocą dotnet narzędzia wiersza:

$ dotnet add package FirebaseAdmin --version 2.2.0

Lub, można go zainstalować dodając wpis odniesienia następujący pakiet do swojego .csproj pliku:

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

Zainicjuj pakiet SDK

Po utworzeniu projektu Firebase można zainicjować SDK ze strategią autoryzacji, który łączy plik konta usługi wraz z Google domyślną aplikacją poświadczenia .

Projekty Firebase obsługują Google kont usług , których można użyć, aby zadzwonić API serwera Firebase z serwera aplikacji lub zaufanym środowisku. 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 upoważnić 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, otwartych Ustawienia> Konta usług .

  2. Kliknij przycisk Utwórz nowy klucz prywatny, a następnie potwierdź klikając Generowanie klucza.

  3. Bezpiecznie przechowuj plik JSON zawierający klucz.

Podczas autoryzacji za pośrednictwem konta usługi masz dwie możliwości podania danych uwierzytelniających do swojej aplikacji. Można też ustawić GOOGLE_APPLICATION_CREDENTIALS zmienną środowiskową, czy można jednoznacznie przekazać ścieżkę do klucza konta usługi w kodzie. Pierwsza opcja jest bezpieczniejsza i zdecydowanie zalecana.

Aby ustawić zmienną środowiskową:

Ustawić zmienną środowiskową GOOGLE_APPLICATION_CREDENTIALS do ścieżki pliku pliku JSON, który zawiera 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 aplikacja Domyślne poświadczenia (ADC) aplikacji będzie w stanie domyślnie określić Twoje dane logowania, co pozwoli Ci używać danych logowania do konta usługi podczas testowania lub uruchamiania w środowiskach innych niż Google.

Zainicjuj pakiet 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()

Udać się

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

Korzystanie z tokena odświeżania OAuth 2.0

Admin SDK zapewnia również poświadczenia który umożliwia uwierzytelnianie z Google OAuth2 odświeżyć znak:

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)

Udać się

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 bez parametrów

Zestaw SDK można również zainicjować bez parametrów. W tym przypadku SDK wykorzystuje Google domyślną aplikacją poświadczeń . Ponieważ domyślne wyszukiwanie danych logowania jest w pełni zautomatyzowane w środowiskach Google, bez konieczności podawania zmiennych środowiskowych ani innej konfiguracji, ten sposób inicjowania pakietu SDK jest zdecydowanie zalecany w przypadku aplikacji działających w Compute Engine, Kubernetes Engine, App Engine i Cloud Functions.

Aby opcjonalnie określić inicjalizacji opcji dla usług takich jak Realtime Database Cloud Storage, lub funkcji Chmura, użyj FIREBASE_CONFIG zmienną środowiskową. Jeśli zawartość FIREBASE_CONFIG zmiennej zaczyna się od { będzie analizowany 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()

Udać się

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żyć pakietu Admin SDK, aby wykonać następujące rodzaje zadań:

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

Udać się

// 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 tworzenia 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ż uwierzytelnić dwie aplikacje za pomocą oddzielnych poświadczeń. Pakiet Firebase SDK umożliwia jednoczesne tworzenie wielu aplikacji, 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);

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)

Udać się

// 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 Google Compute Engine VM z Google domyślną aplikacją poświadczenia Realtime bazy danych lub uwierzytelniania, należy również ustalić odpowiednie zakresy dostępu . Realtime do bazy danych i uwierzytelniania, trzeba zakresy kończące się userinfo.email i albo cloud-platform lub firebase.database . Aby sprawdzić istniejących zakresów dostępu i zmienić je, uruchom następujące polecenia przy użyciu 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

Testując Admin SDK lokalnie z Google aplikacji domyślnych poświadczeń uzyskanych przez uruchomienie gcloud auth application-default login , potrzebne są dodatkowe zmiany do korzystania z uwierzytelniania Firebase ze względu na następujące kwestie:

  • Uwierzytelnianie Firebase nie akceptuje danych logowania użytkownika końcowego gcloud wygenerowanych przy użyciu identyfikatora klienta OAuth gcloud.
  • Uwierzytelnianie Firebase wymaga podania identyfikatora projektu podczas inicjowania dla tego typu danych logowania użytkownika końcowego.

Jako obejście, można wygenerować Google domyślną aplikacją poświadczenia w gcloud pomocą własnego OAuth 2.0 klienta identyfikator . Identyfikator klienta OAuth musi być stacjonarny aplikacja app.

gcloud

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

Można podać identyfikator projektu wyraźnie na inicjalizacji aplikacji lub po prostu użyć GOOGLE_CLOUD_PROJECT zmienną środowiskową. To ostatnie 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)

Udać się

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: