获取我们在 Firebase 峰会上发布的所有信息,了解 Firebase 可如何帮助您加快应用开发速度并满怀信心地运行应用。了解详情

Administre e implemente las reglas de seguridad de Firebase

Firebase le proporciona varias herramientas para administrar sus Reglas, cada una útil en casos particulares, y cada una utiliza la misma API de administración de Reglas de seguridad de Firebase de back-end.

No importa qué herramienta se use para invocarla, la API de administración:

  • Ingiere una fuente de reglas: un conjunto de reglas, generalmente un archivo de código que contiene declaraciones de reglas de seguridad de Firebase.
  • Almacena la fuente ingerida como un conjunto de reglas inmutable.
  • Realiza un seguimiento de la implementación de cada conjunto de reglas en una versión . Los servicios habilitados para las reglas de seguridad de Firebase buscan el lanzamiento de un proyecto para evaluar cada solicitud de un recurso seguro.
  • Proporciona la capacidad de ejecutar pruebas sintácticas y semánticas de un conjunto de reglas.

Usar la CLI de Firebase

Con Firebase CLI , puede cargar fuentes locales e implementar versiones . Firebase Local Emulator Suite de la CLI le permite realizar pruebas locales completas de las fuentes .

El uso de la CLI le permite mantener sus reglas bajo control de versiones con su código de aplicación e implementar reglas como parte de su proceso de implementación existente.

Generar un archivo de configuración

Cuando configura su proyecto de Firebase mediante Firebase CLI, crea un archivo de configuración .rules en el directorio de su proyecto. Use el siguiente comando para comenzar a configurar su proyecto de Firebase:

Tienda de fuego en la nube

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

Base de datos en tiempo real

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

Almacenamiento en la nube

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

Edite y actualice sus reglas

Edite su fuente de reglas directamente en el archivo de configuración .rules . Asegúrese de que cualquier edición que realice en la CLI de Firebase se refleje en la consola de Firebase, o que realice actualizaciones de manera constante mediante la consola de Firebase o la CLI de Firebase. De lo contrario, podría sobrescribir las actualizaciones realizadas en Firebase console.

Prueba tus actualizaciones

Local Emulator Suite proporciona emuladores para todos los productos habilitados para reglas de seguridad. El motor de reglas de seguridad para cada emulador realiza una evaluación tanto sintáctica como semántica de las reglas, superando así las pruebas sintácticas que ofrece la API de administración de reglas de seguridad.

Si está trabajando con la CLI, Suite es una excelente herramienta para probar las reglas de seguridad de Firebase. Use Local Emulator Suite para probar sus actualizaciones localmente y confirmar que las Reglas de su aplicación muestran el comportamiento que desea.

Implementa tus actualizaciones

Una vez que haya actualizado y probado sus Reglas, implemente las fuentes en producción. Utilice los siguientes comandos para implementar selectivamente sus Reglas solas o implementarlas como parte de su proceso de implementación normal.

Tienda de fuego en la nube

// Deploy your .rules file
firebase deploy --only firestore:rules

Base de datos en tiempo real

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

Almacenamiento en la nube

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

Usar la consola de Firebase

También puede editar fuentes de reglas e implementarlas como versiones desde la consola de Firebase. Las pruebas sintácticas se realizan a medida que editas en la IU de la consola de Firebase, y las pruebas sintácticas están disponibles mediante el Juego de reglas.

Edite y actualice sus reglas

  1. Abra la consola de Firebase y seleccione su proyecto.
  2. Luego, seleccione Base de datos en tiempo real , Cloud Firestore o Almacenamiento desde la navegación del producto, luego haga clic en Reglas para navegar al editor de Reglas.
  3. Edite sus reglas directamente en el editor.

Prueba tus actualizaciones

Además de probar la sintaxis en la interfaz de usuario del editor, puede probar el comportamiento de las reglas semánticas, usando la base de datos y los recursos de almacenamiento de su proyecto, directamente en la consola de Firebase, usando el Playground de reglas . Abra la pantalla Juego de reglas en el editor de reglas, modifique la configuración y haga clic en Ejecutar . Busque el mensaje de confirmación en la parte superior del editor.

Implementa tus actualizaciones

Una vez que esté satisfecho de que sus actualizaciones son lo que espera, haga clic en Publicar .

Usar el SDK de administrador

