Firebase-Sicherheitsregeln verwalten und bereitstellen

Firebase bietet mehrere Tools zur Verwaltung Ihrer Rules. Jedes Tool ist für bestimmte Fälle geeignet und verwendet dieselbe Backend-API zur Verwaltung von Firebase-Sicherheitsregeln.

Unabhängig davon, mit welchem Tool das Tool aufgerufen wird, gilt für die Verwaltungs-API Folgendes:

  • Hier wird eine Regelnquelle aufgenommen: eine Reihe von Regeln, in der Regel eine Codedatei mit Firebase Security Rules-Anweisungen.
  • Die aufgenommene Quelle wird als unveränderliches Regelset gespeichert.
  • Hier wird die Bereitstellung der einzelnen Regelsätze in einer Version erfasst. Dienste, die Firebase-Sicherheitsregeln unterstützen, suchen die Version für ein Projekt auf, um jede Anfrage für eine gesicherte Ressource zu prüfen.
  • Bietet die Möglichkeit, syntaktische und semantische Tests eines Regelsatzes auszuführen.

Firebase CLI verwenden

Mit der Firebase-Befehlszeile können Sie lokale Quellen hochladen und Releases bereitstellen. Mit der Firebase Local Emulator Suite-Befehlszeile können Sie vollständige lokale Tests von Quellen ausführen.

Mit der Befehlszeile können Sie die Versionsverwaltung für Ihre Regeln mit Ihrem Anwendungscode beibehalten und Regeln im Rahmen des vorhandenen Bereitstellungsprozesses bereitstellen.

Konfigurationsdatei generieren

Wenn Sie Ihr Firebase-Projekt mit der Firebase-Befehlszeile konfigurieren, erstellen Sie eine .rules-Konfigurationsdatei in Ihrem Projektverzeichnis. Konfigurieren Sie Ihr Firebase-Projekt mit dem folgenden Befehl:

Cloud Firestore 

// Set up Firestore in your project directory, creates a .rules file
firebase init firestore

Realtime Database 

// Set up Realtime Database in your project directory, creates a .rules file
firebase init database

Cloud Storage 

// Set up Storage in your project directory, creates a .rules file
firebase init storage

Regeln bearbeiten und aktualisieren

Bearbeiten Sie die Regelquelle direkt in der Konfigurationsdatei .rules.

Achten Sie darauf, dass alle Änderungen, die Sie in der Firebase-Befehlszeile vornehmen, in der Firebase-Konsole übernommen werden. Alternativ können Sie die Änderungen auch immer in der Firebase-Konsole oder in der Firebase CLI vornehmen. Andernfalls werden möglicherweise alle in der Firebase-Konsole vorgenommenen Änderungen überschrieben.

Aktualisierungen testen

Der Local Emulator Suite bietet Emulatoren für alle Produkte, die Sicherheitsregeln unterstützen. Die Sicherheitsregel-Engine für jeden Emulator führt sowohl eine syntaktische als auch eine semantische Regelbewertung durch und übertrifft damit die syntaktischen Tests, die die Security Rules Management API bietet.

Wenn Sie mit der Befehlszeile arbeiten, ist die Suite ein hervorragendes Tool zum Testen von Firebase Security Rules. Verwenden Sie Local Emulator Suite, um Ihre Updates lokal zu testen und zu prüfen, ob die Rules Ihrer App das gewünschte Verhalten zeigen.

Updates bereitstellen

Nachdem Sie Ihre Rules aktualisiert und getestet haben, stellen Sie die Quellen in der Produktion bereit.

Verknüpfen Sie für Cloud Firestore Security Rules .rules-Dateien mit Ihrer Standard- und zusätzlichen benannten Datenbank, indem Sie die firebase.json-Datei prüfen und aktualisieren.

Mit den folgenden Befehlen können Sie Rules einzeln oder im Rahmen Ihres normalen Bereitstellungsprozesses bereitstellen.

Cloud Firestore 

// Deploy rules for all databases configured in your firebase.json
firebase deploy --only firestore:rules

