Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Validación de datos

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Puede usar las reglas de seguridad de Firebase para escribir datos nuevos de forma condicional en función de los datos existentes en su base de datos o depósito de almacenamiento. También puede escribir reglas que apliquen validaciones de datos al restringir las escrituras en función de los nuevos datos que se escriben. Siga leyendo para obtener más información sobre las reglas que usan datos existentes para crear condiciones de seguridad.

Seleccione un producto en cada sección para obtener más información sobre las reglas de validación de datos.

Restricciones en nuevos datos

Tienda de fuego en la nube

Si desea asegurarse de que no se cree un documento que contenga un campo específico, puede incluir el campo en la condición de allow . Por ejemplo, si desea denegar la creación de cualquier documento que contenga el campo de ranking , lo rechazaría en la condición de create .

  service cloud.firestore {
    match /databases/{database}/documents {
      // Disallow
      match /cities/{city} {
        allow create: if !("ranking" in request.resource.data)
      }
    }
  }

Base de datos en tiempo real

Si desea asegurarse de que los datos que contienen ciertos valores no se agreguen a su base de datos, debe incluir ese valor en sus reglas y no permitir escrituras. Por ejemplo, si desea denegar cualquier escritura que contenga valores de ranking , no permitiría escrituras para ningún documento con valores de ranking .

  {
    "rules": {
      // Write is allowed for all paths
      ".write": true,
      // Allows writes only if new data doesn't include a `ranking` child value
      ".validate": "!newData.hasChild('ranking')
    }
  }

Almacenamiento en la nube

Si desea asegurarse de que no se cree un archivo que contenga metadatos específicos, puede incluir los metadatos en la condición de allow . Por ejemplo, si desea denegar la creación de cualquier archivo que contenga metadatos de ranking , no lo permitiría en la condición de create .

  service firebase.storage {
    match /b/{bucket}/o {
      match /files/{allFiles=**} {
      // Disallow
        allow create: if !("ranking" in request.resource.metadata)
      }
    }
  }

Usar datos existentes en las reglas de seguridad de Firebase

Tienda de fuego en la nube

Muchas aplicaciones almacenan información de control de acceso como campos en documentos en la base de datos. Las reglas de seguridad de Cloud Firestore pueden permitir o denegar el acceso de forma dinámica en función de los datos del documento:

  service cloud.firestore {
    match /databases/{database}/documents {
      // Allow the user to read data if the document has the 'visibility'
      // field set to 'public'
      match /cities/{city} {
        allow read: if resource.data.visibility == 'public';
      }
    }
  }

La variable de resource hace referencia al documento solicitado y resource.data es un mapa de todos los campos y valores almacenados en el documento. Para obtener más información sobre la variable de resource , consulte la documentación de referencia .

Al escribir datos, es posible que desee comparar los datos entrantes con los datos existentes. Esto le permite hacer cosas como asegurarse de que un campo no haya cambiado, que un campo solo haya aumentado en uno o que el nuevo valor sea al menos una semana en el futuro. En este caso, si su conjunto de reglas permite la escritura pendiente, la variable request.resource contiene el estado futuro del documento. Para las operaciones de update que solo modifican un subconjunto de los campos del documento, la variable request.resource contendrá el estado del documento pendiente después de la operación. Puede comprobar los valores de los campos en request.resource para evitar actualizaciones de datos no deseadas o incoherentes:

   service cloud.firestore {
     match /databases/{database}/documents {
      // Make sure all cities have a positive population and
      // the name is not changed
      match /cities/{city} {
        allow update: if request.resource.data.population > 0
                      && request.resource.data.name == resource.data.name;
      }
    }
  }

Base de datos en tiempo real

En Realtime Database, use las reglas .validate para hacer cumplir las estructuras de datos y validar el formato y el contenido de los datos. Las reglas ejecutan reglas .validate después de verificar que una regla .write otorga acceso.

Las reglas .validate no se aplican en cascada. Si alguna regla de validación falla en cualquier ruta o subruta de la regla, se rechazará toda la operación de escritura. Además, las definiciones de validación solo verifican valores no nulos y, posteriormente, ignoran cualquier solicitud que elimine datos.

Considere las siguientes reglas .validate :

  {
    "rules": {
      // write is allowed for all paths
      ".write": true,
      "widget": {
        // a valid widget must have attributes "color" and "size"
        // allows deleting widgets (since .validate is not applied to delete rules)
        ".validate": "newData.hasChildren(['color', 'size'])",
        "size": {
          // the value of "size" must be a number between 0 and 99
          ".validate": "newData.isNumber() &&
                        newData.val() >= 0 &&
                        newData.val() <= 99"
        },
        "color": {
          // the value of "color" must exist as a key in our mythical
          // /valid_colors/ index
          ".validate": "root.child('valid_colors/' + newData.val()).exists()"
        }
      }
    }
  }