Puede usar el SDK de administración para los conjuntos de reglas de Node.js. Con este acceso programático, puede:

  • Implemente herramientas personalizadas, scripts, tableros y canalizaciones de CI/CD para administrar reglas.
  • Administre las reglas más fácilmente en varios proyectos de Firebase.

Al actualizar las reglas mediante programación, es muy importante evitar realizar cambios no deseados en el control de acceso de su aplicación. Escriba su código de Admin SDK teniendo en cuenta la seguridad, especialmente al actualizar o implementar reglas.

Otra cosa importante a tener en cuenta es que las versiones de las reglas de seguridad de Firebase tardan varios minutos en propagarse por completo. Cuando utilice Admin SDK para implementar reglas, asegúrese de evitar condiciones de carrera en las que su aplicación dependa inmediatamente de reglas cuya implementación aún no se haya completado. Si su caso de uso requiere actualizaciones frecuentes de las reglas de control de acceso, considere soluciones que usen Cloud Firestore, que está diseñado para reducir las condiciones de carrera a pesar de las actualizaciones frecuentes.

También tenga en cuenta estos límites:

  • Las reglas deben tener menos de 256 KiB de texto codificado en UTF-8 cuando se serializan.
  • Un proyecto puede tener como máximo 2500 conjuntos de reglas implementados en total. Una vez que se alcanza este límite, debe eliminar algunos conjuntos de reglas antiguos antes de crear otros nuevos.

Crear e implementar conjuntos de reglas de Cloud Storage o Cloud Firestore

Un flujo de trabajo típico para administrar las reglas de seguridad con Admin SDK podría incluir tres pasos discretos:

  1. Crear una fuente de archivo de reglas (opcional)
  2. Crear un conjunto de reglas
  3. Publicar o implementar el nuevo conjunto de reglas

El SDK proporciona un método para combinar estos pasos en una sola llamada a la API para las reglas de seguridad de Cloud Storage y Cloud Firestore. Por ejemplo:

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

Este mismo patrón funciona para las reglas de Cloud Storage con releaseFirestoreRulesetFromSource() .

Como alternativa, puede crear el archivo de reglas como un objeto en memoria, crear el conjunto de reglas e implementar el conjunto de reglas por separado para un control más estricto de estos eventos. Por ejemplo:

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

Actualizar conjuntos de reglas de Realtime Database

Para actualizar los conjuntos de reglas de Realtime Database con Admin SDK, use los getRules() y setRules() de admin.database . Puede recuperar conjuntos de reglas en formato JSON o como una cadena con comentarios incluidos.

Para actualizar un conjunto de reglas:

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

Administrar conjuntos de reglas

Para ayudar a administrar grandes conjuntos de reglas, Admin SDK le permite enumerar todas las reglas existentes con admin.securityRules().listRulesetMetadata . Por ejemplo:

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

Para implementaciones muy grandes que alcanzan el límite de 2500 conjuntos de reglas con el tiempo, puede crear una lógica para eliminar las reglas más antiguas en un ciclo de tiempo fijo. Por ejemplo, para eliminar todos los conjuntos de reglas implementados durante más de 30 días:

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

Usar la API REST

Las herramientas descritas anteriormente se adaptan bien a varios flujos de trabajo, pero es posible que desee administrar e implementar las reglas de seguridad de Firebase mediante la propia API de administración. La API de administración le brinda la mayor flexibilidad.

Tenga en cuenta que las versiones de las reglas de seguridad de Firebase tardan varios minutos en propagarse por completo. Cuando utilice la API REST de administración para implementar, asegúrese de evitar condiciones de carrera en las que su aplicación dependa inmediatamente de reglas cuya implementación aún no se haya completado.

También tenga en cuenta estos límites:

  • Las reglas deben tener menos de 256 KiB de texto codificado en UTF-8 cuando se serializan.
  • Un proyecto puede tener como máximo 2500 conjuntos de reglas implementados en total. Una vez que se alcanza este límite, debe eliminar algunos conjuntos de reglas antiguos antes de crear otros nuevos.

Cree e implemente conjuntos de reglas de Cloud Storage o Cloud Firestore con REST

Los ejemplos de esta sección usan reglas de almacenamiento, aunque también se aplican a las reglas de Cloud Firestore.

Los ejemplos también usan cURL para hacer llamadas a la API. Se omiten los pasos para configurar y pasar tokens de autenticación. Puede experimentar con esta API usando el API Explorer integrado con la documentación de referencia .