// Deploy rules for the specified database configured in your firebase.json
firebase deploy --only firestore:<databaseId>

Realtime Database 

// Deploy your .rules file
firebase deploy --only database

Cloud Storage 

// Deploy your .rules file
firebase deploy --only storage

Firebase-Konsole verwenden

Sie können auch Rules-Quellen bearbeiten und über die Firebase-Konsole als Releases bereitstellen. Der syntaktische Test wird während der Bearbeitung in der Firebase-Konsole durchgeführt. Der semantische Test ist über den Rules-Playground verfügbar.

Regeln bearbeiten und aktualisieren

  1. Öffnen Sie die Firebase Console und wählen Sie Ihr Projekt aus.
  2. Wählen Sie dann in der Produktnavigation Realtime Database, Cloud Firestore oder Storage aus und klicken Sie dann auf Regeln, um den Rules-Editor aufzurufen.
  3. Bearbeiten Sie Ihre Regeln direkt im Editor.

Updates testen

Sie können nicht nur die Syntax in der Editor-Benutzeroberfläche testen, sondern auch das semantische Rules-Verhalten mithilfe der Datenbank- und Speicherressourcen Ihres Projekts direkt in der Firebase-Konsole mit dem Rules Playground. Öffnen Sie im Rules-Editor den Bildschirm Regel-Playground, ändern Sie die Einstellungen und klicken Sie auf Ausführen. Oben im Editor wird eine Bestätigungsmeldung angezeigt.

Updates bereitstellen

Wenn Sie mit den Änderungen zufrieden sind, klicken Sie auf Veröffentlichen.

Admin SDK verwenden

Sie können die Admin SDK für Node.js-Regelsätze verwenden. Mit diesem programmatischen Zugriff können Sie:

  • Implementieren Sie benutzerdefinierte Tools, Scripts, Dashboards und CI/CD-Pipelines zum Verwalten von Regeln.
  • Regeln lassen sich jetzt einfacher in mehreren Firebase-Projekten verwalten.

Bei der programmatischen Aktualisierung von Regeln ist es sehr wichtig, unbeabsichtigte Änderungen an der Zugriffssteuerung für Ihre Anwendung zu vermeiden. Beim Schreiben von Admin SDK-Code steht die Sicherheit an erster Stelle, insbesondere wenn Sie Regeln aktualisieren oder bereitstellen.

Außerdem dauert es einige Minuten, bis Firebase Security Rules-Releases vollständig übernommen werden. Wenn Sie Regeln mit dem Admin SDK bereitstellen, sollten Sie Race-Bedingungen vermeiden, bei denen Ihre App sofort auf Regeln angewiesen ist, deren Bereitstellung noch nicht abgeschlossen ist. Wenn für Ihren Anwendungsfall häufige Aktualisierungen der Zugriffssteuerungsregeln erforderlich sind, sollten Sie Lösungen mit Cloud Firestore in Betracht ziehen. Dieser Dienst wurde entwickelt, um Race-Bedingungen trotz häufiger Aktualisierungen zu reduzieren.

Beachten Sie außerdem die folgenden Einschränkungen:

  • Regeln müssen bei der Serialisierung kleiner als 256 KiB UTF-8-codierten Texts sein.
  • Ein Projekt kann insgesamt höchstens 2.500 bereitgestellte Regelsätze haben. Wenn Sie dieses Limit erreichen, müssen Sie einige alte Regelsätze löschen, bevor Sie neue erstellen können.

Cloud Storage- oder Cloud Firestore-Regeln erstellen und bereitstellen

Ein typischer Workflow zum Verwalten von Sicherheitsregeln mit der Admin SDK kann drei separate Schritte umfassen:

  1. Regeldateiquelle erstellen (optional)
  2. Regelsatz erstellen
  3. Neue Regelsatz veröffentlichen oder bereitstellen

