Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Dodaj pakiet Firebase Admin SDK do swojego serwera

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

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

  • Odczytuj i zapisuj dane bazy danych czasu rzeczywistego z pełnymi uprawnieniami administratora.
  • Programowo wysyłaj wiadomości Firebase Cloud Messaging przy użyciu prostego, alternatywnego podejścia do protokołów serwera Firebase Cloud Messaging.
  • Generuj i weryfikuj 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 wykonywać takie czynności, jak wyszukiwanie danych użytkownika lub zmiana adresu e-mail użytkownika w celu uwierzytelnienia.

Jeśli chcesz używać zestawu Node.js SDK jako klienta do uzyskiwania dostępu przez użytkownika końcowego (na przykład w aplikacji Node.js na komputerze stacjonarnym lub w aplikacji IoT), w przeciwieństwie do dostępu administratora z uprzywilejowanego środowiska (takiego jak serwer), zamiast tego postępuj 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ż odwołanie tokena
Importuj użytkowników
Zarządzanie sesyjnymi plikami cookie
Generowanie linków akcji e-mail
Zarządzanie konfiguracjami dostawców SAML/OIDC
Obsługa wielu najemców
Baza danych czasu rzeczywistego *
Przesyłanie 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
Rozszerzenia Firebase

Aby dowiedzieć się więcej o integracji Admin SDK dla tych zastosowań, zapoznaj się z odpowiednią dokumentacją Realtime Database , FCM , Authentication , Remote Config i Cloud Storage . Pozostała część tej strony dotyczy podstawowej konfiguracji pakietu Admin SDK.

Wymagania wstępne

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

  • Upewnij się, że Twój serwer działa w zależności od używanego pakietu Admin SDK:

    • Admin Node.js SDK — Node.js 14+
    • Admin Java SDK — Java 8+
    • Admin Python SDK — Python 3.6+ (zalecany Python 3.7+)
    • Admin Go SDK — Go 1.15+
    • Admin .NET SDK — .NET Framework 4.6.1+ lub .NET Standard 2.0 dla .Net Core 2.0+

Skonfiguruj projekt Firebase i konto usługi

Aby korzystać z pakietu Firebase Admin SDK, potrzebujesz:

  • Projekt Firebase.
  • Konto usługi Firebase Admin SDK do komunikacji z Firebase. To konto usługi jest tworzone automatycznie podczas tworzenia projektu Firebase lub dodawania Firebase do projektu Google Cloud.
  • Plik konfiguracyjny z poświadczeniami Twojego konta usługi.

Jeśli nie masz jeszcze projektu Firebase, musisz go utworzyć w konsoli Firebase . Odwiedź stronę Projekty Firebase , aby dowiedzieć się więcej o projektach Firebase.

Dodaj SDK

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

Node.js

Pakiet Firebase Admin Node.js SDK 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 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 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.1.1'
}

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

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

Pyton

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

Lub możesz 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 get :

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

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

C#

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

Install-Package FirebaseAdmin -Version 2.3.0

Alternatywnie zainstaluj go za pomocą narzędzia wiersza polecenia dotnet :

dotnet add package FirebaseAdmin --version 2.3.0

Lub możesz go zainstalować, dodając następujący wpis odwołania do pakietu do pliku .csproj :

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

Zainicjuj zestaw SDK

Po utworzeniu projektu Firebase możesz zainicjować pakiet SDK za pomocą strategii autoryzacji, która łączy plik konta usługi z domyślnymi danymi logowania aplikacji Google .

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ć dostęp 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 Generuj nowy klucz prywatny , a następnie potwierdź, klikając Generuj klucz .

  3. Bezpiecznie przechowuj plik JSON zawierający klucz.

W przypadku autoryzacji za pośrednictwem konta usługi masz dwie możliwości podania poświadczeń 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ę do 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 tę 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 logowania aplikacji (ADC) mogą niejawnie określić Twoje dane logowania, umożliwiając korzystanie z danych logowania do 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(),
});

Używanie tokenu odświeżania OAuth 2.0

Pakiet Admin SDK zapewnia również poświadczenia, 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 bez parametrów

Zestaw SDK można również zainicjować bez parametrów. W takim przypadku pakiet SDK korzysta z domyślnych danych logowania aplikacji Google . Ponieważ wyszukiwanie domyślnych danych logowania jest w środowiskach Google w pełni zautomatyzowane i nie wymaga dostarczania 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ć opcje inicjalizacji usług, takich jak Baza danych czasu rzeczywistego, Magazyn w chmurze lub Funkcje w chmurze, użyj zmiennej środowiskowej FIREBASE_CONFIG . Jeśli zawartość zmiennej FIREBASE_CONFIG zaczyna się od { , zostanie przeanalizowana 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()

Iść

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żywać pakietu Admin SDK do wykonywania następujących typów 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(...)

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 wybić niestandardowe tokeny dla innego projektu. Możesz też chcieć uwierzytelnić dwie aplikacje przy użyciu oddzielnych poświadczeń. Pakiet Firebase SDK umożliwia jednoczesne tworzenie wielu aplikacji, z których każda ma własne informacje konfiguracyjne.

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 poświadczeniami aplikacji Google dla bazy danych czasu rzeczywistego lub uwierzytelniania, pamiętaj o ustawieniu odpowiednich zakresów dostępu . W przypadku bazy danych czasu rzeczywistego i uwierzytelniania potrzebne są zakresy kończące się na userinfo.email i cloud-platform lub firebase.database . Aby sprawdzić istniejące zakresy dostępu i je zmienić, uruchom następujące polecenia za pomocą narzędzia 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 poświadczeniami użytkownika końcowego gcloud

Podczas lokalnego testowania pakietu Admin SDK przy użyciu domyślnych danych logowania aplikacji Google uzyskanych za pomocą gcloud auth application-default login wymagane są dodatkowe zmiany w celu korzystania z uwierzytelniania Firebase z następujących powodów:

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

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ć typem aplikacji aplikacji klasycznej.

gcloud

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

Identyfikator projektu można określić bezpośrednio podczas inicjowania aplikacji lub po prostu użyć zmiennej środowiskowej GOOGLE_CLOUD_PROJECT . Ta ostatnia pozwala uniknąć konieczności wprowadzania jakichkolwiek 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: