Firebase Security Rules umożliwiają kontrolowanie dostępu do przechowywanych danych. Elastyczna składnia reguł oznacza, że możesz tworzyć reguły, które pasują do wszystkiego – od wszystkich zapisów w całej bazie danych po operacje na konkretnym dokumencie.
W tym przewodniku opisujemy niektóre z podstawowych przypadków użycia, które możesz wdrożyć podczas konfigurowania aplikacji i zabezpieczania danych. Zanim jednak zaczniesz pisać reguły, warto dowiedzieć się więcej o języku, w którym są pisane, oraz o ich działaniu.
Aby uzyskać dostęp do reguł i je zaktualizować, wykonaj czynności opisane w artykule Zarządzanie i wdrażanie Firebase Security Rules.
prompt AI dla pomocy AI
Aby uzyskać pomoc AI, skopiuj poniższy prompt do swojego agenta kodowania AI (takiego jak Gemini w Android Studio, Antigravity, Claude Code, Codex czy Cursor). Możesz dostosować prompta i wprowadzać zmiany z agentem. Szczegółowe informacje o instalacji znajdziesz w artykule Umiejętności agenta Firebase.
Help me use Firebase in my app.
1. Make sure that **Firebase agent skills** are installed and updated. For Claude Code, Codex, or Cursor agents, help me install the Firebase plugin. For other agents, run `npx skills add firebase/agent-skills`. Always try to use **Firebase agent skills** for Firebase-related tasks.
2. Help me write, validate, and deploy Firebase Security Rules to protect my app's data.
Reguły domyślne: tryb blokady
Podczas tworzenia bazy danych lub instancji pamięci masowej w konsoli Firebase wybierasz, czy Firebase Security Rules ma ograniczać dostęp do danych (tryb zablokowany) czy zezwalać na dostęp wszystkim (tryb testowy). W Cloud Firestore i Realtime Database domyślne reguły trybu blokady odmawiają dostępu wszystkim użytkownikom. W Cloud Storage dostęp do zasobników miejsca na dane mają tylko uwierzytelnieni użytkownicy.
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if false;
}
}
}
Realtime Database
{
"rules": {
".read": false,
".write": false
}
}
Cloud Storage
service firebase.storage {
match /b/{bucket}/o {
match /{allPaths=**} {
allow read, write: if false;
}
}
}
Reguły środowiska programistycznego
Podczas pracy nad aplikacją możesz potrzebować stosunkowo otwartego lub nieograniczonego dostępu do danych. Pamiętaj, aby zaktualizować Security Rules, zanim wdrożysz aplikację w środowisku produkcyjnym. Pamiętaj też, że jeśli wdrożysz aplikację, będzie ona publicznie dostępna, nawet jeśli nie została uruchomiona.
Pamiętaj, że Firebase umożliwia klientom bezpośredni dostęp do danych, a Firebase Security Rules to jedyne zabezpieczenie blokujące dostęp szkodliwym użytkownikom. Definiowanie reguł niezależnie od logiki usługi ma wiele zalet: klienci nie są odpowiedzialni za egzekwowanie zabezpieczeń, błędne implementacje nie naruszają bezpieczeństwa danych, a co najważniejsze, nie musisz polegać na serwerze pośredniczącym, aby chronić dane przed światem.
Wszyscy uwierzytelnieni użytkownicy
Nie zalecamy pozostawiania danych dostępnych dla każdego zalogowanego użytkownika, ale podczas tworzenia aplikacji może być przydatne ustawienie dostępu dla każdego uwierzytelnionego użytkownika.
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
match /some_collection/{document} {
allow read, write: if request.auth != null;
}
}
}
Realtime Database
{
"rules": {
"some_path": {
".read": "auth.uid !== null",
".write": "auth.uid !== null"
}
}
}
Cloud Storage
service firebase.storage {
match /b/{bucket}/o {
match /some_folder/{fileName} {
allow read, write: if request.auth != null;
}
}
}
Reguły gotowe do wykorzystania w środowisku produkcyjnym
Przygotowując się do wdrożenia aplikacji, upewnij się, że dane są chronione i że użytkownicy mają odpowiednie uprawnienia dostępu. Użyj Authentication, aby skonfigurować dostęp na podstawie użytkownika, i odczytuj dane bezpośrednio z bazy danych, aby skonfigurować dostęp na podstawie danych.
Rozważ napisanie reguł podczas strukturyzowania danych, ponieważ sposób, w jaki skonfigurujesz reguły, wpływa na to, jak ograniczysz dostęp do danych w różnych ścieżkach.
Dostęp tylko dla właściciela treści
Te reguły ograniczają dostęp tylko do uwierzytelnionego właściciela treści. Dane mogą być odczytywane i zapisywane tylko przez jednego użytkownika, a ścieżka danych zawiera identyfikator użytkownika.
Kiedy ta reguła działa: ta reguła działa dobrze, jeśli dane są odizolowane według użytkownika – jeśli jedynym użytkownikiem, który musi mieć dostęp do danych, jest ten, który je utworzył.
Kiedy ta reguła nie działa: ten zestaw reguł nie działa, gdy wielu użytkowników musi zapisywać lub odczytywać te same dane – użytkownicy będą zastępować dane lub nie będą mogli uzyskać dostępu do utworzonych przez siebie danych.
Aby skonfigurować tę regułę: utwórz regułę, która potwierdza, że użytkownik proszący o dostęp do odczytu lub zapisu danych jest właścicielem tych danych.
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
// Allow only authenticated content owners access
match /some_collection/{userId}/{document} {
allow read, write: if request.auth != null && request.auth.uid == userId
}
}
}
Realtime Database
{
"rules": {
"some_path": {
"$uid": {
// Allow only authenticated content owners access to their data
".read": "auth !== null && auth.uid === $uid",
".write": "auth !== null && auth.uid === $uid"
}
}
}
}
Cloud Storage
// Grants a user access to a node matching their user ID
service firebase.storage {
match /b/{bucket}/o {
// Files look like: "user/<UID>/file.txt"
match /user/{userId}/{fileName} {
allow read, write: if request.auth != null && request.auth.uid == userId;
}
}
}
Mieszany dostęp publiczny i prywatny
Ta reguła umożliwia każdemu odczyt zbioru danych, ale ogranicza możliwość tworzenia i modyfikowania danych w danej ścieżce tylko do uwierzytelnionego właściciela treści.
Kiedy ta reguła działa: ta reguła sprawdza się w przypadku aplikacji, które wymagają elementów możliwych do odczytania przez wszystkich, ale muszą ograniczyć uprawnienia do edycji tych elementów do ich właścicieli. na przykład aplikacja do obsługi czatu lub blog.
Kiedy ta reguła nie działa: podobnie jak reguła dotycząca tylko właściciela treści, ten zestaw reguł nie działa, gdy wielu użytkowników musi edytować te same dane. Użytkownicy będą ostatecznie zastępować dane innych osób.
Aby skonfigurować tę regułę: utwórz regułę, która umożliwia dostęp do odczytu wszystkim użytkownikom (lub wszystkim uwierzytelnionym użytkownikom) i potwierdza, że użytkownik zapisujący dane jest właścicielem.
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
// Allow public read access, but only content owners can write
match /some_collection/{document} {
// Allow public reads
allow read: if true
// Allow creation if the current user owns the new document
allow create: if request.auth.uid == request.resource.data.author_uid;
// Allow updates by the owner, and prevent change of ownership
allow update: if request.auth.uid == request.resource.data.author_uid
&& request.auth.uid == resource.data.author_uid;
// Allow deletion if the current user owns the existing document
allow delete: if request.auth.uid == resource.data.author_uid;
}
}
}
Realtime Database
{
// Allow anyone to read data, but only authenticated content owners can
// make changes to their data
"rules": {
"some_path": {
"$uid": {
".read": true,
// or ".read": "auth.uid !== null" for only authenticated users
".write": "auth.uid === $uid"
}
}
}
}
Cloud Storage
service firebase.storage {
match /b/{bucket}/o {
// Files look like: "user/<UID>/file.txt"
match /user/{userId}/{fileName} {
allow read;
allow write: if request.auth.uid == userId;
}
}
}
Dostęp na podstawie atrybutów i ról
Aby te reguły działały, musisz zdefiniować i przypisać atrybuty użytkownikom w danych. Firebase Security Rules sprawdza żądanie na podstawie danych z bazy danych lub metadanych pliku, aby potwierdzić lub odrzucić dostęp.
Kiedy ta reguła działa: jeśli przypisujesz rolę użytkownikom, ta reguła pozwala ograniczyć dostęp na podstawie ról lub określonych grup użytkowników. Jeśli na przykład przechowujesz oceny, możesz przypisać różne poziomy dostępu do grupy „uczniowie” (tylko odczyt treści), grupy „nauczyciele” (odczyt i zapis w ramach przedmiotu) i grupy „dyrektorzy” (odczyt wszystkich treści).
Kiedy ta reguła nie działa: w Realtime Database i Cloud Storage Twoje reguły nie mogą używać metody get(), którą mogą uwzględniać reguły Cloud Firestore.
W związku z tym musisz ustrukturyzować bazę danych lub metadane plików, aby odzwierciedlały atrybuty, których używasz w regułach.
Aby skonfigurować tę regułę: w Cloud Firestore dodaj do dokumentów użytkowników pole, które możesz odczytać, a następnie skonfiguruj regułę tak, aby odczytywała to pole i warunkowo przyznawała dostęp. W Realtime Database utwórz ścieżkę danych, która definiuje użytkowników aplikacji i przypisuje im rolę w węźle podrzędnym.
Możesz też skonfigurować niestandardowe oświadczenia w Authentication, a następnie pobrać te informacje ze zmiennej auth.token w dowolnym Firebase Security Rules.
Atrybuty i role zdefiniowane przez dane
Te reguły działają tylko w Cloud Firestore i Realtime Database.
Cloud Firestore
Pamiętaj, że za każdym razem, gdy reguły obejmują odczyt, jak w przypadku reguł poniżej, naliczana jest opłata za operację odczytu w usłudze Cloud Firestore.
service cloud.firestore {
match /databases/{database}/documents {
// For attribute-based access control, Check a boolean `admin` attribute
allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.admin == true;
allow read: true;
// Alterntatively, for role-based access, assign specific roles to users
match /some_collection/{document} {
allow read: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Reader"
allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Writer"
}
}
}
Realtime Database
{
"rules": {
"some_path": {
"${subpath}": {
//
".write": "root.child('users').child(auth.uid).child('role').val() === 'admin'",
".read": true
}
}
}
}
Atrybuty i role niestandardowych deklaracji
Aby wdrożyć te reguły, skonfiguruj roszczenia niestandardowe w Firebase Authentication, a następnie użyj ich w regułach.
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
// For attribute-based access control, check for an administrator claim
allow write: if request.auth.token.admin == true;
allow read: true;
// Alterntatively, for role-based access, assign specific roles to users
match /some_collection/{document} {
allow read: if request.auth.token.reader == "true";
allow write: if request.auth.token.writer == "true";
}
}
}
Realtime Database
{
"rules": {
"some_path": {
"$uid": {
// Create a custom claim for each role or group
// you want to use
".write": "auth.uid !== null && auth.token.writer === true",
".read": "auth.uid !== null && auth.token.reader === true"
}
}
}
}
Cloud Storage
service firebase.storage {
// Allow reads if the group ID in your token matches the file metadata's `owner` property
// Allow writes if the group ID is in the user's custom token
match /files/{groupId}/{fileName} {
allow read: if resource.metadata.owner == request.auth.token.groupId;
allow write: if request.auth.token.groupId == groupId;
}
}
Atrybuty najmu
Aby wdrożyć te reguły, skonfiguruj wielu najemców w Google Cloud Identity Platform (GCIP), a następnie użyj najemcy w regułach. Poniższe przykłady zezwalają na zapisywanie przez użytkownika w określonym najemcy, na przykład tenant2-m6tyz
Cloud Firestore
service cloud.firestore {
match /databases/{database}/documents {
// For tenant-based access control, check for a tenantID
allow write: if request.auth.token.firebase.tenant == 'tenant2-m6tyz';
allow read: true;
}
}
Realtime Database
{
"rules": {
"some_path": {
"$uid": {
// Only allow reads and writes if user belongs to a specific tenant
".write": "auth.uid !== null && auth.token.firebase.tenant === 'tenant2-m6tyz'",
".read": "auth.uid !== null
}
}
}
}
Cloud Storage
service firebase.storage {
// Only allow reads and writes if user belongs to a specific tenant
match /files/{tenantId}/{fileName} {
allow read: if request.auth != null;
allow write: if request.auth.token.firebase.tenant == tenantId;
}
}