Das SDK bietet eine Methode, mit der diese Schritte für Cloud Storage- und Cloud Firestore-Sicherheitsregeln in einem einzigen API-Aufruf kombiniert werden können. Beispiel:

    const source = `service cloud.firestore {
      match /databases/{database}/documents {
        match /carts/{cartID} {
          allow create: if request.auth != null && request.auth.uid == request.resource.data.ownerUID;
          allow read, update, delete: if request.auth != null && request.auth.uid == resource.data.ownerUID;
        }
      }
    }`;
    // Alternatively, load rules from a file
    // const fs = require('fs');
    // const source = fs.readFileSync('path/to/firestore.rules', 'utf8');

    await admin.securityRules().releaseFirestoreRulesetFromSource(source);

Dieses Muster funktioniert auch für Cloud Storage-Regeln mit releaseFirestoreRulesetFromSource().

Alternativ können Sie die Regelndatei als In-Memory-Objekt erstellen, das Regelset erstellen und das Regelset separat bereitstellen, um diese Ereignisse genauer zu steuern. Beispiel:

    const rf = admin.securityRules().createRulesFileFromSource('firestore.rules', source);
    const rs = await admin.securityRules().createRuleset(rf);
    await admin.securityRules().releaseFirestoreRuleset(rs);

Realtime Database Regelsätze aktualisieren

Verwenden Sie die Methoden getRules() und setRules() von admin.database, um Realtime Database-Regeln mit dem Admin SDK zu aktualisieren. Sie können Regelsätze im JSON-Format oder als String mit Kommentaren abrufen.

So aktualisieren Sie einen Regelsatz:

    const source = `{
      "rules": {
        "scores": {
          ".indexOn": "score",
          "$uid": {
            ".read": "$uid == auth.uid",
            ".write": "$uid == auth.uid"
          }
        }
      }
    }`;
    await admin.database().setRules(source);

Regelsätze verwalten

Um große Regelsätze zu verwalten, können Sie mit Admin SDK alle vorhandenen Regeln mit admin.securityRules().listRulesetMetadata auflisten. Beispiel:

    const allRulesets = [];
    let pageToken = null;
    while (true) {
      const result = await admin.securityRules().listRulesetMetadata(pageToken: pageToken);
      allRulesets.push(...result.rulesets);
      pageToken = result.nextPageToken;
      if (!pageToken) {
        break;
      }
    }

Bei sehr großen Implementierungen, die im Laufe der Zeit das Limit von 2.500 Regeln erreichen, können Sie eine Logik erstellen, um die ältesten Regeln in einem festen Zeitzyklus zu löschen. So löschen Sie beispielsweise alle Regelsätze, die länger als 30 Tage bereitgestellt wurden:

    const thirtyDays = new Date(Date.now() - THIRTY_DAYS_IN_MILLIS);
    const promises = [];
    allRulesets.forEach((rs) => {
      if (new Date(rs.createTime) < thirtyDays) {
        promises.push(admin.securityRules().deleteRuleset(rs.name));
      }
    });
    await Promise.all(promises);
    console.log(`Deleted ${promises.length} rulesets.`);

Verwenden der REST API

Die oben beschriebenen Tools eignen sich gut für verschiedene Workflows, einschließlich der Firebase Security Rules-Verwaltung für mehrere Cloud Firestore-Datenbanken in Ihrem Projekt. Sie können Firebase Security Rules aber auch mit der Management API selbst verwalten und bereitstellen. Die Verwaltungs-API bietet die größte Flexibilität.

Beachten Sie außerdem die folgenden Einschränkungen:

  • Regeln müssen bei der Serialisierung kleiner als 256 KiB UTF-8-codierten Texts sein.
  • Ein Projekt kann insgesamt höchstens 2.500 bereitgestellte Regelsätze haben. Wenn Sie dieses Limit erreichen, müssen Sie einige alte Regelsätze löschen, bevor Sie neue erstellen können.

Cloud Firestore- oder Cloud Storage-Regelsätze mit REST erstellen und bereitstellen

In den Beispielen in diesem Abschnitt wird Firestore Rules verwendet, obwohl sie auch für Cloud Storage Rules gelten.