Los pasos típicos para crear e implementar un conjunto de reglas usando la API de administración son:

  1. Crear un archivo de reglas fuentes
  2. Crear un conjunto de reglas
  3. Publicar (implementar) el nuevo conjunto de reglas

Supongamos que está trabajando en su proyecto de Firebase de secure_commerce y desea implementar reglas de almacenamiento en la nube bloqueadas. Puede implementar estas reglas en un archivo storage.rules .

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if false;
    }
  }
}

Ahora, genere una huella digital codificada en base64 para este archivo. Luego puede usar la fuente en este archivo para completar la carga útil necesaria para crear un conjunto de reglas con la llamada REST de projects.rulesets.create . Aquí, usamos el comando cat para insertar el contenido de storage.rules en la carga útil REST.

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

La API devuelve una respuesta de validación y un nombre de conjunto de reglas, por ejemplo projects/secure_commerce/rulesets/uuid123 . Si el conjunto de reglas es válido, el paso final es implementar el nuevo conjunto de reglas en una versión con nombre.

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

Actualice los conjuntos de reglas de Realtime Database con REST

Realtime Database proporciona su propia interfaz REST para administrar reglas. Consulte Administrar las reglas de la base de datos en tiempo real de Firebase a través de REST .

Administrar conjuntos de reglas con REST

Para ayudar a administrar implementaciones de reglas grandes, además de un método REST para crear conjuntos de reglas y versiones, la API de administración proporciona métodos para:

  • enumerar, obtener y eliminar conjuntos de reglas
  • enumerar, obtener y eliminar versiones de reglas

Para implementaciones muy grandes que alcanzan el límite de 2500 conjuntos de reglas con el tiempo, puede crear una lógica para eliminar las reglas más antiguas en un ciclo de tiempo fijo. Por ejemplo, para eliminar todos los conjuntos de reglas implementados durante más de 30 días, puede llamar al método projects.rulesets.list , analizar la lista JSON de objetos de conjunto de Ruleset en sus claves createTime y luego llamar a project.rulesets.delete en los conjuntos de reglas correspondientes por ruleset_id .

Pruebe sus actualizaciones con REST

Finalmente, la API de administración le permite ejecutar pruebas sintácticas y semánticas en los recursos de Cloud Firestore y Cloud Storage en sus proyectos de producción.

La prueba con este componente de la API consiste en:

  1. Definición de un objeto TestSuite JSON para representar un conjunto de objetos TestCase
  2. Enviar el TestSuite
  3. Análisis de los objetos TestResult devueltos

Definamos un objeto TestSuite con un solo TestCase en un archivo testcase.json . En este ejemplo, pasamos la fuente de lenguaje de reglas en línea con la carga útil de REST, junto con el conjunto de pruebas para ejecutar esas reglas. Especificamos una expectativa de evaluación de Reglas y la solicitud del cliente contra la cual se probará el conjunto de reglas. También puede especificar qué tan completo es el informe de prueba, usando el valor "FULL" para indicar los resultados de todas las expresiones del idioma de las Reglas que deben incluirse en el informe, incluidas las expresiones que no coincidieron con la solicitud.

 {
  "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"}}}
            }
          ]
      }
    ]
  }
}

Luego podemos enviar este TestSuite para su evaluación con el método projects.test .

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

El TestReport devuelto (que contiene el estado de la prueba SUCCESS/FAILURE, listas de mensajes de depuración, listas de expresiones de Reglas visitadas y sus informes de evaluación) confirmaría con el estado SUCCESS que el acceso está permitido correctamente.

Administrar permisos para reglas de seguridad de almacenamiento en la nube entre servicios

Si crea reglas de seguridad de almacenamiento en la nube que utilizan el contenido de documentos de Cloud Firestore para evaluar las condiciones de seguridad , se le solicitará en Firebase console o Firebase CLI que habilite los permisos para conectar los dos productos.

Si decide deshabilitar dicha seguridad entre servicios:

  1. Primero, antes de deshabilitar la función, edite sus reglas y elimine todas las declaraciones que usan funciones de Reglas para acceder a Cloud Firestore. De lo contrario, después de que se deshabilite la función, las evaluaciones de las reglas harán que sus solicitudes de almacenamiento fallen.

  2. Use la página de IAM en Google Cloud Console para eliminar la función "Firebase Rules Firestore Service Agent" siguiendo la guía de Cloud para revocar funciones .

Se le pedirá que vuelva a habilitar la función la próxima vez que guarde las reglas entre servicios desde Firebase CLI o Firebase console.