Présentation de l'API Admin Database

Avec le SDK Admin, vous pouvez lire et écrire des données Realtime Database avec des droits d'administrateur complets ou avec des droits limités plus précis. Dans ce document, nous allons vous expliquer comment ajouter le SDK Firebase Admin à votre projet pour accéder à Firebase Realtime Database.

Vous pouvez créer des instances Realtime Database dans différentes régions géographiques, avec des schémas d'URL firebaseio.com et firebasedatabase.app distincts. Les méthodes Admin SDK permettant de définir des URL peuvent utiliser l'un ou l'autre de ces schémas. Pour connaître les régions et les schémas d'URL actuellement pris en charge, consultez l'article des guides sur la sélection d'emplacements dans les projets Firebase.

Configuration du SDK Admin

Pour commencer à utiliser Firebase Realtime Database sur votre serveur, vous devez d'abord configurer le SDK Admin Firebase dans la langue de votre choix.

Si vous souhaitez utiliser le SDK Node.js en tant que client pour l'accès des utilisateurs finaux (par exemple, dans une application IoT ou de bureau Node.js), plutôt que pour l'accès administrateur à partir d'un environnement privilégié (comme un serveur), vous devez suivre les instructions de configuration du SDK JavaScript client.

Authentification du SDK Admin

Avant de pouvoir accéder à Firebase Realtime Database à partir d'un serveur à l'aide du SDK Admin Firebase, vous devez authentifier votre serveur avec Firebase. Lorsque vous authentifiez un serveur, au lieu de vous connecter avec les identifiants d'un compte utilisateur comme vous le feriez dans une application cliente, vous vous authentifiez avec un compte de service qui identifie votre serveur auprès de Firebase.

Vous pouvez obtenir deux niveaux d'accès différents lorsque vous vous authentifiez à l'aide du SDK Firebase Admin:

Niveaux d'accès Auth du SDK Admin Firebase
Droits d'administrateur	Accès complet en lecture et en écriture au Realtime Database d'un projet. À utiliser avec précaution pour effectuer des tâches administratives telles que la migration ou la restructuration de données qui nécessitent un accès illimité aux ressources de votre projet.
Privilèges limités	Accès à l'Realtime Database d'un projet, limité aux seules ressources dont votre serveur a besoin. Utilisez ce niveau pour effectuer des tâches administratives dont les exigences d'accès sont bien définies. Par exemple, lorsque vous exécutez une tâche de résumé qui lit les données de l'ensemble de la base de données, vous pouvez vous protéger contre les écritures accidentelles en définissant une règle de sécurité en lecture seule, puis en initialisant le SDK Admin avec des droits limités par cette règle.

S'authentifier avec des droits d'administrateur

Lorsque vous initialisez le SDK Admin Firebase avec les identifiants d'un compte de service disposant du rôle Éditeur dans votre projet Firebase, cette instance dispose d'un accès en lecture/écriture complet à l'Realtime Database de votre projet.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json");

// Initialize the app with a service account, granting admin privileges
FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .build();
FirebaseApp.initializeApp(options);

// As an admin, the app has access to read and write all data, regardless of Security Rules
DatabaseReference ref = FirebaseDatabase.getInstance()
    .getReference("restricted_access/secret_document");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    Object document = dataSnapshot.getValue();
    System.out.println(document);
  }

  @Override
  public void onCancelled(DatabaseError error) {
  }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a service account, granting admin privileges
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com"
});

// As an admin, the app has access to read and write all data, regardless of Security Rules
var db = admin.database();
var ref = db.ref("restricted_access/secret_document");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com'
})

# As an admin, the app has access to read and write all data, regradless of Security Rules
ref = db.reference('restricted_access/secret_document')
print(ref.get())

Accéder

ctx := context.Background()
conf := &firebase.Config{
	DatabaseURL: "https://databaseName.firebaseio.com",
}
// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

// Initialize the app with a service account, granting admin privileges
app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// As an admin, the app has access to read and write all data, regradless of Security Rules
ref := client.NewRef("restricted_access/secret_document")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

Votre service n'a accès qu'aux ressources du compte de service utilisé pour l'authentifier. Par exemple, vous pouvez limiter votre service en lecture seule à l'aide d'un compte de service avec le rôle Lecteur sur votre projet. De même, un compte de service sans rôle dans le projet ne peut pas lire ni écrire de données.