In den Beispielen wird auch cURL für API-Aufrufe verwendet. Die Schritte zum Einrichten und Übergeben von Authentifizierungstokens werden weggelassen. Sie können diese API mit dem API Explorer testen, der in der Referenzdokumentation eingebunden ist.

Typische Schritte zum Erstellen und Bereitstellen einer Regelliste mit der Verwaltungs-API:

  1. Quellen für Regeldateien erstellen
  2. Regelsatz erstellen
  3. Geben Sie den neuen Regelsatz frei (Bereitstellung).

Quelle erstellen

Angenommen, Sie arbeiten an Ihrem secure_commerce-Firebase-Projekt und möchten gesperrte Cloud Firestore-Rules in einer Datenbank in Ihrem Projekt namens east_store bereitstellen.

Sie können diese Regeln in einer firestore.rules-Datei implementieren.

service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

Regelsatz erstellen

Erstellen Sie jetzt einen base64-codierten Fingerabdruck für diese Datei. Sie können dann die Quelle in dieser Datei verwenden, um die Nutzlast zu füllen, die zum Erstellen eines Regelsatzes mit dem REST-Aufruf projects.rulesets.create erforderlich ist. Hier wird der Befehl cat verwendet, um den Inhalt von firestore.rules in die REST-Nutzlast einzufügen.

Wenn du es für das Tracking mit deiner east_store-Datenbank verknüpfen möchtest, setze attachment_point auf east_store.

curl -X POST -d '{
  "source": {
    "files": [
      {
        "content": "' $(cat storage.rules) '",
        "name": "firestore.rules",
        "fingerprint": <sha fingerprint>
      },
    "attachment_point": "firestore.googleapis.com/databases/east_store"
    ]
  }
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/rulesets'

Die API gibt eine Validierungsantwort und einen Regelsatznamen zurück, z. B. projects/secure_commerce/rulesets/uuid123.

Regelsatz veröffentlichen (bereitstellen)

Wenn die Regelsammlung gültig ist, ist der letzte Schritt die Bereitstellung der neuen Regelsammlung in einer benannten Version.

curl -X POST -d '{
  "name": "projects/secure_commerce/releases/cloud.firestore/east_store"  ,
  "rulesetName": "projects/secure_commerce/rulesets/uuid123"
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/releases'

Beachten Sie, dass es mehrere Minuten dauern kann, bis Firebase Security Rules-Releases vollständig weitergegeben werden. Wenn Sie die Verwaltungs-REST API für die Bereitstellung verwenden, achten Sie darauf, Race-Bedingungen zu vermeiden, in denen Ihre Anwendung sofort auf Regeln zurückgreift, deren Bereitstellung noch nicht abgeschlossen ist.

Realtime Database-Regeln mit REST aktualisieren

Realtime Database bietet eine eigene REST-Schnittstelle zur Verwaltung von Rules. Weitere Informationen finden Sie unter Firebase Realtime Database Rules über REST verwalten.

Regelsätze mit REST verwalten

Zur Verwaltung großer Regelimplementierungen bietet die Verwaltungs-API neben einer REST-Methode zum Erstellen von Regelsätzen und Releases auch Methoden für Folgendes:

  • Regelsätze auflisten, abrufen und löschen
  • Releases von Regeln auflisten, abrufen und löschen

Bei sehr großen Implementierungen, die im Laufe der Zeit das Limit von 2.500 Regeln erreichen, können Sie eine Logik erstellen, um die ältesten Regeln in einem festen Zeitzyklus zu löschen. Wenn Sie beispielsweise alle Regelsätze löschen möchten, die vor mehr als 30 Tagen bereitgestellt wurden, können Sie die Methode projects.rulesets.list aufrufen, die JSON-Liste der Ruleset-Objekte anhand ihrer createTime-Schlüssel parsen und dann project.rulesets.delete für die entsprechenden Regelsätze mit ruleset_id aufrufen.

Aktualisierungen mit REST testen

Mit der Verwaltungs-API können Sie außerdem syntaktische und semantische Tests für Cloud Firestore- und Cloud Storage-Ressourcen in Ihren Produktionsprojekten ausführen.

