Adicionar o SDK do Firebase Admin ao servidor

O SDK Admin permite que você interaja com o Firebase em ambientes privilegiados para executar ações como:

  • ler e gravar dados do Realtime Database com privilégios de administrador totais;
  • enviar de maneira programática mensagens do Firebase Cloud Messaging usando uma abordagem simples e alternativa dos protocolos do servidor do FCM;
  • gerar e verificar os tokens de autenticação do Firebase;
  • acessar os recursos do Google Cloud Platform, como os intervalos do Cloud Storage e os bancos de dados do Firestore associados aos seus projetos do Firebase.
  • criar seu próprio console de administração simplificado para realizar ações como procurar dados do usuário ou alterar o endereço de e-mail de um usuário para fazer a autenticação.

Se você tiver interesse em usar o SDK do Node.js como cliente para permitir o acesso do usuário final (por exemplo, em um computador com Node.js ou um aplicativo de Internet das Coisas), em vez do acesso de administrador em um ambiente privilegiado (como um servidor), siga as instruções para configurar o SDK para JavaScript cliente.

Veja a seguir uma matriz de recursos que mostra quais recursos do Firebase são compatíveis com cada linguagem:

Recurso Node.js Java Python Go C#
Verificação de tokens personalizada
Verificação de tokens de código
Gerenciamento de usuários
Acesso de controle com declarações personalizadas
Revogação do token de atualização
Importação de usuários
Gerenciamento de cookies de sessão
Como gerar links de ação de e-mail
Realtime Database *
Cloud Messaging
Gerenciar inscrições de tópicos do FCM
Cloud Storage
Cloud Firestore
Gerenciamento de projetos

Para saber mais sobre como integrar o SDK Admin a esses tipos de uso, consulte a documentação correspondente do Realtime Database, FCM, Authentication e Cloud Storage. O resto desta página se concentra na configuração básica do SDK Admin.

Pré-requisitos

Antes de começar, verifique se você tem o seguinte:

  • Um servidor executando Node.js 6.0 ou posterior, se estiver usando o SDK para Node.js
  • Um servidor executando Java 7 ou posterior, se estiver usando o SDK para Java
  • Um servidor executando Python 2.7 ou posterior ou 3.x, se estiver usando o SDK Admin para Python
  • Um servidor executando Go 1.9 ou posterior, se estiver usando o SDK Admin para Go
  • Um servidor executando .NET Framework 4.5 ou posterior, ou .Net Core 1.5 ou posterior, se estiver usando o SDK Admin para .NET
  • Um app de servidor

Adicionar o Firebase ao seu app

Para usar os SDKs Admin do Firebase, você precisará ter um projeto do Firebase, uma conta de serviço para se comunicar com o Firebase e um arquivo de configuração com as credenciais da conta de serviço.

  1. Se você ainda não tem um projeto do Firebase, adicione um no Console do Firebase. A caixa de diálogo Adicionar projeto também oferece a opção de adicionar o Firebase a um projeto existente do Google Cloud Platform.
  2. Na página de configurações do projeto, acesse a guia Contas de serviço.
  3. Clique no botão Gerar nova chave privada na parte inferior da seção SDK Admin do Firebase da guia Contas de serviço.

Em seguida, será feito o download de um arquivo JSON que contém as credenciais da sua conta de serviço. Ele será necessário para inicializar o SDK na próxima etapa.

Este arquivo só é gerado uma vez. Se você perder a chave ou ela for exposta, repita as instruções acima para criar uma nova chave JSON para a conta de serviço.

Adicionar o SDK

Se você estiver configurando um novo projeto, será necessário instalar o SDK para o idioma de sua escolha.

Node.js

O SDK Admin para Node.js do Firebase está disponível em NPM. Caso você ainda não tenha um arquivo package.json, crie um por meio do npm init. Em seguida, instale o pacote NPM firebase-admin e salve-o no seu package.json:

$ npm install firebase-admin --save

Para usar o módulo no seu aplicativo, use a função require para solicitá-lo de qualquer arquivo JavaScript:

var admin = require('firebase-admin');

Se você estiver usando ES2015, use a função import para importar o módulo:

import * as admin from 'firebase-admin';

Java

O SDK Admin para JavaScript do Firebase foi publicado no repositório Maven central. Para instalar a biblioteca, declare-a como uma dependência no seu arquivo build.gradle:

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

Se você usa o Maven para criar seu aplicativo, adicione esta dependência ao pom.xml:

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

Python

O SDK Admin para Python do Firebase está disponível via PIP. Você pode instalar a biblioteca para todos os usuários via sudo:

$ sudo pip install firebase-admin

Ou, para instalar a biblioteca apenas para o usuário atual, passe o sinalizador --user:

$ pip install --user firebase-admin

Go

O SDK Admin para Go pode ser instalado por meio do utilitário go get:

$ go get firebase.google.com/go

C#

O SDK Admin para .NET pode ser instalado por meio do gerenciador de pacotes .NET:

$ Install-Package FirebaseAdmin -Version 1.0.0

Se preferir, instale-o com o utilitário de linha de comando dotnet:

$ dotnet add package FirebaseAdmin --version 1.0.0