S'authentifier avec des privilèges limités

Il est recommandé qu'un service n'ait accès qu'aux ressources dont il a besoin. Pour contrôler plus précisément les ressources auxquelles une instance d'application Firebase peut accéder, utilisez un identifiant unique dans vos règles de sécurité pour représenter votre service. Configurez ensuite les règles appropriées qui accordent à votre service l'accès aux ressources dont il a besoin. Exemple :

{
  "rules": {
    "public_resource": {
      ".read": true,
      ".write": true
    },
    "some_resource": {
      ".read": "auth.uid === 'my-service-worker'",
      ".write": false
    },
    "another_resource": {
      ".read": "auth.uid === 'my-service-worker'",
      ".write": "auth.uid === 'my-service-worker'"
    }
  }
}

Ensuite, sur votre serveur, lorsque vous initialisez l'application Firebase, utilisez l'option databaseAuthVariableOverride pour remplacer l'objet auth utilisé par vos règles de base de données. Dans cet objet auth personnalisé, définissez le champ uid sur l'identifiant que vous avez utilisé pour représenter votre service dans vos règles de sécurité.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json");

// Initialize the app with a custom auth variable, limiting the server's access
Map<String, Object> auth = new HashMap<String, Object>();
auth.put("uid", "my-service-worker");

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .setDatabaseAuthVariableOverride(auth)
    .build();
FirebaseApp.initializeApp(options);

// The app only has access as defined in the Security Rules
DatabaseReference ref = FirebaseDatabase
    .getInstance()
    .getReference("/some_resource");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        String res = dataSnapshot.getValue();
        System.out.println(res);
    }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a custom auth variable, limiting the server's access
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com",
  databaseAuthVariableOverride: {
    uid: "my-service-worker"
  }
});

// The app only has access as defined in the Security Rules
var db = admin.database();
var ref = db.ref("/some_resource");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a custom auth variable, limiting the server's access
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com',
    'databaseAuthVariableOverride': {
        'uid': 'my-service-worker'
    }
})

# The app only has access as defined in the Security Rules
ref = db.reference('/some_resource')
print(ref.get())

Accéder

ctx := context.Background()
// Initialize the app with a custom auth variable, limiting the server's access
ao := map[string]interface{}{"uid": "my-service-worker"}
conf := &firebase.Config{
	DatabaseURL:  "https://databaseName.firebaseio.com",
	AuthOverride: &ao,
}

// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// The app only has access as defined in the Security Rules
ref := client.NewRef("/some_resource")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

Dans certains cas, vous pouvez réduire la portée des SDK d'administration pour qu'ils agissent en tant que client non authentifié. Pour ce faire, indiquez la valeur null pour le forçage de la variable d'authentification de la base de données.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json");

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .setDatabaseAuthVariableOverride(null)
    .build();
FirebaseApp.initializeApp(options);

// The app only has access to public data as defined in the Security Rules
DatabaseReference ref = FirebaseDatabase
    .getInstance()
    .getReference("/public_resource");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        String res = dataSnapshot.getValue();
        System.out.println(res);
    }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a null auth variable, limiting the server's access
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com",
  databaseAuthVariableOverride: null
});

// The app only has access to public data as defined in the Security Rules
var db = admin.database();
var ref = db.ref("/public_resource");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a None auth variable, limiting the server's access
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com',
    'databaseAuthVariableOverride': None
})

# The app only has access to public data as defined in the Security Rules
ref = db.reference('/public_resource')
print(ref.get())

Accéder

ctx := context.Background()
// Initialize the app with a nil auth variable, limiting the server's access
var nilMap map[string]interface{}
conf := &firebase.Config{
	DatabaseURL:  "https://databaseName.firebaseio.com",
	AuthOverride: &nilMap,
}

// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// The app only has access to public data as defined in the Security Rules
ref := client.NewRef("/some_resource")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

Étapes suivantes

• Découvrez comment structurer les données pour Realtime Database.
• Évoluez vos données sur plusieurs instances de base de données.
• Enregistrer des données
• Récupérer les données
• Affichez votre base de données dans la console Firebase.