Questa pagina è stata tradotta dall'API Cloud Translation.

Gestisci ed esegui il deployment delle regole di sicurezza Firebase

Firebase offre diversi strumenti per gestire Rules, ciascuno una utile in casi particolari, e ognuna che usa lo stesso backend Firebase API di gestione delle regole di sicurezza.

Indipendentemente dallo strumento utilizzato per richiamarlo, l'API di gestione:

Importazione di un'origine di Regole: un insieme di regole, in genere un file di codice contenente Estratti conto Firebase Security Rules.
Archivia l'origine importata come set di regole immutabile.
Monitora il deployment di ogni set di regole in una release. Sicurezza di Firebase I servizi abilitati per le regole cercano la release di un progetto per valutare ogni richiesta per una risorsa protetta.
Offre la possibilità di eseguire test sintattici e semantici di un set di regole.

Utilizza l'interfaccia a riga di comando Firebase

Con l'interfaccia a riga di comando di Firebase, puoi: caricare origini locali ed eseguire il deployment delle release. L'interfaccia a riga di comando Firebase Local Emulator Suite consente di eseguire test locali completi delle origini.

L'utilizzo dell'interfaccia a riga di comando ti consente di mantenere il controllo della versione delle regole con codice dell'applicazione ed eseguire il deployment delle regole nell'ambito del processo di deployment esistente.

Genera un file di configurazione

Quando configuri il progetto Firebase utilizzando l'interfaccia a riga di comando Firebase, crei un file di configurazione .rules nella directory del progetto. Utilizza quanto segue per iniziare a configurare il tuo progetto Firebase:

Cloud Firestore

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

Realtime Database

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

Cloud Storage

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

Modificare e aggiornare le regole

Modifica l'origine delle regole direttamente nel file di configurazione .rules.

Assicurati che le modifiche apportate nell'interfaccia a riga di comando di Firebase siano riflesse nell'interfaccia Firebase o che effettui aggiornamenti costanti utilizzando Console Firebase o l'interfaccia a riga di comando di Firebase. In caso contrario, potresti sovrascrivere qualsiasi aggiornamenti apportati nella console Firebase.

Testa gli aggiornamenti

Local Emulator Suite fornisce emulatori per tutte le regole di sicurezza abilitate prodotti di big data e machine learning. Il motore delle regole di sicurezza per ogni emulatore esegue sia la valutazione sintattica sia quella semantica delle regole, superando così i test sintattici offerti dall'API di gestione delle regole di sicurezza.

Se stai utilizzando l'interfaccia a riga di comando, la suite è uno strumento eccellente per Firebase Security Rules test. Utilizza Local Emulator Suite per testare gli aggiornamenti a livello locale e verifica che Rules dell'app presenti il comportamento che desiderato.

Esegui il deployment degli aggiornamenti

Dopo aver aggiornato e testato Rules, esegui il deployment delle origini in e produzione.

Per Cloud Firestore Security Rules, associa i file .rules ai database denominati predefiniti e aggiuntivi esaminando e aggiornando il file firebase.json.

Usa i seguenti comandi per eseguire selettivamente il deployment di Rules da solo oppure come parte del normale processo di deployment.

Cloud Firestore

// Deploy rules for all databases configured in your firebase.json
firebase deploy --only firestore:rules

// Deploy rules for the specified database configured in your firebase.json
firebase deploy --only firestore:<databaseId>

Realtime Database

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

Cloud Storage

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

Utilizza la console Firebase

Puoi anche modificare Rules origini ed eseguirne il deployment come release da nella console Firebase. Il test sintattico viene eseguito mentre apporti modifiche nel L'interfaccia utente della console Firebase e i test semantici sono disponibili utilizzando Rules Playground.

Modificare e aggiornare le regole

Apri la console Firebase e seleziona il tuo progetto.
Quindi, seleziona Realtime Database, Cloud Firestore o Spazio di archiviazione da navigazione del prodotto, poi fai clic su Regole per accedere Editor Rules.
Modifica le regole direttamente nell'editor.

di Gemini Advanced.

Testa gli aggiornamenti

Oltre a testare la sintassi nell'interfaccia utente dell'editor, puoi testare la semantica Comportamento di Rules, usando il database e le risorse di archiviazione del tuo progetto, direttamente nella console Firebase, utilizzando Rules Playground. Apri il Playground regole schermata nell'editor di Rules, modifica le impostazioni e fai clic su Esegui. Cerca il messaggio di conferma nella parte superiore dell'editor.

Esegui il deployment degli aggiornamenti

Quando ritieni che gli aggiornamenti siano quelli previsti, fai clic su Pubblica.

