Bien que les opérations de pipeline offrent un ensemble complet de fonctionnalités, le moteur de règles est limité à la reconnaissance des filtres de comparaison (par exemple, >) et logiques (par exemple, or) pour garantir la satisfaction des contraintes et la sécurité.
Expressions de filtre acceptées
Pour que les opérations de pipeline soient limitées aux limites définies par vos règles, elles doivent utiliser des opérateurs logiques et de comparaison par rapport aux constantes. Les types de filtres suivants sont reconnus par le moteur de règles :
- Comparaisons :
eq,neq,gt,gte,lt,lte,in,arrayContains. - Logique :
and,or.
Voici quelques exemples :
where(eq("foo", 2))where(lt("foo", 2))documents("/user/1", "/user/2").where(...)
Propriétés de la requête
Vous pouvez continuer à utiliser l'objet request pour valider l'authentification et le contexte de la requête, bien que certaines propriétés disponibles dans les requêtes standards ne soient pas compatibles avec les opérations de pipeline.
Propriétés acceptées
Le nouveau moteur continue d'accepter les propriétés suivantes :
request.auth: accédez à l'UID de l'utilisateur et aux données du jeton.request.method: identifie l'opération (par exemple,get,list).request.path: chemin d'accès de la ressource consultée.request.time: code temporel côté serveur de la requête.
Propriétés non compatibles
Les propriétés request.query telles que limit, offset et orderBy ne sont pas compatibles avec les vérifications des règles d'opérations de pipeline en raison de la complexité de la détermination de ces valeurs dans les requêtes multi-étapes.
Gestion et autorisations des étapes du pipeline
Il existe différentes étapes de pipeline qui correspondent à des opérations précises et précises dans les règles de sécurité :
- Autorisations
allow list: déclenchées par les étapescollection(),collectionGroup()etdatabase(). - Autorisations
allow get: déclenchées par l'étapedocuments(), qui est traitée de la même manière qu'une opérationgetpar lot. allow create: déclenchées par les étapesinsert()etupsert()lors de la création de documents.allow update: déclenchées par les étapesupdate()etupsert()lors de la mise à jour de documents existants.- Autorisations
allow delete: déclenchées par les étapesdelete(). allow write: s'applique à toutes les opérations LMD (insert(),update(),upsert()etdelete()).- Étape des littéraux : l'étape
literals()ne lit pas la base de données, mais peut entraîner des coûts. Pour éviter tout abus, elle doit être associée à une autre étape (commecollection()) pouvant être validée par des règles.
Étapes de modification des champs
Les règles ne s'appliquent qu'aux données stockées, et non aux valeurs dérivées. Si un pipeline inclut des étapes qui modifient des champs (par exemple, add_fields(...), replace_with(...), select(...), remove_fields(...)), le moteur de règles cesse d'appliquer les contraintes de filtre après cette étape. Pour vous assurer que les règles fonctionnent comme prévu, placez vos étapes de filtrage (par exemple, where) avant toute étape susceptible de modifier les documents stockés d'origine.
Prenons l'exemple de la règle de sécurité suivante :
match /databases/{database}/documents {
match /cities/{city} {
// Allow the user to read data if the document has the 'visibility'
// field set to 'public'
allow read: if resource.data.visibility == 'public';
}
}
Refusé : cette règle rejette le pipeline suivant, car l'étape addFields se produit avant le filtrage des documents où visibility est public :
const results = await db.pipeline()
.collection("/cities")
// Filters after a modification stage are ignored by Rules.
.addFields(constant(1000).as("population"))
.where(eq(field("visibility"), constant("public")))
.execute();
Autorisé : cette règle autorise le pipeline suivant, car l'étape where(eq(field("visibility"), constant("public"))) se produit avant toute étape de modification :
const results = await db.pipeline()
.collection("/cities")
.where(eq(field("visibility"), constant("public")))
.addFields(constant(1000).as("population"))
.execute();
Étapes du langage de manipulation de données et règles de sécurité
Lors de l'exécution d'étapes du langage de manipulation de données (LMD) (insert(), update(), upsert() et delete()), les règles de sécurité évaluent les autorisations différemment des requêtes de lecture :
- Évaluation des règles par document : contrairement aux pipelines de lecture, qui nécessitent des expressions de filtre en amont pour limiter la requête au moment de la planification, les opérations LMD évaluent les règles de sécurité par rapport à chaque mutation de document individuelle.
- Variables de règle :
request.resource: contient les données de document proposées pour les opérationsinsert(),update()etupsert().resource: contient les données du document actuel stockées dans la base de données avant modification (disponible pourupdate(),delete()etupsert()des documents existants).
Limites du système et comportement d'exécution avec le LMD
Lorsque vous exécutez des opérations LMD avec des règles de sécurité, tenez compte des limites du système et des comportements d'exécution suivants :
La limite de 20 recherches sur get() et exists()
Les règles de sécurité Firebase autorisent un maximum de 20 recherches de documents (get() ou exists()) sur l'ensemble d'une requête.
Lorsqu'un pipeline LMD s'exécute en dehors d'une transaction explicite, Cloud Firestore traite les écritures de documents par lots. Étant donné que chaque lot s'exécute dans sa propre transaction et que les documents peuvent être modifiés simultanément entre les lots, les règles de sécurité et les recherches de documents sont réévaluées pour chaque lot d'écriture.
Même si vos règles de sécurité évaluent un seul document statique (par exemple, pour vérifier si un utilisateur est un administrateur) :
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /posts/{postId} {
allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.isAdmin == true;
}
}
}
Chaque lot d'écriture de 10 documents effectue une recherche. Par conséquent, après l'écriture de tous les documents possibles, la limite de 20 recherches pour la requête est atteinte et le pipeline échoue avec une erreur PERMISSION_DENIED. De plus, chaque recherche effectuée par lot d'écriture entraîne sa propre facturation de lecture.
Réussite partielle et PERMISSION_DENIED
Lorsqu'elles sont exécutées en dehors d'une transaction, les opérations LMD valident les écritures par lots séquentiels. Si un lot échoue (soit parce qu'un document ne respecte pas une condition de règle, soit parce que la limite de 20 recherches est dépassée), le pipeline s'arrête et renvoie une erreur PERMISSION_DENIED.
Toutefois, les lots qui ont déjà été validés ne sont pas annulés. La base de données reste dans un état partiellement mis à jour. Étant donné que le client reçoit une erreur sans liste de documents modifiés, vous devez interroger vos données pour inspecter les écritures ayant réussi.
Diagnostiquer les échecs de règles avec Cloud Audit Logs
Pour des raisons de sécurité, les erreurs PERMISSION_DENIED visibles par le client n'indiquent pas quelle condition de règle de sécurité a échoué ni si la limite de 20 recherches a été atteinte.
Pour diagnostiquer les échecs d'évaluation des règles, les administrateurs de projet peuvent inspecter les journaux d'audit Cloud dans la console Google Cloud (sous Firestore > Surveillance ou dans l'explorateur de journaux) pour afficher les entrées EvaluationError détaillées.