Cette page a été traduite par l'API Cloud Translation.
Switch to English

Introduction à l'API de base de données d'administration

Avec le SDK Admin, vous pouvez lire et écrire des données de base de données en temps réel avec des privilèges d'administrateur complets ou avec des privilèges limités plus précis. Dans ce document, nous vous guiderons tout au long de l'ajout du SDK Firebase Admin à votre projet pour accéder à la base de données Firebase Realtime.

Configuration du SDK d'administration

Pour démarrer avec la base de données Firebase Realtime sur votre serveur, vous devez d'abord configurer le SDK Firebase Admin dans la langue de votre choix.

Authentification du SDK d'administration

Avant de pouvoir accéder à la base de données Firebase Realtime à partir d'un serveur à l'aide du SDK Firebase Admin, vous devez authentifier votre serveur avec Firebase. Lorsque vous authentifiez un serveur, plutôt que de vous connecter avec les informations d'identification 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 d'authentification du SDK Admin Firebase
Privilèges administratifs Accès complet en lecture et en écriture à la base de données en temps réel d'un projet. Utilisez 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 à la base de données en temps réel d'un projet, limité aux seules ressources dont votre serveur a besoin. Utilisez ce niveau pour effectuer des tâches administratives qui ont des exigences d'accès bien définies. Par exemple, lorsque vous exécutez une tâche de synthèse qui lit des données dans toute 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 privilèges limités par cette règle.

Authentifiez-vous avec les privilèges d'administrateur

Lorsque vous initialisez le SDK Firebase Admin avec les informations d'identification d'un compte de service avec le rôle Editeur sur votre projet Firebase, cette instance dispose d'un accès complet en lecture et en écriture à la base de données en temps réel 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 = new FirebaseOptions.Builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    .setDatabaseUrl("https://<databaseName>.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),
  databaseURL: "https:// databaseName .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())
Aller
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)

Authentifiez-vous avec des privilèges limités

En tant que meilleure pratique, un service doit avoir accès uniquement aux ressources dont il a besoin. Pour obtenir un contrôle plus précis sur 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. Par 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 d' auth utilisé par vos règles de base de données. Dans cet objet d' 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))
    .setDatabaseUrl("https:// databaseName .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),
  databaseURL: "https:// databaseName .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())
Aller
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 souhaiterez peut-être réduire la portée des SDK d'administration pour agir en tant que client non authentifié. Vous pouvez le faire en fournissant une valeur null pour le remplacement 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))
    .setDatabaseUrl("https:// databaseName .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),
  databaseURL: "https:// databaseName .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())
Aller
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)

Prochaines étapes