Utilizzare l'SDK Admin

Puoi utilizzare Admin SDK per Node.js set di regole. Con questo accesso programmatico puoi:

Implementa strumenti, script, dashboard e pipeline CI/CD personalizzati per gestire le regole.
Gestisci più facilmente le regole in più progetti Firebase.

Quando aggiorni le regole in modo programmatico, è molto importante evitare di modifiche indesiderate al controllo dell'accesso per la tua app. Scrivi il tuo Admin SDK codice la sicurezza deve essere la priorità, soprattutto durante l'aggiornamento o il deployment delle regole.

Un'altra cosa importante da tenere a mente è che le release per Firebase Security Rules richiedono un di diversi minuti per propagarsi completamente. Quando utilizzi Admin SDK per eseguire il deployment assicurati di evitare condizioni di gara in cui la tua app fa immediatamente affidamento sulle regole il cui deployment non è ancora completato. Se il tuo caso d'uso richiede aggiornamenti frequenti alle regole di controllo dell'accesso, valuta le soluzioni che utilizzano Cloud Firestore, progettato per ridurre le condizioni di gara nonostante gli aggiornamenti frequenti.

Tieni inoltre presente questi limiti:

Quando sono serializzate, le regole devono contenere meno di 256 KiB di testo codificato UTF-8.
Un progetto può avere al massimo 2500 set di regole distribuiti. Una volta che questo limite Raggiunto, devi eliminare alcuni set di regole precedenti prima di crearne di nuovi.

Crea ed esegui il deployment di set di regole Cloud Storage o Cloud Firestore

Un tipico flusso di lavoro per la gestione delle regole di sicurezza con Admin SDK potrebbe includere tre passaggi distinti:

Crea un'origine del file di regole (facoltativo)
Crea un set di regole
Rilascia o esegui il deployment del nuovo set di regole

L'SDK fornisce un metodo per combinare questi passaggi in un'unica chiamata API per Cloud Storage e Cloud Firestore regole di sicurezza. Ad esempio:

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

Lo stesso pattern funziona per Cloud Storage regole con releaseFirestoreRulesetFromSource().

In alternativa, puoi creare il file delle regole come oggetto in memoria, creare e distribuire la serie separatamente per avere un controllo più attento di questi eventi. Ad esempio:

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

Aggiorna i set di regole Realtime Database

Per aggiornare i set di regole Realtime Database con Admin SDK, utilizza i getRules() e setRules() metodi di admin.database. Puoi recuperare i set di regole in formato JSON o come stringa con i commenti inclusi.

Per aggiornare un set di regole:

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

Gestisci set di regole

Per aiutarti a gestire insiemi di regole di grandi dimensioni, Admin SDK ti consente di elencare tutte le regole esistenti con admin.securityRules().listRulesetMetadata. Ad esempio:

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

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

Utilizzo dell'API REST

Gli strumenti descritti in precedenza sono adatti a vari flussi di lavoro, tra cui gestione di Firebase Security Rules per più database Cloud Firestore nel tuo progetto, ma potresti voler gestire ed eseguire il deployment di Firebase Security Rules utilizzando l'API di gestione stessa. L'API di gestione offre la massima flessibilità.

Tieni inoltre presente questi limiti:

Quando sono serializzate, le regole devono contenere meno di 256 KiB di testo codificato UTF-8.
Un progetto può avere al massimo 2500 set di regole distribuiti. Una volta raggiunto questo limite, devi eliminare alcuni vecchi set di regole prima di crearne di nuovi.

Creare ed eseguire il deployment di set di regole Cloud Firestore o Cloud Storage con REST

Gli esempi in questa sezione utilizzano Firestore Rules, anche se si applicano a Cloud Storage Rules.

Negli esempi viene utilizzato anche cURL per effettuare chiamate API. I passaggi per configurare e passare i token di autenticazione sono omessi. Puoi sperimentare con questa API utilizzando Explorer API integrato con documentazione di riferimento.

Di seguito sono riportati alcuni passaggi tipici per la creazione e il deployment di un set di regole utilizzando l'API di gestione:

Creare origini file delle regole
Creare un insieme di regole
Rilascia (esegui il deployment) del nuovo insieme di regole.

Crea un'origine

Supponiamo che tu stia lavorando al tuo progetto Firebase secure_commerce e che tu voglia per eseguire il deployment di Cloud Firestore Rules bloccato in un database progetto denominato east_store.

Puoi implementare queste regole in un file firestore.rules.

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

Crea un set di regole

Ora genera un'impronta con codifica base64 per questo file. Puoi quindi utilizzare il codice sorgente in questo file per compilare il payload necessario per creare un insieme di regole con la chiamata REST projects.rulesets.create. In questo caso, usa il comando cat per inserire i contenuti di firestore.rules nel payload REST.

