Configura e gestisci progetti e prodotti Firebase tramite Terraform

1. Introduzione

Obiettivi

Puoi utilizzare Terraform per impostare e gestire un progetto Firebase, inclusa la configurazione programmatica dell'infrastruttura e dei prodotti Firebase.

Questo codelab descrive innanzitutto come creare un file di configurazione Terraform per creare un nuovo progetto Firebase, seguito da come configurare le app e i prodotti Firebase che desideri utilizzare in quel progetto. Copriremo anche le nozioni di base della riga di comando Terraform, come visualizzare in anteprima le modifiche da apportare e quindi implementarle.

Se desideri imparare come configurare e gestire progetti e prodotti Firebase con Terraform, allora questo codelab fa al caso tuo!

Cosa imparerai

• Come creare un file di configurazione Terraform ( *.tf )
• Come utilizzare i comandi CLI Terraform per gestire la tua infrastruttura
• Come modificare la configurazione per aggiornare le risorse e i servizi
• Come applicare la tua configurazione su una vera web app (chiamata Friendly Chat )
• Come definire configurazioni parallele (e sincronizzate) in diversi ambienti (produzione, staging, ecc.)

Di cosa avrai bisogno

• Un terminale/console
• L'IDE/editor di testo di tua scelta, come WebStorm , Atom , Sublime o VS Code
• Il browser di tua scelta, ad esempio Chrome
• La CLI di Google Cloud (CLI di gCloud): installa questa CLI e accedi utilizzando un account utente o un account di servizio

Per avere successo con questo codelab, è necessaria una conoscenza di base di Terraform e della sua terminologia, inclusi i seguenti prerequisiti:

• Installa Terraform e acquisisci familiarità con Terraform utilizzando i tutorial ufficiali

Questo codelab fornisce un'app di esempio reale che ti consente di testare e interagire con ciò di cui esegui il provisioning tramite Terraform. Per fare ciò, avrai bisogno di quanto segue:

• Il codice di esempio per un'app Web: scarica questo codice nel passaggio successivo del codelab
• Il gestore pacchetti npm (che in genere viene fornito con Node.js ): installa questi strumenti
• La CLI Firebase : installa questa CLI e accedi

2. Ottieni il codice iniziale

In questo codelab puoi testare ciò che fornisci tramite Terraform con una vera app Web. Ti consigliamo di farlo in modo da comprendere tutti i passaggi necessari per utilizzare le risorse fornite da Terraform.

Clona il repository GitHub del codelab dalla riga di comando:

git clone https://github.com/firebase/codelab-friendlychat-web

In alternativa, se non hai git installato, puoi scaricare il repository come file ZIP .

3. Crea una configurazione Terraform

Configurazione di Terraform

1. Nella codebase dell'app di esempio scaricata, vai alla radice della directory web .
2. Alla radice di quella directory, crea un file di configurazione Terraform chiamato main.tf con la seguente configurazione iniziale:
   
   main.tf

   # Terraform configuration to set up providers by version.
   terraform {
     required_providers {
       google-beta = {
         source  = "hashicorp/google-beta"
         version = "~> 4.0"
       }
     }
   }
   
   # Configure the provider not to use the specified project for quota check.
   # This provider should only be used during project creation and initializing services.
   provider "google-beta" {
     alias                 = "no_user_project_override"
     user_project_override = false
   }
   
   # Configure the provider that uses the new project's quota.
   provider "google-beta" {
     user_project_override = true
   }
   

Ciascuno dei provider google-beta ha un attributo denominato user_project_override che determina il modo in cui verrà controllata la quota delle operazioni da Terraform. Per il provisioning della maggior parte delle risorse, dovresti utilizzare user_project_override = true , il che significa verificare la quota rispetto al tuo progetto Firebase. Tuttavia, per configurare il tuo nuovo progetto in modo che possa accettare i controlli delle quote, devi prima utilizzare user_project_override=false . La sintassi alias Terraform ti consente di distinguere tra le due configurazioni del provider nei passaggi successivi di questo codelab.

Inizializza Terraform nella directory

La creazione di una nuova configurazione per la prima volta richiede il download del provider specificato nella configurazione.

Per eseguire questa inizializzazione, esegui il comando seguente dalla radice della stessa directory del file di configurazione main.tf :

terraform init

4. Crea un progetto Firebase tramite Terraform

Per "creare un progetto Firebase", è importante ricordare che ogni progetto Firebase è in realtà un progetto Google Cloud, solo con i servizi Firebase abilitati.

Aggiungi blocchi per il progetto Google Cloud e le API sottostanti

1. Innanzitutto, esegui il provisioning del progetto Google Cloud sottostante.
   
   Al tuo file di configurazione main.tf , aggiungi il seguente blocco di risorse.
   
   Devi specificare il nome del tuo progetto (come "Terraform FriendlyChat Codelab" ) e il tuo ID progetto (come "terraform-codelab-your-initials" ). Tieni presente che il valore name viene utilizzato solo nelle interfacce Firebase e non è visibile agli utenti finali. Il valore project_id , tuttavia, identifica in modo univoco il tuo progetto su Google, quindi assicurati di specificare un valore univoco. main.tf

   ...
   
   # Create a new Google Cloud project.
   resource "google_project" "default" {
     provider = google-beta.no_user_project_override
   
     name            = "<PROJECT_NAME_OF_YOUR_PROJECT>"
     project_id      = "<PROJECT_ID_OF_YOUR_PROJECT>"
   
     # Required for the project to display in any list of Firebase projects.
     labels = {
       "firebase" = "enabled"
     }
   }
   

