Configura e gestisci progetti e prodotti Firebase tramite Terraform

1. Introduzione

Obiettivi

Puoi utilizzare Terraform per configurare 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, quindi come configurare le app e i prodotti Firebase che vuoi utilizzare nel progetto. Tratteremo anche le nozioni di base della riga di comando di Terraform, ad esempio l'anteprima delle modifiche da apportare e la loro implementazione.

Se vuoi imparare a configurare e gestire progetti e prodotti Firebase con Terraform, questo codelab fa al caso tuo.

Obiettivi didattici

  • Come creare un file di configurazione Terraform (*.tf)
  • Come utilizzare i comandi dell'interfaccia a riga di comando di Terraform per gestire l'infrastruttura
  • Come modificare la configurazione per aggiornare le risorse e i servizi
  • Come applicare la configurazione a un'app web reale (chiamata Friendly Chat)
  • Come definire configurazioni parallele (e sincronizzate) in ambienti diversi (produzione, gestione temporanea e così via)

Che cosa ti serve

Per completare questo codelab, devi avere 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 in modo che tu possa testare e interagire con ciò che esegui il provisioning tramite Terraform. A questo scopo, ti serviranno:

  • Il codice campione per un'app web. Scarica questo codice nel passaggio successivo del codelab.
  • Il gestore di pacchetti npm (che in genere viene fornito con Node.js): installa questi strumenti
  • L'interfaccia a riga di comando di Firebase: installa questa CLI ed esegui l'accesso

2. Ottieni il codice iniziale

In questo codelab puoi testare il provisioning tramite Terraform con un'app web reale. Ti consigliamo di farlo per comprendere tutti i passaggi necessari per utilizzare le risorse di cui è stato eseguito il provisioning con 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 installato git, puoi scaricare il repository come file ZIP.

3. Crea una configurazione Terraform

Configurazione di Terraform

  1. Nel codebase dell'app di esempio scaricata, vai alla radice della directory web.
  2. Nella radice di questa directory, crea un file di configurazione Terraform denominato 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 la modalità di verifica della quota delle operazioni di Terraform. Per il provisioning della maggior parte delle risorse, devi utilizzare user_project_override = true, ovvero controllare la quota rispetto al tuo progetto Firebase. Tuttavia, per configurare il nuovo progetto in modo che possa accettare i controlli della quota, devi prima utilizzare user_project_override=false. La sintassi di Terraform alias 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 attivati.

Aggiungi blocchi per il progetto Google Cloud e le API sottostanti

  1. Innanzitutto, esegui il provisioning del progetto Google Cloud sottostante.

    Aggiungi il seguente blocco di risorse al file di configurazione main.tf.

    Devi specificare il tuo nome del progetto (ad esempio "Terraform FriendlyChat Codelab") e il tuo ID progetto (ad esempio "terraform-codelab-your-initials"). Tieni presente che il valore name viene utilizzato solo all'interno delle interfacce Firebase e non è visibile agli utenti finali. Il valore project_id, tuttavia, identifica in modo univoco il tuo progetto per 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.

    L'abilitazione di queste API viene in genere gestita in background quando utilizzi la console Firebase per creare un progetto Firebase, ma Terraform deve essere informato esplicitamente di eseguire questa operazione.

    Al 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
}
    Se abiliti l'API Service Usage, il tuo nuovo progetto potrà accettare i controlli delle quote. Pertanto, per tutto il provisioning delle risorse e l'attivazione dei servizi successivi, devi utilizzare il provider con user_project_override (non è necessario alcun alias).

Aggiungere un blocco per attivare i servizi Firebase

L'ultima cosa necessaria per "creare un progetto Firebase" è l'attivazione dei servizi Firebase nel progetto.

Continua nel file di configurazione main.tf e 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 riportato sopra, potresti notare la clausola depends_on, che indica a Terraform di attendere l'abilitazione delle API sottostanti. Senza questa clausola, Terraform non conosce la dipendenza e potrebbe riscontrare errori durante il provisioning delle risorse in parallelo.

Applica 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 delle 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 devi solo visualizzare l'anteprima delle modifiche senza applicarle, puoi utilizzare il comando terraform plan.

Convalidare le modifiche

Al termine dell'esecuzione di Terraform, puoi esaminare lo stato di tutte le risorse e i servizi di cui è stato eseguito il provisioning 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.