Per il monitoraggio, per associarlo al tuo database east_store imposta attachment_point su east_store.

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

L'API restituisce una risposta di convalida e il nome del set di regole, ad esempio projects/secure_commerce/rulesets/uuid123.

Rilascia (deployment) un set di regole

Se il set di regole è valido, il passaggio finale consiste nell'eseguire il deployment della nuova serie di regole in un .

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

Tieni presente che il completamento delle release di Firebase Security Rules richiede diversi minuti propagarsi. Quando utilizzi l'API REST di gestione per il deployment, assicurati di evitare condizioni in cui l'app fa immediatamente affidamento su regole il cui deployment ancora completato.

Aggiorna i set di regole Realtime Database con REST

Realtime Database fornisce la propria interfaccia REST per la gestione di Rules. Consulta Gestione di Firebase Realtime Database Rules tramite REST.

Gestire i set di regole con REST

Per gestire il deployment di regole di grandi dimensioni, oltre a un metodo REST creando set di regole e release, l'API di gestione offre metodi per:

elencare, ottenere ed eliminare regole
elenca, recupera ed elimina le release delle regole

Per deployment molto grandi che raggiungono il limite di 2500 regole nel tempo, puoi creare una logica per eliminare le regole meno recenti in un ciclo di tempo fisso. Ad esempio, per eliminare tutti i set di regole di cui è stato eseguito il deployment per più di 30 giorni, puoi richiamare projects.rulesets.list, analizza l'elenco JSON degli oggetti Ruleset le chiavi createTime, quindi chiama project.rulesets.delete serie di regole corrispondenti per ruleset_id.

Testa gli aggiornamenti con REST

Infine, l'API di gestione consente di eseguire test sintattici e semantici Cloud Firestore e Cloud Storage risorse nella tua produzione in modo programmatico a gestire i progetti.

Il test con questo componente dell'API prevede:

Definizione di un oggetto JSON TestSuite per rappresentare un insieme di oggetti TestCase
Invio di TestSuite in corso...
L'analisi ha restituito TestResult oggetti

Definiamo un oggetto TestSuite con un singolo TestCase in un testcase.json file. In questo esempio, passiamo il valore Rules del linguaggio sorgente in linea con il payload REST, insieme alla suite di test da eseguire in base a queste regole. Specifichiamo un'aspettativa di valutazione delle regole e il client richiesta in base alla quale testare il set di regole. Puoi anche specificare come completare il report del test utilizzando il valore "FULL" per indicare i risultati per tutti Rules espressioni linguistiche devono essere incluse nel report, tra cui espressioni che non corrispondono alla richiesta.

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

Possiamo quindi inviare questo TestSuite per la valutazione con il metodo projects.test.

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

Il valore TestReport restituito (contenente lo stato SUCCESS/FAILED del test, elenchi di messaggi di debug, elenchi di espressioni di regole visitate e relativi report di valutazione) con lo stato SUCCESS che l'accesso è consentito correttamente.

Gestisci le autorizzazioni per Cloud Storage Security Rules tra servizi

Se crei elementi Cloud Storage Security Rules che utilizzano Cloud Firestore contenuti dei documenti per valutare le condizioni di sicurezza, ti verrà chiesto nella console Firebase o nell'interfaccia a riga di comando Firebase per abilitare autorizzazioni necessarie per collegare i due prodotti.

Se decidi di disattivare questa sicurezza tra servizi:

In primo luogo, prima di disattivare la funzione, modifica le regole, rimuovendo tutte istruzioni che utilizzano le funzioni Rules per accedere a Cloud Firestore. In caso contrario, dopo la disattivazione della funzionalità, le valutazioni di Rules verranno che causano l'esito negativo delle richieste.
Utilizza la pagina IAM della console Google Cloud per eliminare il ruolo "Agente di servizio Firestore di Firebase Rules" seguendo la guida di Cloud per la revoca dei ruoli.

Nota: nella pagina IAM, seleziona la casella "Includi ruolo fornito da Google" donazioni" per visualizzare tutti i ruoli.
Nota: nella pagina IAM dovresti trovare il servizio Firebase Storage con ID che termina con @gcp-sa-firebasestorage.iam.gserviceaccount.com. Se le regole per più servizi sono abilitate, vedrai l'agente di servizio Firestore delle regole Firebase ruolo dall'elenco.

Ti verrà chiesto di riattivare la funzionalità la volta successiva che salvi regole per più servizi dall'interfaccia a riga di comando Firebase o dalla console Firebase.