2. Successivamente, devi abilitare le API sottostanti richieste: l'API Service Usage e l'API Firebase Management.
   
   Questa abilitazione dell'API viene solitamente gestita dietro le quinte quando utilizzi la console Firebase per creare un progetto Firebase, ma è necessario che Terraform venga esplicitamente informato di eseguire questa abilitazione.
   
   Al tuo file di configurazione main.tf (appena sotto il blocco che crea il nuovo progetto Cloud), aggiungi il seguente blocco di risorse:
   
   main.tf

   ...
   
   # Enable the required underlying Service Usage API.
   resource "google_project_service" "serviceusage" {
     provider = google-beta.no_user_project_override
   
     project = google_project.default.project_id
     service = "serviceusage.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Enable the required underlying Firebase Management API.
   resource "google_project_service" "firebase" {
     provider = google-beta.no_user_project_override
   
     project = google_project.default.project_id
     service = "firebase.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   

   Abilitando l'API Service Usage, il tuo nuovo progetto sarà in grado di accettare controlli di quota! Pertanto, per tutti i successivi provisioning delle risorse e abilitazione dei servizi, è necessario utilizzare il provider con user_project_override (non è necessario alcun alias).

Aggiungi un blocco per abilitare i servizi Firebase

L'ultima cosa necessaria per "creare un progetto Firebase" è abilitare i servizi Firebase sul progetto.

Continuando nel file di configurazione main.tf , aggiungi il seguente blocco di risorse.

Come accennato in precedenza, tieni presente che questo blocco di risorse utilizza il provider con user_project_override (non è necessario alcun alias).

main.tf

...

# Enable Firebase services for the new project created above.
resource "google_firebase_project" "default" {
  provider = google-beta

  project = google_project.default.project_id

  # Wait until the required APIs are enabled.
  depends_on = [
    google_project_service.firebase,
    google_project_service.serviceusage,
  ]
}

Nel blocco di risorse sopra, potresti notare la clausola depends_on , che indica a Terraform di attendere l'abilitazione delle API sottostanti. Senza questa clausola, Terraform non è a conoscenza della dipendenza e potrebbe riscontrare errori durante il provisioning delle risorse in parallelo.

Applicare la configurazione

1. Per eseguire il provisioning delle nuove risorse e abilitare le API specificate nel file di configurazione, esegui il comando seguente dalla radice della stessa directory del file main.tf (che dovrebbe essere web ):

   terraform apply
   

2. Nel terminale, Terraform stampa un piano di azioni che eseguirà.
   
   Se tutto sembra come previsto, approva le azioni inserendo yes .
   
   main.tf

   Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
     + create
   
   Terraform will perform the following actions:
   
     # google_firebase_project.default will be created
     + resource "google_firebase_project" "default" {
         + display_name   = (known after apply)
         + id             = (known after apply)
         + project        = "terraform-friendlychat-codelab"
         + project_number = (known after apply)
       }
   
     # google_project.default will be created
     + resource "google_project" "default" {
         + auto_create_network = true
         + id                  = (known after apply)
         + labels              = {
             + "firebase" = "enabled"
           }
         + name                = "Terraform FriendlyChat Codelab"
         + number              = (known after apply)
         + project_id          = "terraform-friendlychat-codelab"
         + skip_delete         = (known after apply)
       }
   
     # google_project_service.firebase will be created
     + resource "google_project_service" "firebase" {
         + disable_on_destroy = false
         + id                 = (known after apply)
         + project            = "terraform-friendlychat-codelab"
         + service            = "firebase.googleapis.com"
       }
   
     # google_project_service.serviceusage will be created
     + resource "google_project_service" "serviceusage" {
         + disable_on_destroy = false
         + id                 = (known after apply)
         + project            = "terraform-friendlychat-codelab"
         + service            = "serviceusage.googleapis.com"
       }
   
   Plan: 4 to add, 0 to change, 0 to destroy.
   
   Do you want to perform these actions?
     Terraform will perform the actions described above.
     Only 'yes' will be accepted to approve.
   
     Enter a value: yes # <----
   

Tieni presente che se hai solo bisogno di visualizzare in anteprima le modifiche senza applicarle, puoi invece utilizzare il comando terraform plan .

Convalidare le modifiche

Al termine dell'esecuzione di Terraform, puoi controllare lo stato di tutte le risorse e i servizi forniti da Terraform abilitati eseguendo il comando seguente:

terraform show

Ecco un esempio di ciò che dovresti vedere stampato. Il tuo stato conterrà valori specifici per il tuo progetto.

# google_firebase_project.default:
resource "google_firebase_project" "default" {
    display_name   = "Terraform FriendlyChat Codelab"
    id             = "projects/terraform-friendlychat-codelab"
    project        = "terraform-friendlychat-codelab"
    project_number = "000000000"
}

# google_project.default:
resource "google_project" "default" {
    auto_create_network = true
    id                  = "projects/terraform-friendlychat-codelab"
    labels              = {
        "firebase" = "enabled"
    }
    name                = "Terraform FriendlyChat Codelab"
    number              = "000000000"
    project_id          = "terraform-friendlychat-codelab"
}

# google_project_service.firebase:
resource "google_project_service" "firebase" {
    disable_on_destroy = false
    id                 = "terraform-friendlychat-codelab/firebase.googleapis.com"
    project            = "terraform-friendlychat-codelab"
    service            = "firebase.googleapis.com"
}

# google_project_service.serviceusage:
resource "google_project_service" "serviceusage" {
    disable_on_destroy = false
    id                 = "terraform-friendlychat-codelab/serviceusage.googleapis.com"
    project            = "terraform-friendlychat-codelab"
    service            = "serviceusage.googleapis.com"
}

In alternativa, puoi verificare che il progetto sia stato creato visualizzandolo nella console Firebase .

5. Registra la tua app Firebase tramite Terraform

Per utilizzare Firebase, devi registrare ciascuna variante della piattaforma della tua app nel tuo progetto Firebase. In questo codelab utilizzerai un'app reale per testare e interagire con ciò che fornisci tramite Terraform. Questa app è un'app Web, quindi devi indicare a Terraform di registrare un'app Web Firebase nel progetto Firebase appena creato.

Aggiungi un blocco per registrare l'app Web

Per registrare la tua app Web nel tuo progetto Firebase, aggiungi il file main.tf con il seguente blocco di risorse.

Devi specificare il tuo display_name per la tua app Web. Tieni presente che questo nome viene utilizzato solo nelle interfacce Firebase e non è visibile agli utenti finali.

main.tf

...

# Create a Firebase Web App in the new project created above.
resource "google_firebase_web_app" "default" {
  provider = google-beta

  project      = google_firebase_project.default.project
  display_name = "<DISPLAY_NAME_OF_YOUR_WEB_APP>"
  deletion_policy = "DELETE"
}

Applicare la configurazione

1. Per eseguire il provisioning della nuova risorsa, esegui il comando seguente dalla radice della stessa directory del file main.tf (che dovrebbe essere web ).

   terraform apply
   

   Tieni presente che questo comando non ricreerà un nuovo progetto Google Cloud. Terraform rileverà che esiste già un progetto con l'ID progetto specificato e confronterà lo stato corrente del progetto con il contenuto del file .tf e apporterà le eventuali modifiche trovate.
2. Esaminare il piano d'azione stampato. Se tutto sembra come previsto, digita yes e premi Invio per approvare le azioni.

Convalidare le modifiche

Puoi controllare lo stato della risorsa appena fornita eseguendo il comando seguente:

terraform show

In alternativa, puoi verificare che l'app sia stata registrata correttamente nel tuo progetto visualizzandola nella console Firebase. Vai a Impostazioni progetto e scorri verso il basso fino alla sezione Le tue app .

6. Configura l'autenticazione Firebase

L'autenticazione è una parte importante di qualsiasi app. Per consentire agli utenti finali di accedere alla tua app Web con i propri account Google, puoi abilitare l'autenticazione Firebase e configurare il metodo di accesso con Google.

Tieni presente che in questo codelab forniamo due diverse opzioni per impostare l'autenticazione Firebase:

• Opzione 1 (consigliata) : configura l'autenticazione Firebase nella console, che non richiede GCIP.
  • L'utilizzo di questa opzione significa che non è necessario associare il nuovo progetto a un account di fatturazione Cloud.
• Opzione 2 : configura l'autenticazione Firebase tramite Terraform utilizzando le API Google Cloud Identity Platform (GCIP).
  • L'utilizzo di questa opzione significa che devi associare il tuo nuovo progetto a un account di fatturazione Cloud poiché GCIP richiede che il progetto sia incluso nel piano tariffario Blaze.

Opzione 1: configura l'autenticazione utilizzando la console Firebase

Per configurare l'autenticazione Firebase utilizzando la console Firebase, non è necessario che il tuo progetto sia incluso nel piano tariffario Blaze.

Ecco come configurare l'autenticazione Firebase e accedere con Google:

1. Nella console Firebase , individua la sezione Build nel pannello di sinistra.
2. Fare clic su Autenticazione , fare clic su Inizia , quindi fare clic sulla scheda Metodo di accesso (o fare clic qui per andare direttamente lì).
3. Fai clic su Aggiungi nuovo fornitore e, dalla sezione Fornitori aggiuntivi , seleziona Google .
4. Attiva l'interruttore Abilita .
5. Imposta il nome pubblico della tua app su qualcosa come FriendlyChat (non è necessario che sia univoco a livello globale).
6. Scegli un'e-mail di supporto per il progetto dal menu a discesa, quindi fai clic su Salva .
7. Dovresti vedere Google come fornitore di accesso abilitato.

Opzione 2: configura l'autenticazione tramite Terraform utilizzando le API Google Cloud Identity Platform (GCIP).

Per configurare l'autenticazione Firebase tramite Terraform, devi utilizzare le API GCIP, il che significa che il progetto deve rientrare nel piano tariffario Blaze. Puoi aggiornare il tuo progetto Firebase per utilizzare il piano Blaze associando un account di fatturazione Cloud al progetto.

Abilita la fatturazione tramite Terraform

1. Se non disponi già di un account di fatturazione Cloud, il primo passaggio è creare un nuovo account in Google Cloud Console . In tal caso, prendi nota dell'ID dell'account di fatturazione . L'ID account di fatturazione si trova nella pagina Fatturazione nell'ID account di fatturazione associato al tuo progetto.
2. Per abilitare la fatturazione nel tuo progetto tramite Terraform, aggiungi un attributo billing_account nella risorsa google_project esistente nel tuo file main.tf :
   
   main.tf

   ...
   
   # Create a new Google Cloud project.
   resource "google_project" "default" {
     provider = google-beta.no_user_project_override
   
     name            = "<PROJECT_NAME_OF_YOUR_PROJECT>"
     project_id      = "<PROJECT_ID_OF_YOUR_PROJECT>"
     billing_account = "<YOUR_BILLING_ACCOUNT_ID>" # Add this line with your Cloud Billing account ID
   
     # Required for the project to display in any list of Firebase projects.
     labels = {
       "firebase" = "enabled"
     }
   }
   
   ...
   

Abilita l'autenticazione Firebase e accedi con Google tramite Terraform

1. Per eseguire il provisioning dell'autenticazione Firebase con GCIP, aggiungi il file main.tf con i seguenti blocchi di risorse:
   
   main.tf

   ...
   
   # Enable the Identity Toolkit API.
   resource "google_project_service" "auth" {
     provider = google-beta
   
     project  = google_firebase_project.default.project
     service =  "identitytoolkit.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Create an Identity Platform config.
   # Also, enable Firebase Authentication using Identity Platform (if Authentication isn't yet enabled).
   resource "google_identity_platform_config" "auth" {
     provider = google-beta
     project  = google_firebase_project.default.project
   
     # For example, you can configure to auto-delete anonymous users.
     autodelete_anonymous_users = true
   
     # Wait for identitytoolkit.googleapis.com to be enabled before initializing Authentication.
     depends_on = [
       google_project_service.auth,
     ]
   }
   

2. Per abilitare l'accesso con Google è necessario disporre di un client OAuth . Vai alla sezione API e servizi di Google Cloud Console per eseguire questa configurazione.
3. Poiché è la prima volta che crei un ID cliente per questo progetto, devi configurare la schermata di consenso OAuth.
   1. Apri la schermata di consenso OAuth e quindi seleziona il progetto appena creato.
   2. Impostare Tipo utente su Esterno , quindi fare clic su Crea .
   3. Nella schermata successiva, completa le seguenti operazioni, quindi fai clic su Salva e continua .
      • Imposta il nome dell'app rivolta al pubblico su qualcosa come FriendlyChat (non è necessario che sia univoco a livello globale).
      • Scegli un'e-mail di supporto utente dal menu a discesa.
      • Inserisci un indirizzo email per le informazioni di contatto dello sviluppatore .
   4. Nelle schermate successive, completare quanto segue:
      • Accettare le impostazioni predefinite nella pagina Ambiti , quindi fare clic su Salva e continua .
      • Accettare le impostazioni predefinite nella pagina Utenti di prova , quindi fare clic su Salva e continua .
      • Esamina il riepilogo, quindi fai clic su Torna alla dashboard .
      
4. Configura un client OAuth nella pagina Credenziali effettuando le seguenti operazioni:
   1. Fai clic su Crea credenziali e seleziona ID client OAuth .
   2. Dal menu a discesa Tipo di applicazione , seleziona Applicazione Web .
   3. Nel campo Nome , inserisci il nome della tua app, ad esempio FriendlyChat (non è necessario che sia univoco a livello globale).
   4. Consenti all'URL della tua app di utilizzare questo client OAuth impostando quanto segue:
      • In Origini JavaScript autorizzate , fai clic su Aggiungi URI e inserisci
        https://<PROJECT_ID>.firebaseapp.com , dove <PROJECT_ID> è l'ID progetto impostato in main.tf .
      • In URI di reindirizzamento autorizzati , fai clic su Aggiungi URI e inserisci
        https://<PROJECT_ID>.firebaseapp.com/__/auth/handler , dove <PROJECT_ID> è l'ID progetto impostato in main.tf .
   5. Fare clic su Salva .
   
5. Per abilitare l'accesso con Google utilizzando l'ID client OAuth e il segreto client, aggiungi il file main.tf con il seguente blocco:
   
   main.tf

   ...
   
   variable "oauth_client_secret" {
     type = string
   
     description = "OAuth client secret. For this codelab, you can pass in this secret through the environment variable TF_VAR_oauth_client_secret. In a real app, you should use a secret manager service."
   
     sensitive = true
   }
   
   resource "google_identity_platform_default_supported_idp_config" "google_sign_in" {
     provider = google-beta
     project  = google_firebase_project.default.project
   
     enabled       = true
     idp_id        = "google.com"
     client_id     = "<YOUR_OAUTH_CLIENT_ID>"
     client_secret = var.oauth_client_secret
   
     depends_on = [
        google_identity_platform_config.auth
     ]
   }
   

Applicare la configurazione

1. Per impostare l'autenticazione in base alla tua configurazione, esegui i seguenti comandi dalla radice della stessa directory del file main.tf (che dovrebbe essere web ):

   export TF_VAR_oauth_client_secret="<YOUR_OAUTH_CLIENT_SECRET>"
   

   terraform apply
   

   Tieni presente che l'esecuzione terraform apply non ricreerà un nuovo progetto Google Cloud. Terraform rileverà che esiste già un progetto con l'ID progetto specificato e confronterà lo stato corrente del progetto con il contenuto del file .tf . Quindi apporterà tutte le modifiche trovate.
2. Esaminare il piano d'azione stampato. Se tutto sembra come previsto, digita yes e premi Invio per approvare le azioni.

Convalidare le modifiche

1. Nella console Firebase , individua la sezione Build nel pannello di sinistra.
2. Fare clic su Autenticazione , quindi sulla scheda Metodo di accesso (o fare clic qui per andare direttamente lì).
3. Dovresti vedere Google come fornitore di accesso abilitato.

7. Configura un database Firestore e le sue regole di sicurezza

Per l'app Web di questo codelab, memorizzerai i messaggi tra gli utenti finali in un database Firestore.

1. Per abilitare le API richieste ed eseguire il provisioning dell'istanza del database, aggiungi il file main.tf con i seguenti blocchi di risorse:
   
   main.tf

   ...
   
   # Enable required APIs for Cloud Firestore.
   resource "google_project_service" "firestore" {
     provider = google-beta
   
     project  = google_firebase_project.default.project
     for_each = toset([
       "firestore.googleapis.com",
       "firebaserules.googleapis.com",
     ])
     service = each.key
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Provision the Firestore database instance.
   resource "google_firestore_database" "default" {
     provider                    = google-beta
   
     project                     = google_firebase_project.default.project
     name                        = "(default)"
     # See available locations:
     # https://firebase.google.com/docs/firestore/locations
     location_id                 = "<NAME_OF_DESIRED_REGION>"
     # "FIRESTORE_NATIVE" is required to use Firestore with Firebase SDKs,
     # authentication, and Firebase Security Rules.
     type                        = "FIRESTORE_NATIVE"
     concurrency_mode            = "OPTIMISTIC"
   
     depends_on = [
       google_project_service.firestore
     ]
   }
   

2. Cambia <NAME_OF_DESIRED_REGION> nella regione in cui desideri che risieda il database.
   
   Quando sviluppi un'app di produzione, ti consigliamo di trovarla in un'area vicina alla maggior parte degli utenti e in comune con altri servizi Firebase, come Cloud Functions. Per questo codelab, puoi utilizzare us-east1 (Carolina del Sud) o la regione più vicina a te (vedi Posizioni Cloud Firestore ).
3. Ogni istanza del database Firestore accessibile a Firebase deve essere protetta dalle regole di sicurezza Firebase .
   
   Il codice di esempio di questo codelab fornisce una serie di regole Firestore sicure nel file firestore.rules , che puoi trovare nella radice della directory web .
4. Aggiungi il tuo file main.tf con i seguenti blocchi di risorse per effettuare le seguenti operazioni:
   • Crea un set di regole di sicurezza Firebase dal file firestore.rules locale.
   • Rilascia il set di regole per l'istanza Firestore.
   Tieni presente che questi blocchi di risorse equivalgono a fare clic sul pulsante Pubblica nella console Firebase o eseguire firebase deploy --only firestore:rules .
   
   main.tf

   ...
   
   # Create a ruleset of Firestore Security Rules from a local file.
   resource "google_firebaserules_ruleset" "firestore" {
     provider = google-beta
   
     project  = google_firebase_project.default.project
     source {
       files {
         name = "firestore.rules"
         # Write security rules in a local file named "firestore.rules".
         # Learn more: https://firebase.google.com/docs/firestore/security/get-started
         content = file("firestore.rules")
       }
     }
   
     # Wait for Firestore to be provisioned before creating this ruleset.
     depends_on = [
       google_firestore_database.default,
     ]
   }
   
   # Release the ruleset for the Firestore instance.
   resource "google_firebaserules_release" "firestore" {
     provider     = google-beta
   
     name         = "cloud.firestore"  # must be cloud.firestore
     ruleset_name = google_firebaserules_ruleset.firestore.name
     project      = google_firebase_project.default.project
   
     # Wait for Firestore to be provisioned before releasing the ruleset.
     depends_on = [
       google_firestore_database.default,
     ]
   
     lifecycle {
       replace_triggered_by = [
         google_firebaserules_ruleset.firestore
       ]
     }
   }
   

5. Esegui terraform apply per effettuare il provisioning del database Firestore e distribuirne le regole di sicurezza.
6. Verifica che sia stato eseguito il provisioning del database e che le relative regole di sicurezza siano distribuite:
   1. Nella console Firebase , individua la sezione Build nel pannello di sinistra.
   2. Vai alla sezione Database Firestore , quindi fai clic sulla scheda Regole .
   

8. Configura un bucket Cloud Storage e le relative regole di sicurezza

Per l'app Web di questo codelab, archivierai le immagini condivise tra gli utenti finali in un bucket Cloud Storage.

1. Per abilitare le API richieste ed eseguire il provisioning del bucket predefinito Cloud Storage, aggiungi il file main.tf con i seguenti blocchi di risorse.
   
   Tieni presente che il provisioning del bucket Cloud Storage predefinito per il tuo progetto viene effettuato tramite Google App Engine e deve avere la stessa posizione del database Firestore. Per ulteriori informazioni, consulta Posizioni di App Engine .
   
   Se desideri più bucket nel tuo progetto, eseguine il provisioning utilizzando la risorsa google_storage_bucket (non mostrata in questo codelab).
   
   main.tf

   ...
   
   # Enable required APIs for Cloud Storage for Firebase.
   resource "google_project_service" "storage" {
     provider = google-beta
   
     project  = google_firebase_project.default.project
     for_each = toset([
       "firebasestorage.googleapis.com",
       "storage.googleapis.com",
     ])
     service = each.key
   
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Provision the default Cloud Storage bucket for the project via Google App Engine.
   resource "google_app_engine_application" "default" {
     provider    = google-beta
   
     project     = google_firebase_project.default.project
     # See available locations: https://firebase.google.com/docs/projects/locations#default-cloud-location
     # This will set the location for the default Storage bucket and the App Engine App.
     location_id = "<NAME_OF_DESIRED_REGION_FOR_DEFAULT_BUCKET>"  # Must be in the same location as Firestore (above)
   
     # Wait until Firestore is provisioned first.
     depends_on = [
       google_firestore_database.default
     ]
   }
   
   # Make the default Storage bucket accessible for Firebase SDKs, authentication, and Firebase Security Rules.
   resource "google_firebase_storage_bucket" "default-bucket" {
     provider  = google-beta
   
     project   = google_firebase_project.default.project
     bucket_id = google_app_engine_application.default.default_bucket
   }
   

2. Ogni bucket Cloud Storage accessibile a Firebase deve essere protetto dalle regole di sicurezza Firebase .
   
   Il codice di esempio di questo codelab fornisce una serie di regole Firestore sicure nel file storage.rules , che puoi trovare nella radice della directory web .
3. Aggiungi il tuo file main.tf con i seguenti blocchi di risorse per effettuare le seguenti operazioni:
   • Crea un set di regole di sicurezza Firebase dal file locale.
   • Rilascia il set di regole per il bucket di archiviazione.
   Tieni presente che questi blocchi di risorse equivalgono a fare clic sul pulsante Pubblica nella console Firebase o a eseguire firebase deploy --only storage .
   
   main.tf

   ...
   
   # Create a ruleset of Cloud Storage Security Rules from a local file.
   resource "google_firebaserules_ruleset" "storage" {
     provider = google-beta
   
     project  = google_firebase_project.default.project
     source {
       files {
         # Write security rules in a local file named "storage.rules".
         # Learn more: https://firebase.google.com/docs/storage/security/get-started
         name    = "storage.rules"
         content = file("storage.rules")
       }
     }
   
     # Wait for the default Storage bucket to be provisioned before creating this ruleset.
     depends_on = [
       google_firebase_storage_bucket.default-bucket,
     ]
   }
   
   # Release the ruleset to the default Storage bucket.
   resource "google_firebaserules_release" "default-bucket" {
     provider     = google-beta
   
     name         = "firebase.storage/${google_app_engine_application.default.default_bucket}"
     ruleset_name = "projects/${google_firebase_project.default.project}/rulesets/${google_firebaserules_ruleset.storage.name}"
     project      = google_firebase_project.default.project
   
     lifecycle {
       replace_triggered_by = [
         google_firebaserules_ruleset.storage
       ]
     }
   }
   

4. Esegui terraform apply per eseguire il provisioning del bucket Cloud Storage predefinito e distribuirne le regole di sicurezza.
5. Verifica che sia stato eseguito il provisioning del bucket e che le relative regole di sicurezza siano distribuite:
   1. Nella console Firebase , individua la sezione Build nel pannello di sinistra.
   2. Vai alla sezione Archiviazione , quindi fai clic sulla scheda Regole .
   

9. Esegui la tua app localmente

Ora sei pronto per eseguire la tua app Web per la prima volta! Utilizzerai l' emulatore Firebase Hosting per servire la tua app localmente.

1. Apri una nuova finestra di terminale e, dalla directory web , esegui il seguente comando CLI di Firebase per avviare l'emulatore:

   firebase emulators:start --project=<PROJECT_ID>
   

2. Nel browser, apri l'app Web nell'URL locale restituito dalla CLI (in genere http://localhost:5000 ).

Dovresti vedere l'interfaccia utente dell'app FriendlyChat, che non funziona (ancora!) L'app non è ancora connessa a Firebase, ma completando i passaggi successivi di questo codelab lo sarà!

Tieni presente che ogni volta che apporti modifiche alla tua app Web (come farai nei passaggi seguenti di questo codelab), aggiorna il browser per aggiornare l'URL locale con tali modifiche.

10. Installa, configura e inizializza Firebase

Per far funzionare un'app con Firebase, la tua app necessita dell'SDK Firebase e della configurazione Firebase per il tuo progetto Firebase.

Il codice di esempio per questo codelab è già un'app funzionante con tutte le dipendenze e le funzioni richieste per l'utilizzo di vari prodotti Firebase nell'app. Puoi cercare in web/package.json e web/src/index.js se desideri vedere cosa è già stato fatto.

Anche se il codice di esempio è quasi completo, devi comunque fare alcune cose per far funzionare la tua app, tra cui: installare l'SDK Firebase, avviare la build, aggiungere la configurazione Firebase alla tua app e infine inizializzare Firebase.

Installa l'SDK Firebase e avvia la creazione del tuo pacchetto web

Devi eseguire alcuni comandi per avviare la compilazione della tua app.

1. Apri una nuova finestra di terminale.
2. Assicurati di essere nella radice della directory web .
3. Esegui npm install per scaricare l'SDK Firebase.
4. Esegui npm update per aggiornare eventuali dipendenze.
5. Esegui npm run start per avviare il webpack.

Per il resto del codelab, webpack ora ricostruirà continuamente il tuo codice sorgente.

Aggiungi la configurazione Firebase alla tua app

Devi anche aggiungere la configurazione Firebase alla tua app in modo che gli SDK Firebase sappiano quale progetto Firebase desideri che utilizzino.

Per questo codelab hai due diverse opzioni per ottenere la configurazione di Firebase:

• Opzione 1 : ottieni la configurazione di Firebase dalla console Firebase.
• Opzione 2 : ottieni la configurazione di Firebase tramite Terraform.

Opzione 1: ottieni la configurazione dalla console Firebase e aggiungila alla tua codebase

1. Nella console Firebase, vai alle Impostazioni progetto .
2. Scorri verso il basso fino alla scheda Le tue app , quindi seleziona la tua app Web.
3. Seleziona Config dal riquadro dello snippet dell'SDK Firebase, quindi copia lo snippet di configurazione.
4. Incolla la tua configurazione nel file web/src/firebase-config.js della tua app, in questo modo:
   
   firebase-config.js

   ...
   
   const config = {
     apiKey: "<API_KEY>",
     authDomain: "<PROJECT_ID>.firebaseapp.com",
     projectId: "<PROJECT_ID>",
     storageBucket: "<PROJECT_ID>.appspot.com",
     messagingSenderId: "<SENDER_ID>",
     appId: "<APP_ID>",
     measurementId: "<G-MEASUREMENT_ID>",
   };
   
   ...
   

Opzione 2: ottieni la configurazione tramite Terraform e aggiungila alla tua codebase

In alternativa, puoi ottenere la configurazione Firebase tramite Terraform come valore di output nella CLI.

1. Nel file main.tf , trova il blocco di risorse google_firebase_web_app (il blocco che ha registrato un'app Web con il tuo progetto).
2. Immediatamente dopo quel blocco, aggiungi i seguenti blocchi:
   
   main.tf

   ...
   
   data "google_firebase_web_app_config" "default" {
     provider     = google-beta
     project      = google_firebase_project.default.project
     web_app_id   = google_firebase_web_app.default.app_id
   }
   
   output "friendlychat_web_app_config" {
     value = {
       projectId         = google_firebase_project.default.project
       appId             = google_firebase_web_app.default.app_id
       apiKey            = data.google_firebase_web_app_config.default.api_key
       authDomain        = data.google_firebase_web_app_config.default.auth_domain
       storageBucket     = lookup(data.google_firebase_web_app_config.default, "storage_bucket", "")
       messagingSenderId = lookup(data.google_firebase_web_app_config.default, "messaging_sender_id", "")
       measurementId     = lookup(data.google_firebase_web_app_config.default, "measurement_id", "")
     }
   }
   
   ...
   

3. Poiché il blocco data e il blocco output non sono destinati a modificare in alcun modo l'infrastruttura, è sufficiente eseguire solo i seguenti comandi.
   1. Per caricare la configurazione Firebase della tua app Web nello stato Terraform della directory, esegui questo comando:

      terraform refresh
      

   2. Per stampare i valori di configurazione di Firebase, esegui questo comando:

      terraform output –json
      

      Di seguito è riportato un esempio di output di un file config. L'output stampato conterrà i valori del progetto e dell'app.

      {
        "friendlychat_web_app_config": {
          "sensitive": false,
          "type": [
            "object",
            {
              "apiKey": "string",
              "appId": "string",
              "authDomain": "string",
              "measurementId": "string",
              "messagingSenderId": "string",
              "projectId": "string",
              "storageBucket": "string"
            }
          ],
          "value": {
            "apiKey": "<API_KEY>",
            "appId": "<APP_ID>",
            "authDomain": "<PROJECT_ID>.firebaseapp.com",
            "measurementId": "<G-MEASUREMENT_ID>",
            "messagingSenderId": "<SENDER_ID>",
            "projectId": "<PROJECT_ID>",
            "storageBucket": "<PROJECT_ID>.appspot.com"
          }
        }
      }
      

4. Copia i valori dalla mappa value .
5. Incolla questi valori (la tua configurazione) nel file web/src/firebase-config.js della tua app, in questo modo:
   
   firebase-config.js

   ...
   
   const config = {
     apiKey: "<API_KEY>",
     appId: "<APP_ID>",
     authDomain: "<PROJECT_ID>.firebaseapp.com",
     measurementId: "<G-MEASUREMENT_ID>",
     messagingSenderId: "<SENDER_ID>",
     projectId: "<PROJECT_ID>",
     storageBucket: "<PROJECT_ID>.appspot.com",
   };
   
   ...
   

Inizializza Firebase nella tua app

Infine, per inizializzare Firebase, aggiungi il file web/src/index.js della tua app con quanto segue:

indice.js

...

const firebaseAppConfig = getFirebaseConfig();
initializeApp(firebaseAppConfig);

Prova la tua app

Ora che tutto è configurato per Firebase, puoi provare la tua app Web funzionale.

1. Aggiorna il browser che serve la tua app.
2. Ora dovresti essere in grado di accedere con Google e iniziare a pubblicare messaggi nella chat. Se hai file di immagine, puoi anche caricarli!

11. Replica la tua configurazione tra ambienti

Terraform eccelle nella gestione di più infrastrutture configurate in modo simile (ad esempio, impostando un progetto Firebase di staging simile a un progetto di produzione).

In questo codelab creerai un secondo progetto Firebase da utilizzare come ambiente di staging.

Per replicare una configurazione esistente per creare questo progetto di staging, hai due opzioni:

• Opzione 1 : crea una copia della configurazione Terraform.
  Questa opzione offre la massima flessibilità per quanto il progetto replicato può differire dal progetto di origine.
• Opzione 2 : riutilizzare le configurazioni con for_each .
  Questa opzione offre un maggiore riutilizzo del codice se ciascun progetto non deve differire in modo significativo e si desidera propagare le modifiche a tutti i progetti contemporaneamente.

Opzione 1: crea una copia della configurazione Terraform

Questa opzione offre la massima flessibilità per quanto il progetto replicato può differire dal progetto di origine, ad esempio avere app con nomi visualizzati diversi e implementazioni graduali.

1. Nella radice della directory web , crea un nuovo file di configurazione Terraform chiamato main_staging.tf .
2. Copia tutti i blocchi di risorse dal tuo file main.tf (ad eccezione dei blocchi terraform e provider ), quindi incollali nel tuo file main_staging.tf .
3. Devi quindi modificare ciascuno dei blocchi di risorse replicati in main_staging.tf affinché funzionino con il tuo progetto di staging:
   • Etichette delle risorse: utilizza un nuovo nome per evitare conflitti. Ad esempio, rinomina la resource "google_project" "default" in resource "google_project" "staging" .
   • Riferimenti alle risorse: aggiornali ciascuno. Ad esempio, aggiorna google_firebase_project.default.project in google_firebase_project.staging.project .
   Puoi trovare la configurazione completa di un file main_staging.tf nel repository GitHub di questo codelab:
   
   web/terraform-checkpoints/replicate-config/main_staging-copypaste.tf
   
   Se desideri utilizzare questa configurazione, assicurati di effettuare le seguenti operazioni:
   1. Copia la configurazione da main_staging-copypaste.tf e incollala nel file main_staging.tf .
   2. Nel file main_staging.tf , procedi come segue:
      • Nel blocco di risorse google_project , aggiorna l'attributo name , l'attributo project-id e (se configuri l'autenticazione tramite Terraform) l'attributo billing_account con i tuoi valori.
      • Nel blocco risorse google_firebase_web_app , aggiorna l'attributo display_name con il tuo valore.
      • Nei blocchi di risorse google_firestore_database e google_app_engine_application , aggiorna gli attributi location_id con il tuo valore.
   main_staging.tf

   # Create a new Google Cloud project.
   resource "google_project" "staging" {
     provider = google-beta.no_user_project_override
   
     name            = "<PROJECT_NAME_OF_STAGING_PROJECT>"
     project_id      = "<PROJECT_ID_OF_STAGING_PROJECT"
     # Required if you want to set up Authentication via Terraform
     billing_account = "<YOUR_BILLING_ACCOUNT_ID>"
   
     # Required for the project to display in any list of Firebase projects.
     labels = {
       "firebase" = "enabled"
     }
   }
   
   # Enable the required underlying Service Usage API.
   resource "google_project_service" "staging_serviceusage" {
     provider = google-beta.no_user_project_override
   
     project = google_project.staging.project_id
     service = "serviceusage.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Enable the required underlying Firebase Management API.
   resource "google_project_service" "staging_firebase" {
     provider = google-beta.no_user_project_override
   
     project = google_project.staging.project_id
     service = "firebase.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Enable Firebase services for the new project created above.
   resource "google_firebase_project" "staging" {
     provider = google-beta
   
     project = google_project.staging.project_id
   
     # Wait until the required APIs are enabled.
     depends_on = [
       google_project_service.staging_serviceusage,
       google_project_service.staging_firebase,
     ]
   }
   
   # Create a Firebase Web App in the new project created above.
   resource "google_firebase_web_app" "staging" {
     provider = google-beta
   
     project      = google_firebase_project.staging.project
     display_name = "<DISPLAY_NAME_OF_YOUR_WEB_APP>"
     deletion_policy = "DELETE"
   }
   

4. Esegui terraform apply per eseguire il provisioning del tuo nuovo progetto Firebase di "staging" e di tutte le sue risorse e abilitarne i servizi.
5. Verifica che tutto sia stato sottoposto a provisioning e abilitato come previsto controllandoli nella console Firebase come prima.

Opzione 2: riutilizzare le configurazioni con for_each

Questa opzione offre un maggiore riutilizzo del codice se ciascun progetto non deve differire in modo significativo e si desidera propagare le modifiche a tutti i progetti contemporaneamente. Utilizza il meta argomento for_each nel linguaggio Terraform.

1. Apri il file main.tf
2. In ogni blocco di risorse che desideri replicare, aggiungi un meta argomento for_each , in questo modo:
   
   main.tf

   # Create new Google Cloud projects.
   resource "google_project" "default" {
     provider        = google-beta.no_user_project_override
     name            = each.value
     # Create a unique project ID for each project, with each ID starting with <PROJECT_ID>.
     project_id      = "<PROJECT_ID>-${each.key}"
     # Required if you want to set up Authentication via Terraform
     billing_account = "<YOUR_BILLING_ACCOUNT_ID>"
   
     # Required for the projects to display in any list of Firebase projects.
     labels = {
       "firebase" = "enabled"
     }
   
     for_each = {
       prod    = "<PROJECT_NAME_OF_PROD_PROJECT>"
       staging = "<PROJECT_NAME_OF_STAGING_PROJECT>"
     }
   }
   
   # Enable the required underlying Service Usage API.
   resource "google_project_service" "serviceusage" {
     provider = google-beta.no_user_project_override
     for_each = google_project.default
   
     project = each.value.project_id
     service = "serviceusage.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Enable the required underlying Firebase Management API.
   resource "google_project_service" "firebase" {
     provider = google-beta.no_user_project_override
     for_each = google_project.default
   
     project = each.value.project_id
     service = "firebase.googleapis.com"
   
     # Don't disable the service if the resource block is removed by accident.
     disable_on_destroy = false
   }
   
   # Enable Firebase services for each of the new projects created above.
   resource "google_firebase_project" "default" {
     provider = google-beta
     for_each = google_project.default
   
     project = each.value.project_id
   
     depends_on = [
       google_project_service.serviceusage,
       google_project_service.firebase,
     ]
   }
   
   # Create a Firebase Web App in each of the new projects created above.
   resource "google_firebase_web_app" "default" {
     provider = google-beta
     for_each = google_firebase_project.default
   
     project      = each.value.project
     # The Firebase Web App created in each project will have the same display name.
     display_name = "<DISPLAY_NAME_OF_YOUR_WEB_APP>"
     deletion_policy = "DELETE"
   }
   
   
   # NOTE: For this codelab, we recommend setting up Firebase Authentication
   # using the Firebase console. However, if you set up Firebase Authentication
   # using Terraform, copy-paste from your main.tf the applicable blocks.
   # Make sure to add the `for_each` meta-argument into each block.
   
   
   # Copy-paste from your main.tf file the applicable resource blocks
   # for setting up Cloud Firestore (including rules) and
   # for setting up Cloud Storage for Firebase (including rules).
   # Make sure to add the `for_each` meta-argument into each block.
   

   Puoi trovare la configurazione completa di un file main.tf che utilizza il meta argomento for_each nel repository GitHub di questo codelab:
   
   web/terraform-checkpoints/replicate-config/main-foreach.tf
   
   Se desideri utilizzare questa configurazione, assicurati di effettuare le seguenti operazioni:
   1. Copia la configurazione da main-foreach.tf , quindi incollala nel file main.tf
   2. Nel tuo file main.tf , fai quanto segue:
      • Nel blocco delle risorse google_project , aggiorna l'attributo name , l'attributo project-id e (se si imposta l'autenticazione tramite Terraform) l'attributo billing_account con i tuoi valori.
      • Nel blocco risorse google_firebase_web_app , aggiorna l'attributo display_name con il tuo valore.
      • In google_firestore_database e google_app_engine_application Blocks, aggiorna gli attributi location_id con il tuo valore.
3. Invece di applicare subito questa configurazione, è importante capire e fissare alcune cose su come Terraform interpreta questa configurazione rispetto all'infrastruttura esistente.
   1. In questo momento, se avessi applicato questa configurazione che utilizza for_each , gli indirizzi delle risorse sembrerebbero quanto segue:

      google_project.default["prod"]
      google_project.default["staging"]
      google_firebase_project.default["prod"]
      google_firebase_project.default["staging"]
      google_firebase_web_app.default["prod"]
      google_firebase_web_app.default["staging"]
      

      Tuttavia, il progetto esistente creato nella prima parte di questo codelab è noto per terraform come segue:

      google_project.default
      google_firebase_project.default
      google_firebase_android_app.default
      

   2. Esegui terraform plan per vedere quali azioni intraprendono Terraform, dato lo stato attuale.
      
      L'output dovrebbe mostrare che Terraform eliminerebbe il progetto creato nella prima parte di questo codelab e creerebbe due nuovi progetti. Questo perché Terraform non sa che il progetto all'indirizzo google_project.default è stato spostato nel nuovo indirizzo google_project.default["prod"] .
   3. Per correggere questo, eseguire il comando terraform state mv :

      terraform state mv "google_project.default" "google_project.default[\"prod\"]"
      

   4. Allo stesso modo, per correggere tutti gli altri blocchi di risorse, eseguire terraform state mv per google_firebase_project , google_firebase_web_app e tutti gli altri blocchi di risorse nel file main.tf
   5. Ora, se esegui di nuovo terraform plan , non dovrebbe mostrare che Terraform eliminerebbe il progetto che hai creato nella prima parte di questo codelab.
4. Esegui terraform apply per fornire il tuo nuovo progetto Firebase "Staging" e tutte le sue risorse e consentire i suoi servizi.
5. Verificare che tutto sia stato provocato e abilitato come previsto controllandoli nella console Firebase come prima.

12. Passaggio bonus: distribuire le app di messa in scena e prod

1. Nella base di codice della tua app, modifica invece il firebase-config.js per utilizzare la configurazione Firebase dal progetto di stadiazione.
   
   Per ricordare a te stesso come ottenere la configurazione Firebase e aggiungerla alla tua app, consulta il passaggio precedente di questo codelab, aggiungi la configurazione Firebase alla tua app.
2. Nella radice della tua directory web , eseguire il comando seguente per distribuire la tua app nel progetto Firebase di gestione temporanea.

   firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
   

3. Apri l'app di gestione temporanea nel browser tramite l'URL stampato nell'output di firebase deploy . Prova ad accedere, inviare messaggi e caricare immagini.
   
   Quando si distribuisce un'app a un progetto Firebase, utilizza risorse di base Fire, non emulate. Mentre interagisci con la tua app di gestione temporanea, dovresti vedere i dati e le immagini appaiono nel tuo progetto di stadiazione nella console Firebase.
4. Dopo aver testato l'app nella messa in scena, modifica il firebase-config.js nell'uso della configurazione Firebase del progetto Prod (il primo progetto che hai creato in questo codelab).
5. Nella radice della directory web , esegui il comando seguente per distribuire la tua app al progetto Firebase di produzione.

   firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
   

6. Apri la tua app di produzione nel browser tramite l'URL stampato nell'output di firebase deploy . Prova ad accedere, inviare messaggi e caricare immagini.
   
   Dovresti vedere i dati e le immagini appaiono nel tuo progetto di produzione nella console Firebase.
7. Quando hai finito di interagire con le due app per questo codelab, puoi impedire a Firebase di servirle. Esegui il seguente comando per ciascuno dei tuoi progetti:

   firebase hosting:disable --project=<STAGING_PROJECT_ID>
   

   firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>
   

13. Congratulazioni!

Hai usato Terraform per configurare un'applicazione Web di chat in tempo reale! E hai seguito le migliori pratiche per gli ambienti di sviluppo creando progetti separati per la messa in scena e Prod.

Di cosa abbiamo parlato

• Utilizzo della CLI Terraform per gestire le risorse cloud
• Utilizzo di Terraform per configurare i prodotti Firebase (autenticazione, Firestore, Cloud Storage e Regole di sicurezza)
• Eseguire e testare un'app Web a livello locale utilizzando la suite emulatore locale Firebase
• Importazione di Firebase in un'app Web
• Utilizzo di Terraform per replicare una configurazione in più ambienti

Per ulteriori informazioni su Firebase e Terraform, visitare la nostra documentazione . Puoi trovare un elenco di tutti i prodotti Firebase con supporto Terraform, configurazioni di terraform campione per casi di utilizzo comune e utili risoluzione dei problemi e FAQ.