Google is committed to advancing racial equity for Black communities. See how.
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Regole di sicurezza di base

Le regole di sicurezza di Firebase consentono di controllare l'accesso ai dati memorizzati. La sintassi flessibile delle regole significa che è possibile creare regole che corrispondono a qualsiasi cosa, da tutte le scritture all'intero database alle operazioni su un documento specifico.

Questa guida descrive alcuni dei casi d'uso di base che potresti voler implementare mentre configuri la tua app e salvaguardi i tuoi dati. Tuttavia, prima di iniziare a scrivere regole, potresti voler saperne di più sulla lingua in cui sono scritti e sul loro comportamento .

Per accedere e aggiornare le regole, seguire i passaggi descritti in Gestire e distribuire le regole di sicurezza di Firebase .

Regole predefinite: modalità bloccata

Quando si crea un database o un'istanza di archiviazione nella console di Firebase, si sceglie se le regole di sicurezza di Firebase limitano l'accesso ai dati ( modalità bloccata ) o se ne consente l'accesso a chiunque ( modalità test ). In Cloud Firestore e Realtime Database, le regole predefinite per la modalità bloccata negano l'accesso a tutti gli utenti. In Archiviazione, solo gli utenti autenticati possono accedere ai secchi di archiviazione.

Cloud Firestore

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

Database in tempo reale

 {
  "rules": {
    ".read": false,
    ".write": false
  }
}
 

Conservazione

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

Regole dell'ambiente di sviluppo

Mentre lavori sulla tua app, potresti desiderare un accesso relativamente aperto o libero ai tuoi dati. Assicurati di aggiornare le tue regole prima di distribuire l'app in produzione. Ricorda inoltre che se distribuisci la tua app è accessibile pubblicamente, anche se non l'hai lanciata .

Ricorda che Firebase consente ai clienti di accedere direttamente ai tuoi dati e che le Regole di sicurezza di Firebase sono l'unica protezione che blocca l'accesso per utenti malintenzionati. Definire le regole separatamente dalla logica del prodotto presenta una serie di vantaggi: i clienti non sono responsabili dell'applicazione della sicurezza, le implementazioni con errori non compromettono i dati e, soprattutto, non si affidano a un server intermedio per proteggere i dati dal mondo.

Tutti gli utenti autenticati

Sebbene non ti consigliamo di lasciare i tuoi dati accessibili a tutti gli utenti che hanno effettuato l'accesso, potrebbe essere utile impostare l'accesso a qualsiasi utente autenticato durante lo sviluppo della tua app.

Cloud Firestore

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

Database in tempo reale

 {
  "rules": {
    ".read": "auth.uid != null"
    ".write": "auth.uid != null"
  }
}
 

Conservazione

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

Regole pronte per la produzione

Mentre ti prepari a distribuire la tua app, assicurati che i tuoi dati siano protetti e che l'accesso sia concesso correttamente ai tuoi utenti. Sfrutta l' autenticazione per impostare l'accesso basato sull'utente e leggere direttamente dal tuo database per impostare l'accesso basato sui dati.

Prendi in considerazione la possibilità di scrivere regole mentre strutturi i tuoi dati, poiché il modo in cui imposti le tue regole influisce sul modo in cui limiti l'accesso ai dati su percorsi diversi.

Accesso solo al proprietario dei contenuti

Queste regole limitano l'accesso al solo proprietario autenticato del contenuto. I dati sono leggibili e scrivibili da un solo utente e il percorso dei dati contiene l'ID dell'utente.

Quando questa regola funziona: questa regola funziona bene se i dati vengono messi a tacere dall'utente - se l'unico utente che deve accedere ai dati è lo stesso utente che ha creato i dati.

Quando questa regola non funziona: questa serie di regole non funziona quando più utenti devono scrivere o leggere gli stessi dati: gli utenti sovrascriveranno i dati o non potranno accedere ai dati che hanno creato.

Per impostare questa regola: Creare una regola che confermi l'utente che richiede l'accesso per leggere o scrivere i dati è l'utente proprietario di tali dati.

Cloud Firestore

 service cloud.firestore {
  match /databases/{database}/documents {
    // Allow only authenticated content owners access
    match /some_collection/{userId}/{documents=**} {
      allow read, write: if request.auth != null && request.auth.uid == userId
    }
  }
}
 