Las solicitudes de escritura a una base de datos con las reglas anteriores tendrían los siguientes resultados:

JavaScript
var ref = db.ref("/widget");

// PERMISSION_DENIED: does not have children color and size
ref.set('foo');

// PERMISSION DENIED: does not have child color
ref.set({size: 22});

// PERMISSION_DENIED: size is not a number
ref.set({ size: 'foo', color: 'red' });

// SUCCESS (assuming 'blue' appears in our colors list)
ref.set({ size: 21, color: 'blue'});

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child('size').set(99);
C objetivo
Nota: Este producto de Firebase no está disponible en el objetivo App Clip.
FIRDatabaseReference *ref = [[[FIRDatabase database] reference] child: @"widget"];

// PERMISSION_DENIED: does not have children color and size
[ref setValue: @"foo"];

// PERMISSION DENIED: does not have child color
[ref setValue: @{ @"size": @"foo" }];

// PERMISSION_DENIED: size is not a number
[ref setValue: @{ @"size": @"foo", @"color": @"red" }];

// SUCCESS (assuming 'blue' appears in our colors list)
[ref setValue: @{ @"size": @21, @"color": @"blue" }];

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
[[ref child:@"size"] setValue: @99];
Rápido
Nota: Este producto de Firebase no está disponible en el objetivo App Clip.
var ref = FIRDatabase.database().reference().child("widget")

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo")

// PERMISSION DENIED: does not have child color
ref.setValue(["size": "foo"])

// PERMISSION_DENIED: size is not a number
ref.setValue(["size": "foo", "color": "red"])

// SUCCESS (assuming 'blue' appears in our colors list)
ref.setValue(["size": 21, "color": "blue"])

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("widget");

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo");

// PERMISSION DENIED: does not have child color
ref.child("size").setValue(22);

// PERMISSION_DENIED: size is not a number
Map<String,Object> map = new HashMap<String, Object>();
map.put("size","foo");
map.put("color","red");
ref.setValue(map);

// SUCCESS (assuming 'blue' appears in our colors list)
map = new HashMap<String, Object>();
map.put("size", 21);
map.put("color","blue");
ref.setValue(map);

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
DESCANSAR
# PERMISSION_DENIED: does not have children color and size
curl -X PUT -d 'foo' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION DENIED: does not have child color
curl -X PUT -d '{"size": 22}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION_DENIED: size is not a number
curl -X PUT -d '{"size": "foo", "color": "red"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# SUCCESS (assuming 'blue' appears in our colors list)
curl -X PUT -d '{"size": 21, "color": "blue"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# If the record already exists and has a color, this will
# succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
# will fail to validate
curl -X PUT -d '99' \
https://docs-examples.firebaseio.com/rest/securing-data/example/size.json

Almacenamiento en la nube

Al evaluar las reglas, es posible que también desee evaluar los metadatos del archivo que se está cargando, descargando, modificando o eliminando. Esto le permite crear reglas complejas y poderosas que hacen cosas como permitir que solo se carguen archivos con ciertos tipos de contenido, o que solo se eliminen archivos que superen cierto tamaño.

El objeto de resource contiene pares clave/valor con metadatos de archivo que aparecen en un objeto de Cloud Storage. Estas propiedades se pueden inspeccionar en solicitudes de read o write para garantizar la integridad de los datos. El objeto de resource verifica los metadatos en los archivos existentes en su depósito de Cloud Storage.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        match /{allImages=**} {
          // Allow reads if a custom 'visibility' field is set to 'public'
          allow read: if resource.metadata.visibility == 'public';
        }
      }
    }
  }

También puede usar el objeto request.resource en solicitudes de write (como cargas, actualizaciones de metadatos y eliminaciones). El objeto request.resource obtiene metadatos del archivo que se escribirán si se permite la write .

Puede utilizar estos dos valores para evitar actualizaciones no deseadas o incoherentes o para aplicar restricciones de la aplicación, como el tipo o el tamaño del archivo.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        // Cascade read to any image type at any path
        match /{allImages=**} {
          allow read;
        }

        // Allow write files to the path "images/*", subject to the constraints:
        // 1) File is less than 5MB
        // 2) Content type is an image
        // 3) Uploaded content type matches existing content type
        // 4) File name (stored in imageId wildcard variable) is less than 32 characters
        match /{imageId} {
          allow write: if request.resource.size < 5 * 1024 * 1024
                       && request.resource.contentType.matches('image/.*')
                       && request.resource.contentType == resource.contentType
                       && imageId.size() < 32
        }
      }
    }
  }

Una lista completa de propiedades en el objeto de resource está disponible en la documentación de referencia .