Il progetto Terraform FriendlyChat Codelab selezionato nella console Firebase

5. Registrare l'app Firebase tramite Terraform

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

Aggiungere un blocco per registrare l'app web

Per registrare la tua app web nel progetto Firebase, aggiungi il seguente blocco di risorse al file main.tf.

Devi specificare il tuo display_name per la tua app web. Tieni presente che questo nome viene utilizzato solo all'interno delle 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"
}

Applica 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 ricrea un nuovo progetto Google Cloud. Terraform rileverà che esiste già un progetto con l'ID progetto specificato, confronterà lo stato attuale del progetto con quello del file .tf e apporterà le modifiche che rileva.
  2. Esamina il piano d'azione stampato. Se tutto sembra come previsto, digita yes e premi Invio per approvare le azioni.

Convalidare le modifiche

Puoi esaminare lo stato della risorsa appena sottoposta a provisioning eseguendo il seguente comando:

terraform show

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

6. Configurare Firebase Authentication

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 attivare Firebase Authentication e configurare il metodo di accesso con Google.

Tieni presente che in questo codelab forniamo due opzioni diverse per configurare Firebase Authentication:

  • Opzione 1 (consigliata): configura Firebase Authentication nella console, che non richiede GCIP.
    • Se utilizzi questa opzione, non devi associare il nuovo progetto a un account di fatturazione Cloud.
  • Opzione 2: configura Firebase Authentication tramite Terraform utilizzando le API Google Cloud Identity Platform (GCIP).
    • Se utilizzi questa opzione, devi associare il nuovo progetto a un account di fatturazione Cloud, poiché GCIP richiede che il progetto utilizzi il piano tariffario Blaze.

Opzione 1: configura Authentication utilizzando la console Firebase

Per configurare Firebase Authentication utilizzando la console Firebase, non è necessario che il progetto utilizzi il piano tariffario Blaze.

Ecco come configurare Firebase Authentication e l'accesso con Google:

  1. Nella console Firebase, individua la sezione Build nel riquadro a sinistra.
  2. Fai clic su Autenticazione, poi su Inizia e infine sulla scheda Metodo di accesso (o fai clic qui per andare direttamente alla scheda).
  3. Fai clic su Aggiungi nuovo fornitore e, nella sezione Fornitori aggiuntivi, seleziona Google.
  4. Attiva il pulsante di attivazione/disattivazione Attiva.
  5. Imposta il nome pubblico della tua app su un valore come FriendlyChat (non è necessario che sia univoco a livello globale).
  6. Scegli un'email di assistenza per il progetto dal menu a discesa, quindi fai clic su Salva.Configurare Firebase Auth nella console Firebase
  7. Dovresti vedere Google come provider di accesso abilitato.Pagina Autenticazione della console Firebase: accesso con Google attivato

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

Per configurare Firebase Authentication tramite Terraform, devi utilizzare le API GCIP, il che significa che il progetto deve essere incluso nel piano tariffario Blaze. Esegui l'upgrade del tuo progetto Firebase per utilizzare il piano Blaze associando un account di fatturazione Cloud al progetto.

Abilitare la fatturazione tramite Terraform

  1. Se non disponi già di un account Cloud Billing, il primo passaggio consiste nel crearne uno nuovo nella console Google Cloud. Quando lo fai, annota il relativo ID account di fatturazione. L'ID account di fatturazione si trova nella pagina Fatturazione dell'ID account di fatturazione associato al tuo progetto.Attivare un account di fatturazione utilizzando la console Google Cloud
  2. Per attivare la fatturazione nel tuo progetto tramite Terraform, aggiungi un attributo billing_account alla risorsa google_project esistente nel 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"
  }
}

...