Der Test mit dieser Komponente der API umfasst Folgendes:

  1. TestSuite-JSON-Objekt zum Darstellen einer Reihe von TestCase-Objekten definieren
  2. Einreichen der TestSuite
  3. Zurückgegebene TestResult-Objekte parsen

Definieren wir ein TestSuite-Objekt mit einem einzelnen TestCase in einer testcase.json-Datei. In diesem Beispiel übergeben wir die Rules-Sprachquelle inline mit der REST-Nutzlast zusammen mit der Testsuite, die für diese Regeln ausgeführt werden soll. Wir legen die Erwartungen der Regelauswertung und die Clientanfrage fest, anhand derer der Regelsatz getestet werden soll. Sie können auch angeben, wie vollständig der Testbericht sein soll. Mit dem Wert „FULL“ geben Sie an, dass Ergebnisse für alle Rules-Sprachausdrücke im Bericht enthalten sein sollen, einschließlich Ausdrücke, die nicht mit der Anfrage übereinstimmten.

 {
  "source":
  {
    "files":
    [
      {
        "name": "firestore.rules",
        "content": "service cloud.firestore {
          match /databases/{database}/documents {
            match /users/{userId}{
              allow read: if (request.auth.uid == userId);
            }
            function doc(subpath) {
              return get(/databases/$(database)/documents/$(subpath)).data;
            }
            function isAccountOwner(accountId) {
              return request.auth.uid == accountId 
                  || doc(/users/$(request.auth.uid)).accountId == accountId;
            }
            match /licenses/{accountId} {
              allow read: if isAccountOwner(accountId);
            }
          }
        }"
      }
    ]
  },
  "testSuite":
  {
    "testCases":
    [
      {
        "expectation": "ALLOW",
        "request": {
           "auth": {"uid": "123"},
           "path": "/databases/(default)/documents/licenses/abcd",
           "method": "get"},
        "functionMocks": [
            {
            "function": "get",
            "args": [{"exact_value": "/databases/(default)/documents/users/123"}],
            "result": {"value": {"data": {"accountId": "abcd"}}}
            }
          ]
      }
    ]
  }
}

Wir können diese TestSuite dann mit der projects.test-Methode zur Bewertung einreichen.

curl -X POST -d '{
    ' $(cat testcase.json) '
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/rulesets/uuid123:test'

Die zurückgegebene TestReport (mit Teststatus SUCCESS/FAILURE, Listen mit Fehlerbehebungsmeldungen, Listen besuchter Regelausdrücke und deren Bewertungsberichte) würde mit dem Status SUCCESS bestätigen, dass der Zugriff ordnungsgemäß gewährt wurde.

Berechtigungen für dienstübergreifende Cloud Storage Security Rules verwalten

Wenn Sie Cloud Storage Security Rules erstellen, die den Inhalt von Cloud Firestore-Dokumenten zum Bewerten der Sicherheitsbedingungen verwendet, werden Sie in der Firebase-Konsole oder der Firebase-Befehlszeile aufgefordert, Berechtigungen zum Verbinden der beiden Produkte zu aktivieren.

Wenn Sie diese dienstübergreifende Sicherheit deaktivieren möchten, gehen Sie so vor:

  1. Bevor Sie die Funktion deaktivieren, bearbeiten Sie Ihre Regeln und entfernen Sie alle Anweisungen, in denen Rules-Funktionen zum Zugriff auf Cloud Firestore verwendet werden. Andernfalls führen Rules-Bewertungen nach der Deaktivierung der Funktion dazu, dass Ihre Speicheranfragen fehlschlagen.

  2. Löschen Sie die Rolle „Firebase Rules Firestore Service Agent“ auf der Seite IAM in der Google Cloud Console. Folgen Sie dazu der Anleitung zum Widerrufen von Rollen in der Cloud.

Sie werden aufgefordert, die Funktion wieder zu aktivieren, wenn Sie das nächste Mal dienstübergreifende Regeln über die Firebase-Befehlszeile oder die Firebase-Konsole speichern.