Database in tempo reale

 {
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "request.auth != null && request.auth.uid == $uid"
        ".write": "request.auth != null && request.auth.uid == $uid"
      }
    }
  }
}
 

Conservazione

 // Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
  }
}
 

Accesso misto pubblico e privato

Questa regola consente a chiunque di leggere un set di dati, ma limita la possibilità di creare o modificare i dati in un determinato percorso solo al proprietario del contenuto autenticato.

Quando questa regola funziona: questa regola funziona bene per le app che richiedono elementi leggibili pubblicamente, ma devono limitare l'accesso in modifica ai proprietari di tali elementi. Ad esempio, un'app di chat o un blog.

Quando questa regola non funziona: come la sola regola del proprietario del contenuto, questa serie di regole non funziona quando più utenti devono modificare gli stessi dati. Gli utenti alla fine sovrascriveranno i dati degli altri.

Per impostare questa regola: Creare una regola che consenta l'accesso in lettura a tutti gli utenti (o tutti gli utenti autenticati) e confermi che l'utente che scrive i dati è il proprietario.

Cloud Firestore

 service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      allow read: if true
      allow create: if request.auth.uid == request.resource.data.author_uid;
      allow update, delete: if request.auth.uid == resource.data.author_uid;
    }
  }
}
 

Database in tempo reale

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

Conservazione

 service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}
 

Accesso basato sugli attributi e basato sul ruolo

Affinché queste regole funzionino, è necessario definire e assegnare attributi agli utenti nei dati. Le regole di sicurezza di Firebase controllano la richiesta rispetto ai dati del database o dei metadati del file per confermare o negare l'accesso.

Quando questa regola funziona: se stai assegnando un ruolo agli utenti, questa regola semplifica la limitazione dell'accesso in base a ruoli o gruppi specifici di utenti. Ad esempio, se si memorizzavano voti, è possibile assegnare livelli di accesso diversi al gruppo "studenti" (solo per leggere il loro contenuto), al gruppo "insegnanti" (leggere e scrivere nella loro materia) e al gruppo "presidi" (leggere tutto il contenuto).

Quando questa regola non funziona: in Realtime Database and Storage, le tue regole non possono sfruttare il metodo get() che le regole di Cloud Firestore possono incorporare. Di conseguenza, è necessario strutturare il database o i metadati del file per riflettere gli attributi utilizzati nelle regole.

Per impostare questa regola: In Cloud Firestore, includere un campo nei documenti degli utenti che è possibile leggere, quindi strutturare la regola per leggere quel campo e concedere condizionalmente l'accesso. Nel database in tempo reale, creare un percorso dati che definisca gli utenti dell'app e conceda loro un ruolo in un nodo figlio.

È inoltre possibile impostare attestazioni personalizzate in Autenticazione e quindi recuperare tali informazioni dalla variabile auth.token in qualsiasi regola di sicurezza Firebase.

Attributi e ruoli definiti dai dati

Queste regole funzionano solo su Cloud Firestore e Realtime Database.

Cloud Firestore

Ricorda che ogni volta che le tue regole includono una lettura, come le regole seguenti, ti verrà addebitata un'operazione di lettura in 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"
   }
  }
}
 

Database in tempo reale

 {
  "rules": {
    "some_path": {
      "${subpath}": {
        //
        ".write": "root.child('users').child(auth.uid).child('role').val() == 'admin'",
        ".read": true
      }
    }
  }
}
 

Attributi e ruoli della rivendicazione personalizzata

Per implementare queste regole, imposta le attestazioni personalizzate nell'autenticazione Firebase e sfrutta le attestazioni nelle tue regole.

Cloud Firestore

Ricorda che ogni volta che le tue regole includono una lettura, come le regole seguenti, ti verrà addebitata un'operazione di lettura in Cloud Firestore.

 service cloud.firestore {
  match /databases/{database}/documents {
    // For attribute-based access control, check for an admin 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";
   }
  }
}
 

Database in tempo reale

 {
  "rules": {
    "some_path": {
      "$uid": {
        // Create a custom claim for each role or group
        // you want to leverage
        ".write": "auth.uid != null && auth.token.writer == true",
        ".read": "auth.uid != null && auth.token.reader == true"
      }
    }
  }
}
 

Conservazione

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