Abilitare Firebase Authentication e l'accesso con Google tramite Terraform

  1. Per eseguire il provisioning di Firebase Authentication con GCIP, aggiungi al file main.tf 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. L'attivazione di Accedi con Google richiede un client OAuth. Per eseguire questa configurazione, vai alla sezione API e servizi di Google Cloud Console.
  3. Poiché è la prima volta che crei un ID client per questo progetto, devi configurare la schermata per il consenso OAuth.
    1. Apri la pagina Schermata per il consenso OAuth e seleziona il progetto che hai appena creato.
    2. Imposta Tipo di utente su Esterno e poi fai clic su Crea.
    3. Nella schermata successiva, completa i seguenti passaggi, quindi fai clic su Salva e continua.
      • Imposta il nome dell'app visibile al pubblico su un valore come FriendlyChat (non deve essere univoco a livello globale).
      • Scegli un'email di assistenza utenti dal menu a discesa.
      • Inserisci un indirizzo email per le Informazioni di contatto dello sviluppatore.
    4. Nelle schermate successive, completa quanto segue:
      • Accetta i valori predefiniti nella pagina Ambiti e poi fai clic su Salva e continua.
      • Accetta i valori predefiniti nella pagina Utenti di test e poi fai clic su Salva e continua.
      • Controlla il riepilogo e fai clic su Torna alla dashboard.
      Configurazione di un client OAuth2 utilizzando la console Google Cloud
  4. Configura un client OAuth nella pagina Credenziali procedendo nel seguente modo:
    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 che hai 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 che hai impostato in main.tf.
    5. Fai clic su Salva.
    Ottenere l&#39;ID client e il client secret OAuth2 dalla pagina Credenziali della console Google Cloud
  5. Per attivare l'accesso con Google utilizzando l'ID client OAuth e il client secret, aggiungi il seguente blocco al file main.tf:

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

Applica la configurazione

  1. Per configurare l'autenticazione in base alla 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 di terraform apply non comporta la creazione di un nuovo progetto Google Cloud. Terraform rileverà che esiste già un progetto con l'ID progetto specificato e confronterà lo stato attuale del progetto con quello del file .tf. Dopodiché, apporterà le modifiche che rileva.
  2. Esamina 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 riquadro a sinistra.
  2. Fai clic su Autenticazione, quindi sulla scheda Metodo di accesso (o fai clic qui per andare direttamente alla scheda).
  3. Dovresti vedere Google come provider di accesso abilitato.Pagina Autenticazione della console Firebase: accesso con Google attivato

7. Configura un database Firestore e le relative 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 e eseguire il provisioning dell'istanza del database, aggiungi al file main.tf 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. Modifica <NAME_OF_DESIRED_REGION> con la regione in cui vuoi che risieda il database.

    Quando sviluppi un'app di produzione, ti consigliamo di scegliere una regione 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 Località 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 un insieme di regole Firestore sicure nel file firestore.rules, che puoi trovare nella directory principale di web.
  4. Aggiungi al tuo file main.tf i seguenti blocchi di risorse per:
    • Crea un insieme di regole di Firebase Security Rules dal file firestore.rules locale.
    • Rilascia il set di regole per l'istanza Firestore.
    Tieni presente che questi blocchi di risorse eseguono l'equivalente di fare clic sul pulsante Pubblica nella console Firebase o di 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 eseguire il provisioning del database Firestore e il deployment delle relative regole di sicurezza.
  6. Verifica che il database sia sottoposto a provisioning e che le relative regole di sicurezza siano implementate:
    1. Nella console Firebase, individua la sezione Build nel riquadro a sinistra.
    2. Vai alla sezione Database Firestore, quindi fai clic sulla scheda Regole.
    Verifica delle regole di Cloud Firestore utilizzando la console Firebase

