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

Walidacji danych

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Za pomocą reguł zabezpieczeń Firebase możesz warunkowo zapisywać nowe dane na podstawie istniejących danych w Twojej bazie danych lub zasobniku na dane. Możesz także napisać reguły, które wymuszają sprawdzanie poprawności danych, ograniczając zapisy na podstawie nowych zapisywanych danych. Czytaj dalej, aby dowiedzieć się więcej o regułach, które wykorzystują istniejące dane do tworzenia warunków bezpieczeństwa.

Wybierz produkt w każdej sekcji, aby dowiedzieć się więcej o regułach sprawdzania poprawności danych.

Ograniczenia dotyczące nowych danych

Cloud Firestore

Jeśli chcesz się upewnić, że dokument zawierający określone pole nie zostanie utworzony, możesz uwzględnić to pole w warunku allow . Na przykład, jeśli chcesz odmówić tworzenia jakichkolwiek dokumentów, które zawierają pole ranking , nie zezwalasz na to w warunku create .

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

Baza danych czasu rzeczywistego

Jeśli chcesz się upewnić, że dane zawierające określone wartości nie zostaną dodane do Twojej bazy danych, uwzględnij tę wartość w swoich regułach i nie zezwalaj na jej zapisy. Na przykład, jeśli chcesz odmówić jakichkolwiek zapisów zawierających wartości ranking , zabronisz zapisu dla wszystkich dokumentów z wartościami 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')
    }
  }

Magazyn w chmurze

Jeśli chcesz się upewnić, że plik zawierający określone metadane nie zostanie utworzony, możesz uwzględnić metadane w warunku allow . Na przykład, jeśli chcesz odmówić tworzenia jakichkolwiek plików zawierających metadane ranking , nie zezwalasz na to w warunku create .

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

Użyj istniejących danych w regułach bezpieczeństwa Firebase

Cloud Firestore

Wiele aplikacji przechowuje informacje o kontroli dostępu jako pola w dokumentach w bazie danych. Reguły zabezpieczeń Cloud Firestore mogą dynamicznie zezwalać lub odmawiać dostępu na podstawie danych dokumentu:

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

Zmienna resource odnosi się do żądanego dokumentu, a resource.data to mapa wszystkich pól i wartości przechowywanych w dokumencie. Więcej informacji na temat zmiennej resource można znaleźć w dokumentacji referencyjnej .

Podczas zapisywania danych możesz chcieć porównać dane przychodzące z istniejącymi danymi. Pozwala to na takie rzeczy, jak upewnienie się, że pole nie uległo zmianie, że pole zwiększyło się tylko o jeden lub że nowa wartość jest co najmniej o tydzień w przyszłości. W takim przypadku, jeśli zestaw reguł zezwala na oczekujący zapis, zmienna request.resource zawiera przyszły stan dokumentu. W przypadku operacji update , które modyfikują tylko podzbiór pól dokumentu, zmienna request.resource będzie zawierać oczekujący stan dokumentu po operacji. Możesz sprawdzić wartości pól w request.resource , aby zapobiec niechcianym lub niespójnym aktualizacjom danych:

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

Baza danych czasu rzeczywistego

W Bazie danych czasu rzeczywistego użyj reguł .validate , aby wymusić struktury danych i sprawdzić poprawność formatu i zawartości danych. Reguły uruchamiają reguły .validate po sprawdzeniu, czy reguła .write przyznaje dostęp.

Reguły .validate nie są kaskadowe. Jeśli jakakolwiek reguła walidacji nie powiedzie się na dowolnej ścieżce lub ścieżce podrzędnej w regule, cała operacja zapisu zostanie odrzucona. Ponadto walidacja definicji sprawdza tylko wartości inne niż null, a następnie ignoruje wszelkie żądania, które usuwają dane.

Rozważ następujące reguły .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()"
        }
      }
    }
  }

Żądania zapisu do bazy danych z powyższymi regułami miałyby następujące wyniki:

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);
Cel C
Uwaga: ten produkt Firebase nie jest dostępny w miejscu docelowym klipu aplikacji.
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];
Szybki
Uwaga: ten produkt Firebase nie jest dostępny w miejscu docelowym klipu aplikacji.
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);
Jawa
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);
RESZTA
# 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

Magazyn w chmurze

Podczas oceny reguł możesz również chcieć ocenić metadane przesyłanego, pobieranego, modyfikowanego lub usuwanego pliku. Pozwala to na tworzenie złożonych i potężnych reguł, które pozwalają na przesyłanie tylko plików z określonymi typami treści lub usuwanie tylko plików większych niż określony rozmiar.

Obiekt resource zawiera pary klucz/wartość z metadanymi pliku znajdującymi się w obiekcie Cloud Storage. Te właściwości można sprawdzać w żądaniach read lub write , aby zapewnić integralność danych. Obiekt resource sprawdza metadane istniejących plików w Twoim zasobniku 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';
        }
      }
    }
  }

Możesz również użyć obiektu request.resource przy żądaniach write (takich jak przesyłanie, aktualizacja metadanych i usuwanie. Obiekt request.resource pobiera metadane z pliku, który zostanie zapisany, jeśli write będzie dozwolony.

Tych dwóch wartości można użyć, aby zapobiec niechcianym lub niespójnym aktualizacjom lub wymusić ograniczenia aplikacji, takie jak typ lub rozmiar pliku.

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

Pełna lista właściwości w obiekcie resource jest dostępna w dokumentacji referencyjnej .