Ou você pode instalá-lo adicionando a seguinte entrada de referência do pacote ao seu arquivo .csproj:

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

Inicializar o SDK

Depois de criar um projeto no Console do Firebase e fazer o download de um arquivo JSON com suas credenciais da conta de serviço, inicialize o SDK com este snippet de código:

Node.js

var admin = require('firebase-admin');

var serviceAccount = require('path/to/serviceAccountKey.json');

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

Java

FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountKey.json");

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
    .build();

FirebaseApp.initializeApp(options);

Python

import firebase_admin
from firebase_admin import credentials

cred = credentials.Certificate('path/to/serviceAccountKey.json')
default_app = firebase_admin.initialize_app(cred)

Para usar o SDK Admin para Python em ambiente padrão do Google App Engine, serão necessárias algumas configurações especiais.

Go

import (
	"context"
	"log"

	firebase "firebase.google.com/go"
	"firebase.google.com/go/auth"
	"google.golang.org/api/option"
)

opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")
app, err := firebase.NewApp(context.Background(), nil, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}

C#

using FirebaseAdmin;
using FirebaseAdmin.Auth;
using Google.Apis.Auth.OAuth2;


FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.FromFile("path/to/serviceAccountKey.json"),
});

Encontre o nome do banco de dados na página Banco de dados do projeto no Console do Firebase.

Se o arquivo da conta de serviço não puder ser referenciado, o SDK Admin para Node.js pode aceitar os campos individuais da conta do serviço in-line:

Node.js

admin.initializeApp({
  credential: admin.credential.cert({
    projectId: '<PROJECT_ID>',
    clientEmail: 'foo@<PROJECT_ID>.iam.gserviceaccount.com',
    privateKey: '-----BEGIN PRIVATE KEY-----\n<KEY>\n-----END PRIVATE KEY-----\n'
  }),
  databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Como alternativa, os SDKs Admin podem ser autenticados com um tipo de credencial diferente. Por exemplo, para executar seu código no Google Cloud Platform, use as Application Default Credentials do Google para que os próprios SDKs Admin busquem uma conta de serviço para você:

Node.js

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

Java

FirebaseOptions options = new 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)
}

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});

Para usar uma VM do Google Compute Engine com as Application Default Credentials do Google para Realtime Database ou Authentication, verifique se você configurou os escopos de acesso corretos. Para o Realtime Database e o Authentication, é preciso que os escopos terminem em userinfo.email e cloud-platform ou firebase.database. Para verificar os escopos de acesso existentes e alterá-los, execute os comandos abaixo usando o 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"

Os SDKs Admin também fornecem uma credencial que permite a autenticação com um token de atualização do Google OAuth2:

Node.js

var refreshToken; // Get refresh token from OAuth2 flow

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

Java

FileInputStream refreshToken = new FileInputStream("path/to/refreshToken.json");

FirebaseOptions options = new 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)
}

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.FromFile("path/to/refreshToken.json"),
});

É possível também inicializar o SDK sem parâmetros. Nesse caso, o SDK usa o Application Default Credentials do Google e faz a leitura das opções na variável de ambiente FIREBASE_CONFIG. Caso o conteúdo da variável FIREBASE_CONFIG comece com uma {, ele será analisado como um objeto JSON. Caso contrário, a string será tratada pelo SDK como o nome de um arquivo JSON que contém as opções.

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.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)
}

C#

FirebaseApp.Create();

Agora você está pronto para usar os SDKs do Firebase Admin nas seguintes tarefas:

Inicializar vários aplicativos

Na maioria dos casos, é necessário inicializar um único aplicativo padrão. Você pode acessar serviços fora desse aplicativo de duas maneiras equivalentes:

Node.js

// Initialize the default app
var defaultApp = admin.initializeApp(defaultAppConfig);

console.log(defaultApp.name);  // '[DEFAULT]'

// Retrieve services via the defaultApp variable...
var defaultAuth = defaultApp.auth();
var defaultDatabase = defaultApp.database();

// ... or use the equivalent shorthand notation
defaultAuth = admin.auth();
defaultDatabase = admin.database();

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

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;

Alguns casos de uso exigem que você crie vários aplicativos ao mesmo tempo. Por exemplo, talvez você queira ler dados do Realtime Database em tempo real de um projeto do Firebase e criar tokens personalizados para outro projeto. Ou talvez autenticar dois aplicativos com credenciais individuais. Com o SDK do Firebase, você cria vários aplicativos ao mesmo tempo, cada um com as próprias informações de configuração.

Node.js

// Initialize the default app
admin.initializeApp(defaultAppConfig);

// Initialize another app with a different config
var otherApp = admin.initializeApp(otherAppConfig, 'other');

console.log(admin.app().name);  // '[DEFAULT]'
console.log(otherApp.name);     // 'other'

// Use the shorthand notation to retrieve the default app's services
var defaultAuth = admin.auth();
var defaultDatabase = admin.database();

// Use the otherApp variable to retrieve the other app's services
var otherAuth = otherApp.auth();
var otherDatabase = otherApp.database();

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

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

Próximas etapas

Saiba mais sobre o Firebase:

Adicione recursos do Firebase ao seu app:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.