8. Configurare 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 e eseguire il provisioning del bucket Cloud Storage predefinito, aggiungi al file main.tf i seguenti blocchi di risorse.

    Tieni presente che il bucket Cloud Storage predefinito per il tuo progetto viene sottoposto a provisioning tramite Google App Engine e deve avere la stessa località del database Firestore. Per saperne di più, consulta Località di App Engine.

    Se vuoi più bucket nel tuo progetto, esegui il provisioning utilizzando la google_storage_bucketrisorsa (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 di Firebase.

    Il codice di esempio di questo codelab fornisce un insieme di regole Firestore sicure nel file storage.rules, che puoi trovare nella directory principale di web.
  3. Aggiungi al tuo file main.tf i seguenti blocchi di risorse per:
    • Crea un insieme di regole di Firebase Security Rules dal file locale.
    • Rilascia il ruleset per il bucket di archiviazione.
    Tieni presente che questi blocchi di risorse eseguono l'equivalente di fare clic sul pulsante Pubblica nella console Firebase o di 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 il deployment delle relative regole di sicurezza.
  5. Verifica che il bucket sia sottoposto a provisioning e che le relative regole di sicurezza siano implementate:
    1. Nella console Firebase, individua la sezione Build nel riquadro a sinistra.
    2. Vai alla sezione Archiviazione e poi fai clic sulla scheda Regole.
    Verifica delle regole di sicurezza utilizzando la console Firebase

9. Esegui l'app localmente

Ora puoi eseguire la tua app web per la prima volta. Utilizzerai l'emulatore di Firebase Hosting per pubblicare la tua app localmente.

  1. Apri una nuova finestra del terminale ed esegui il seguente comando della CLI Firebase dalla directory web per avviare l'emulatore:
    firebase emulators:start --project=<PROJECT_ID>
  2. Nel browser, apri l'app web all'URL locale restituito dalla CLI (di solito http://localhost:5000).

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

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

10. Installa, configura e inizializza Firebase

Per far funzionare un'app con Firebase, l'app deve avere l'SDK Firebase e la 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 consultare web/package.json e web/src/index.js se vuoi 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 build di webpack

Devi eseguire alcuni comandi per avviare la build dell'app.

  1. Apri una nuova finestra del terminale.
  2. Assicurati di trovarti nella directory principale di web.
  3. Esegui npm install per scaricare l'SDK Firebase.
  4. Esegui npm update per aggiornare le dipendenze.
  5. Esegui npm run start per avviare webpack.

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

Aggiungere la configurazione di Firebase all'app

Devi anche aggiungere la configurazione Firebase alla tua app in modo che gli SDK Firebase sappiano quale progetto Firebase vuoi 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 al codebase

  1. Nella console Firebase, vai alle impostazioni del progetto.
  2. Scorri verso il basso fino alla scheda Le tue app e seleziona la tua app web.
  3. Seleziona Config (Configurazione) dal riquadro dello snippet dell'SDK Firebase, quindi copia lo snippet di configurazione.
  4. Incolla la configurazione nel file web/src/firebase-config.js della tua app, come segue:

    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 al codebase

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

  1. Nel file main.tf, individua il blocco di risorse google_firebase_web_app (il blocco che ha registrato un'app web con il tuo progetto).
  2. Subito dopo questo 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 l'infrastruttura in alcun modo, devi solo eseguire i seguenti comandi.
    1. Per caricare la configurazione Firebase della tua app web nello stato Terraform della tua 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 una configurazione. 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, come segue:

    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 quanto segue al file web/src/index.js della tua app:

index.js

...

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

Provare l'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 immagini, puoi anche caricarli.

11. Replica la configurazione in più ambienti

Terraform è ideale per gestire più infrastrutture configurate in modo simile (ad esempio, per configurare un progetto Firebase di gestione temporanea simile a un progetto di produzione).

In questo codelab, creerai un secondo progetto Firebase che fungerà da ambiente di staging.

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

  • Opzione 1: crea una copia della configurazione di Terraform.
    Questa opzione offre la massima flessibilità per quanto riguarda la differenza tra il progetto replicato e il progetto di origine.
  • Opzione 2: riutilizza le configurazioni con for_each.
    Questa opzione offre un maggiore riutilizzo del codice se i progetti non devono differire in modo significativo e vuoi propagare le modifiche a tutti i progetti contemporaneamente.

Opzione 1: crea una copia della configurazione Terraform

Questa opzione offre la massima flessibilità per quanto riguarda la differenza tra il progetto replicato e il progetto di origine, ad esempio la presenza di app con nomi visualizzati e implementazioni in più fasi diversi.

  1. Nella directory principale di web, crea un nuovo file di configurazione Terraform denominato main_staging.tf.
  2. Copia tutti i blocchi di risorse dal file main.tf (ad eccezione dei blocchi terraform e provider) e incollali nel file main_staging.tf.
  3. Dopodiché, devi 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 resource "google_project" "default" in resource "google_project" "staging".
    • Riferimenti alle risorse:aggiorna ciascuno. Ad esempio, aggiorna google_firebase_project.default.project a 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 vuoi utilizzare questa configurazione, assicurati di fare quanto segue:
    1. Copia la configurazione da main_staging-copypaste.tf e incollala nel file main_staging.tf.
    2. Nel file main_staging.tf, procedi nel seguente modo:
      • Nel blocco di risorse google_project, aggiorna l'attributo name, l'attributo project-id e (se hai configurato l'autenticazione tramite Terraform) l'attributo billing_account con i tuoi valori.
      • Nel blocco di 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 nuovo progetto Firebase "staging" e di tutte le relative risorse e abilitare i relativi servizi.
  5. Verifica che il provisioning e l'attivazione siano stati eseguiti come previsto controllando la console Firebase come in precedenza.

Opzione 2: riutilizza le configurazioni con for_each

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

  1. Apri il file main.tf.
  2. Aggiungi un meta-argomento for_each a ogni blocco di risorse che vuoi replicare, come segue:

    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 vuoi utilizzare questa configurazione, assicurati di fare quanto segue:
    1. Copia la configurazione da main-foreach.tf e incollala nel file main.tf.
    2. Nel file main.tf, procedi nel seguente modo:
      • Nel blocco di risorse google_project, aggiorna l'attributo name, l'attributo project-id e (se hai configurato l'autenticazione tramite Terraform) l'attributo billing_account con i tuoi valori.
      • Nel blocco di 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.
  3. Prima di applicare questa configurazione, è importante capire e correggere alcuni aspetti del modo in cui Terraform interpreta questa configurazione rispetto all'infrastruttura esistente.
    1. Al momento, se hai applicato questa configurazione che utilizza for_each, gli indirizzi delle risorse avranno il seguente aspetto:
      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 che hai creato nella prima parte di questo codelab è noto a Terraform come segue:
      google_project.default
google_firebase_project.default
google_firebase_android_app.default
    2. Esegui terraform plan per vedere quali azioni intraprenderebbe Terraform in base allo 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 al nuovo indirizzo google_project.default["prod"].
    3. Per risolvere il problema, esegui 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, esegui 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 eseguire il provisioning del nuovo progetto Firebase "staging" e di tutte le relative risorse e abilitare i relativi servizi.
  5. Verifica che il provisioning e l'attivazione siano stati eseguiti come previsto controllando la console Firebase come in precedenza.

12. Passaggio bonus: distribuisci le app di staging e di produzione

  1. Nel codebase della tua app, modifica firebase-config.js per utilizzare la configurazione Firebase del progetto di staging.

    Per ricordarti 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 directory principale di web, esegui questo comando per eseguire il deployment dell'app nel progetto Firebase di gestione temporanea.
    firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
  3. Apri l'app di staging nel browser tramite l'URL stampato nell'output di firebase deploy. Prova ad accedere, inviare messaggi e caricare immagini.

    Quando esegui il deployment di un'app in un progetto Firebase, vengono utilizzate risorse Firebase reali, non risorse emulate. Man mano che interagisci con l'app di staging, dovresti vedere dati e immagini nel progetto di staging nella Console Firebase.
  4. Dopo aver testato l'app in staging, torna a utilizzare la configurazione Firebase del progetto di produzione (il primo progetto che hai creato in questo codelab) per firebase-config.js.
  5. Nella directory principale di web, esegui questo comando per eseguire il deployment dell'app nel progetto Firebase di produzione.
    firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
  6. Apri l'app di produzione nel browser tramite l'URL stampato nell'output di firebase deploy. Prova ad accedere, inviare messaggi e caricare immagini.

    Dovresti visualizzare dati e immagini nel progetto di produzione nella console Firebase.
  7. Al termine dell'interazione con le due app per questo codelab, puoi impedire a Firebase di pubblicarle. Esegui questo comando per ciascuno dei tuoi progetti:
    firebase hosting:disable --project=<STAGING_PROJECT_ID>

    firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>

13. Complimenti!

Hai utilizzato Terraform per configurare un'applicazione web di chat in tempo reale. Inoltre, hai seguito le best practice per gli ambienti di sviluppo creando progetti Firebase separati per la gestione temporanea e la produzione.

Argomenti trattati

  • 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)
  • Esecuzione e test di un'app web in locale utilizzando Firebase Local Emulator Suite
  • Importare Firebase in un'app web
  • Utilizzo di Terraform per replicare una configurazione in più ambienti

Per saperne di più su Firebase e Terraform, consulta la nostra documentazione. Puoi trovare un elenco di tutti i prodotti Firebase con supporto Terraform, configurazioni Terraform di esempio per casi d'uso comuni e utili informazioni per la risoluzione dei problemi e domande frequenti.