Configurer et gérer des projets et produits Firebase via Terraform

1. Introduction

Objectifs

Vous pouvez utiliser Terraform pour configurer et gérer un projet Firebase, y compris la configuration programmatique de l'infrastructure et des produits Firebase.

Cet atelier de programmation décrit d'abord comment créer un fichier de configuration Terraform pour créer un projet Firebase, puis comment configurer les applications et les produits Firebase que vous souhaitez utiliser dans ce projet. Nous abordons également les bases de la ligne de commande Terraform, comme prévisualiser les modifications à apporter puis les implémenter.

Si vous souhaitez apprendre à configurer et gérer des projets et des produits Firebase avec Terraform, cet atelier de programmation est fait pour vous !

Ce que vous apprendrez

• Comment créer un fichier de configuration Terraform ( *.tf )
• Comment utiliser les commandes Terraform CLI pour gérer votre infrastructure
• Comment modifier votre configuration pour mettre à jour vos ressources et services
• Comment appliquer votre configuration sur une vraie application web (appelée Friendly Chat )
• Comment définir des configurations parallèles (et synchronisées) dans différents environnements (production, staging, etc.)

Ce dont vous aurez besoin

• Un terminal/console
• L'IDE/éditeur de texte de votre choix, tel que WebStorm , Atom , Sublime ou VS Code
• Le navigateur de votre choix, tel que Chrome
• Google Cloud CLI (gCloud CLI) : installez cette CLI et connectez-vous à l'aide d'un compte utilisateur ou d'un compte de service.

Pour réussir cet atelier de programmation, vous devez maîtriser Terraform et sa terminologie de base, y compris les prérequis suivants :

• Installez Terraform et familiarisez-vous avec Terraform à l'aide de leurs tutoriels officiels

Cet atelier de programmation fournit un véritable exemple d'application afin que vous puissiez tester et interagir avec ce que vous provisionnez via Terraform. Pour ce faire, vous aurez besoin des éléments suivants :

• Exemple de code pour une application Web : téléchargez ce code à l'étape suivante de l'atelier de programmation.
• Le gestionnaire de packages npm (qui vient généralement avec Node.js ) - installez ces outils
• La CLI Firebase - installez cette CLI et connectez-vous

2. Obtenez le code de départ

Dans cet atelier de programmation, vous pouvez tester ce que vous provisionnez via Terraform avec une véritable application Web. Nous vous recommandons de procéder ainsi afin de comprendre toutes les étapes nécessaires pour utiliser les ressources fournies par Terraform.

Clonez le dépôt GitHub de l'atelier de programmation à partir de la ligne de commande :

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

Alternativement, si git n'est pas installé, vous pouvez télécharger le référentiel sous forme de fichier ZIP .

3. Créez une configuration Terraform

Mise en place de Terraform

1. Dans la base de code de l’exemple d’application téléchargé, accédez à la racine du répertoire web .
2. À la racine de ce répertoire, créez un fichier de configuration Terraform appelé main.tf avec la configuration initiale suivante :
   
   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
   }
   

Chacun des fournisseurs google-beta possède un attribut nommé user_project_override qui détermine comment les opérations de Terraform seront vérifiées par quota. Pour provisionner la plupart des ressources, vous devez utiliser user_project_override = true , ce qui signifie vérifier le quota par rapport à votre propre projet Firebase. Cependant, pour configurer votre nouveau projet afin qu'il puisse accepter les contrôles de quota, vous devez d'abord utiliser user_project_override=false . La syntaxe alias Terraform vous permet de faire la distinction entre les deux configurations de fournisseur dans les prochaines étapes de cet atelier de programmation.

Initialiser Terraform dans le répertoire

La création d'une nouvelle configuration pour la première fois nécessite le téléchargement du fournisseur spécifié dans la configuration.

Pour effectuer cette initialisation, exécutez la commande suivante à partir de la racine du même répertoire que votre fichier de configuration main.tf :

terraform init

4. Créez un projet Firebase via Terraform

Pour "créer un projet Firebase", il est important de se rappeler que chaque projet Firebase est en fait un projet Google Cloud, uniquement avec les services Firebase activés pour celui-ci.

Ajouter des blocs pour le projet Google Cloud sous-jacent et les API

1. Tout d'abord, provisionnez le projet Google Cloud sous-jacent.
   
   À votre fichier de configuration main.tf , ajoutez le bloc de ressources suivant.
   
   Vous devez spécifier votre propre nom de projet (comme "Terraform FriendlyChat Codelab" ) et votre propre ID de projet (comme "terraform-codelab-your-initials" ). Notez que la valeur name n'est utilisée que dans les interfaces Firebase et n'est pas visible pour les utilisateurs finaux. Cependant, la valeur project_id identifie de manière unique votre projet auprès de Google, alors assurez-vous de spécifier une valeur unique. 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. Ensuite, vous devez activer les API sous-jacentes requises : l'API d'utilisation du service et l'API de gestion Firebase.
   
   Cette activation de l'API est généralement gérée en arrière-plan lorsque vous utilisez la console Firebase pour créer un projet Firebase, mais Terraform doit être explicitement invité à effectuer cette activation.
   
   À votre fichier de configuration main.tf (juste sous le bloc qui crée le nouveau projet Cloud), ajoutez le bloc de ressources suivant :
   
   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
   }
   

   En activant l'API d'utilisation des services, votre nouveau projet pourra accepter les contrôles de quota ! Ainsi, pour tout approvisionnement ultérieur en ressources et activation de services, vous devez utiliser le fournisseur avec user_project_override (aucun alias requis).

Ajouter un bloc pour activer les services Firebase

La toute dernière chose requise pour « créer un projet Firebase » est d'activer les services Firebase sur le projet.

En continuant dans votre fichier de configuration main.tf , ajoutez le bloc de ressources suivant.

Comme mentionné juste ci-dessus, notez que ce bloc de ressources utilise le fournisseur avec user_project_override (aucun alias nécessaire).

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

Dans le bloc de ressources ci-dessus, vous remarquerez peut-être la clause depends_on , qui indique à Terraform d'attendre que les API sous-jacentes soient activées. Sans cette clause, Terraform ne connaît pas la dépendance et peut rencontrer des erreurs lors du provisionnement des ressources en parallèle.

Appliquer la configuration

1. Pour provisionner les nouvelles ressources et activer les API spécifiées dans votre fichier de configuration, exécutez la commande suivante à partir de la racine du même répertoire que votre fichier main.tf (qui devrait être web ) :

   terraform apply
   

2. Dans le terminal, Terraform imprime un plan d'actions qu'il va effectuer.
   
   Si tout se passe comme prévu, approuvez les actions en saisissant 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 # <----
   

Notez que si vous avez uniquement besoin de prévisualiser les modifications sans les appliquer, vous pouvez utiliser la commande terraform plan à la place.

Valider les modifications

Une fois l'exécution de Terraform terminée, vous pouvez inspecter l'état de toutes les ressources et services provisionnés par Terraform activés en exécutant la commande suivante :

terraform show

Voici un exemple de ce que vous devriez voir imprimé. Votre état contiendra des valeurs spécifiques à votre projet.

# 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"
}

Vous pouvez également vérifier que le projet est créé en l'affichant dans la console Firebase .

5. Enregistrez votre application Firebase via Terraform

Pour utiliser Firebase, vous devez enregistrer chaque variante de plate-forme de votre application dans votre projet Firebase. Dans cet atelier de programmation, vous utiliserez une véritable application pour tester et interagir avec ce que vous provisionnez via Terraform. Cette application est une application Web, vous devez donc demander à Terraform d'enregistrer une application Web Firebase dans votre projet Firebase nouvellement créé.

Ajouter un bloc pour enregistrer l'application Web

Pour enregistrer votre application Web dans votre projet Firebase, ajoutez votre fichier main.tf avec le bloc de ressources suivant.

Vous devez spécifier votre propre display_name pour votre application Web. Notez que ce nom n'est utilisé que dans les interfaces Firebase et n'est pas visible pour les utilisateurs finaux.

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

Appliquer la configuration

1. Pour provisionner la nouvelle ressource, exécutez la commande suivante à partir de la racine du même répertoire que votre fichier main.tf (qui devrait être web ).

   terraform apply
   

   Notez que cette commande ne recréera pas un nouveau projet Google Cloud. Terraform détectera qu'un projet avec l'ID de projet spécifié existe déjà et comparera l'état actuel du projet avec le contenu du .tf et apportera toutes les modifications trouvées.
2. Examinez le plan d’actions imprimé. Si tout se passe comme prévu, tapez yes et appuyez sur Entrée pour approuver les actions.

Valider les modifications

Vous pouvez inspecter l'état de la ressource nouvellement provisionnée en exécutant la commande suivante :

terraform show

Vous pouvez également vérifier que l'application a été enregistrée avec succès dans votre projet en l'affichant dans la console Firebase. Accédez aux paramètres du projet , puis faites défiler jusqu'à la section Vos applications .

6. Configurer l'authentification Firebase

L'authentification est un élément important de toute application. Pour permettre aux utilisateurs finaux de se connecter à votre application Web avec leurs comptes Google, vous pouvez activer l'authentification Firebase et configurer la méthode de connexion avec Google.

Notez que dans cet atelier de programmation, nous proposons deux options différentes pour configurer l'authentification Firebase :

• Option 1 (recommandée) : configurez l'authentification Firebase dans la console, qui ne nécessite pas GCIP.
  • L'utilisation de cette option signifie que vous n'avez pas besoin d'associer votre nouveau projet à un compte Cloud Billing.
• Option 2 : configurez l'authentification Firebase via Terraform à l'aide des API Google Cloud Identity Platform (GCIP).
  • L'utilisation de cette option signifie que vous devez associer votre nouveau projet à un compte Cloud Billing puisque GCIP nécessite que le projet soit sur le plan tarifaire Blaze.

Option 1 : configurer l'authentification à l'aide de la console Firebase

Pour configurer l'authentification Firebase à l'aide de la console Firebase, votre projet n'a pas besoin de figurer sur le plan tarifaire Blaze.

Voici comment configurer l'authentification Firebase et vous connecter avec Google :

1. Dans la console Firebase , localisez la section Build dans le panneau de gauche.
2. Cliquez sur Authentification , cliquez sur Commencer , puis cliquez sur l'onglet Méthode de connexion (ou cliquez ici pour y accéder directement).
3. Cliquez sur Ajouter un nouveau fournisseur et, dans la section Fournisseurs supplémentaires , sélectionnez Google .
4. Activez le bouton Activer .
5. Définissez le nom public de votre application sur quelque chose comme FriendlyChat (cela n'a pas besoin d'être unique au monde).
6. Choisissez un e-mail d'assistance pour le projet dans le menu déroulant, puis cliquez sur Enregistrer .
7. Vous devriez voir Google comme un fournisseur de connexion activé.

Option 2 : configurer l'authentification via Terraform à l'aide des API Google Cloud Identity Platform (GCIP)

Pour configurer l'authentification Firebase via Terraform, vous devez utiliser les API GCIP, ce qui signifie que le projet doit être sur le plan tarifaire Blaze. Vous mettez à niveau votre projet Firebase pour utiliser le plan Blaze en associant un compte Cloud Billing au projet.

Activer la facturation via Terraform

1. Si vous ne disposez pas déjà d'un compte Cloud Billing, la première étape consiste à créer un nouveau compte dans Google Cloud Console . Ce faisant, notez son ID de compte de facturation . L'ID du compte de facturation peut être situé sur la page Facturation dans l' ID du compte de facturation associé à votre projet.
2. Pour activer la facturation dans votre projet via Terraform, ajoutez un attribut billing_account dans la ressource google_project existante dans votre fichier 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"
     }
   }
   
   ...
   

Activez l'authentification Firebase et connectez-vous avec Google via Terraform

1. Pour provisionner l'authentification Firebase avec GCIP, ajoutez votre fichier main.tf avec les blocs de ressources suivants :
   
   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'activation de la connexion avec Google nécessite que vous disposiez d'un client OAuth . Accédez à la section API et services de Google Cloud Console pour effectuer cette configuration.
3. Étant donné que c'est la première fois que vous créez un identifiant client pour ce projet, vous devez configurer votre écran de consentement OAuth.
   1. Ouvrez la page d'écran de consentement OAuth , puis sélectionnez le projet que vous venez de créer.
   2. Définissez le Type d'utilisateur sur Externe , puis cliquez sur Créer .
   3. Dans l'écran suivant, complétez ce qui suit, puis cliquez sur Enregistrer et continuer .
      • Définissez le nom de l'application publique de votre application sur quelque chose comme FriendlyChat (cela n'a pas besoin d'être unique au monde).
      • Choisissez un e-mail d'assistance utilisateur dans le menu déroulant.
      • Saisissez une adresse e-mail pour les informations de contact du développeur .
   4. Dans les écrans suivants, complétez ce qui suit :
      • Acceptez les valeurs par défaut sur la page Étendues , puis cliquez sur Enregistrer et continuer .
      • Acceptez les valeurs par défaut sur la page Utilisateurs de test , puis cliquez sur Enregistrer et continuer .
      • Consultez le résumé, puis cliquez sur Retour au tableau de bord .
      
4. Configurez un client OAuth sur la page Identifiants en procédant comme suit :
   1. Cliquez sur Créer des informations d'identification et sélectionnez ID client OAuth .
   2. Dans la liste déroulante Type d'application , sélectionnez Application Web .
   3. Dans le champ Nom , saisissez le nom de votre application, par exemple FriendlyChat (il n'est pas nécessaire qu'il soit unique au monde).
   4. Autorisez l'URL de votre application à utiliser ce client OAuth en définissant les paramètres suivants :
      • Sous Origines JavaScript autorisées , cliquez sur Ajouter un URI et saisissez
        https://<PROJECT_ID>.firebaseapp.com , où <PROJECT_ID> est l'ID de projet que vous avez défini dans main.tf .
      • Sous URI de redirection autorisés , cliquez sur Ajouter un URI et saisissez
        https://<PROJECT_ID>.firebaseapp.com/__/auth/handler , où <PROJECT_ID> est l'ID de projet que vous avez défini dans main.tf .
   5. Cliquez sur Enregistrer .
   
5. Pour activer la connexion avec Google à l'aide de votre identifiant client OAuth et de votre secret client, ajoutez votre fichier main.tf avec le bloc suivant :
   
   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
     ]
   }
   

Appliquer la configuration

1. Pour configurer l'authentification en fonction de votre configuration, exécutez les commandes suivantes à partir de la racine du même répertoire que votre fichier main.tf (qui devrait être web ) :

   export TF_VAR_oauth_client_secret="<YOUR_OAUTH_CLIENT_SECRET>"
   

   terraform apply
   

   Notez que l'exécution terraform apply ne recréera pas un nouveau projet Google Cloud. Terraform détectera qu'un projet avec l'ID de projet spécifié existe déjà et comparera l'état actuel du projet avec le contenu du fichier .tf . Il apportera ensuite toutes les modifications qu'il trouvera.
2. Examinez le plan d’actions imprimé. Si tout se passe comme prévu, tapez yes et appuyez sur Entrée pour approuver les actions.

Valider les modifications

1. Dans la console Firebase , localisez la section Build dans le panneau de gauche.
2. Cliquez sur Authentification , puis cliquez sur l'onglet Méthode de connexion (ou cliquez ici pour y accéder directement).
3. Vous devriez voir Google comme un fournisseur de connexion activé.

7. Configurer une base de données Firestore et ses règles de sécurité

Pour l'application Web de cet atelier de programmation, vous stockerez les messages entre les utilisateurs finaux dans une base de données Firestore.

1. Pour activer les API requises et provisionner l'instance de base de données, ajoutez votre fichier main.tf avec les blocs de ressources suivants :
   
   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. Remplacez <NAME_OF_DESIRED_REGION> par la région dans laquelle vous souhaitez que la base de données réside.
   
   Lorsque vous développez une application de production, vous souhaiterez qu'elle se trouve dans une région proche de la majorité des utilisateurs et commune avec d'autres services Firebase, comme Cloud Functions. Pour cet atelier de programmation, vous pouvez utiliser us-east1 (Caroline du Sud) ou utiliser la région la plus proche de chez vous (voir Emplacements Cloud Firestore ).
3. Chaque instance de base de données Firestore accessible à Firebase doit être protégée par les règles de sécurité Firebase .
   
   L'exemple de code de cet atelier de programmation fournit un ensemble de règles Firestore sécurisées dans le fichier firestore.rules , que vous pouvez trouver à la racine du répertoire web .
4. Ajoutez votre fichier main.tf avec les blocs de ressources suivants pour effectuer les opérations suivantes :
   • Créez un ensemble de règles de sécurité Firebase à partir du fichier firestore.rules local.
   • Libérez l'ensemble de règles pour l'instance Firestore.
   Notez que ces blocs de ressources équivalent à cliquer sur le bouton Publier dans la console Firebase ou à exécuter 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. Exécutez terraform apply pour provisionner la base de données Firestore et déployer ses règles de sécurité.
6. Vérifiez que la base de données est provisionnée et que ses règles de sécurité sont déployées :
   1. Dans la console Firebase , localisez la section Build dans le panneau de gauche.
   2. Accédez à la section Base de données Firestore , puis cliquez sur l'onglet Règles .
   

8. Configurer un bucket Cloud Storage et ses règles de sécurité

Pour l'application Web de cet atelier de programmation, vous stockerez les images partagées entre les utilisateurs finaux dans un bucket Cloud Storage.

1. Pour activer les API requises et provisionner votre bucket Cloud Storage par défaut, ajoutez votre fichier main.tf avec les blocs de ressources suivants.
   
   Notez que le bucket Cloud Storage par défaut de votre projet est provisionné via Google App Engine et doit avoir le même emplacement que votre base de données Firestore. Consultez Emplacements App Engine pour plus d'informations.
   
   Si vous souhaitez plusieurs buckets dans votre projet, provisionnez-les à l'aide de la ressource google_storage_bucket (non présentée dans cet atelier de programmation).
   
   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. Chaque bucket Cloud Storage accessible à Firebase doit être protégé par les règles de sécurité Firebase .
   
   L'exemple de code de cet atelier de programmation fournit un ensemble de règles Firestore sécurisées dans le fichier storage.rules , que vous pouvez trouver à la racine du répertoire web .
3. Ajoutez votre fichier main.tf avec les blocs de ressources suivants pour effectuer les opérations suivantes :
   • Créez un ensemble de règles de sécurité Firebase à partir du fichier local.
   • Libérez l'ensemble de règles pour le compartiment de stockage.
   Notez que ces blocs de ressources équivalent à cliquer sur le bouton Publier dans la console Firebase ou à exécuter 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. Exécutez terraform apply pour provisionner le bucket Cloud Storage par défaut et déployer ses règles de sécurité.
5. Vérifiez que le bucket est provisionné et que ses règles de sécurité sont déployées :
   1. Dans la console Firebase , localisez la section Build dans le panneau de gauche.
   2. Accédez à la section Stockage , puis cliquez sur l'onglet Règles .
   

9. Exécutez votre application localement

Vous êtes maintenant prêt à exécuter votre application Web pour la première fois ! Vous utiliserez l' émulateur Firebase Hosting pour diffuser votre application localement.

1. Ouvrez une nouvelle fenêtre de terminal et, à partir du répertoire web , exécutez la commande Firebase CLI suivante pour démarrer l'émulateur :

   firebase emulators:start --project=<PROJECT_ID>
   

2. Dans votre navigateur, ouvrez votre application Web à l'URL locale renvoyée par la CLI (généralement http://localhost:5000 ).

Vous devriez voir l'interface utilisateur de votre application FriendlyChat, qui ne fonctionne pas (encore !). L'application n'est pas encore connectée à Firebase, mais elle le sera une fois les prochaines étapes de cet atelier de programmation terminées !

Notez que chaque fois que vous apportez des modifications à votre application Web (comme vous le ferez dans les étapes suivantes de cet atelier de programmation), actualisez votre navigateur pour mettre à jour l'URL locale avec ces modifications.

10. Installer, configurer et initialiser Firebase

Pour qu'une application fonctionne avec Firebase, votre application a besoin du SDK Firebase et de la configuration Firebase pour votre projet Firebase.

L'exemple de code de cet atelier de programmation est déjà une application fonctionnelle avec toutes les dépendances et fonctions requises pour utiliser divers produits Firebase dans l'application. Vous pouvez consulter web/package.json et web/src/index.js si vous souhaitez voir ce qui a déjà été fait.

Même si l'exemple de code est en grande partie complet, vous devez encore effectuer quelques opérations pour que votre application fonctionne, notamment : installer le SDK Firebase, démarrer votre build, ajouter la configuration Firebase à votre application et enfin initialiser Firebase.

Installez le SDK Firebase et démarrez la construction de votre webpack

Vous devez exécuter quelques commandes pour démarrer la construction de votre application.

1. Ouvrez une nouvelle fenêtre de terminal.
2. Assurez-vous que vous êtes à la racine du répertoire web .
3. Exécutez npm install pour télécharger le SDK Firebase.
4. Exécutez npm update pour mettre à jour toutes les dépendances.
5. Exécutez npm run start pour démarrer le webpack.

Pour le reste de l'atelier de programmation, webpack reconstruira désormais continuellement votre code source.

Ajoutez votre configuration Firebase à votre application

Vous devez également ajouter votre configuration Firebase à votre application afin que les SDK Firebase sachent quel projet Firebase vous souhaitez qu'ils utilisent.

Pour cet atelier de programmation, vous disposez de deux options différentes pour obtenir votre configuration Firebase :

• Option 1 : Obtenez votre configuration Firebase depuis la console Firebase.
• Option 2 : Obtenez votre configuration Firebase via Terraform.

Option 1 : obtenez la configuration depuis la console Firebase et ajoutez-la à votre base de code

1. Dans la console Firebase, accédez aux paramètres de votre projet .
2. Faites défiler jusqu'à la carte Vos applications , puis sélectionnez votre application Web.
3. Sélectionnez Config dans le volet d'extrait de code du SDK Firebase, puis copiez l'extrait de configuration.
4. Collez votre configuration dans le fichier web/src/firebase-config.js de votre application, comme ceci :
   
   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>",
   };
   
   ...
   

Option 2 : Obtenez la configuration via Terraform et ajoutez-la à votre base de code

Vous pouvez également obtenir votre configuration Firebase via Terraform comme valeur de sortie dans la CLI.

1. Dans votre fichier main.tf , recherchez votre bloc de ressources google_firebase_web_app (le bloc qui a enregistré une application Web avec votre projet).
2. Immédiatement après ce bloc, ajoutez les blocs suivants :
   
   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. Étant donné que le bloc data et le bloc output ne sont en aucun cas destinés à modifier l'infrastructure, il vous suffit d'exécuter les commandes suivantes.
   1. Pour charger la configuration Firebase de votre application Web dans l'état Terraform de votre répertoire, exécutez cette commande :

      terraform refresh
      

   2. Pour imprimer les valeurs de configuration Firebase, exécutez cette commande :

      terraform output –json
      

      Voici un exemple de sortie d'une configuration. Votre sortie imprimée contiendra les valeurs de votre projet et de votre application.

      {
        "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. Copiez les valeurs à partir de la carte value .
5. Collez ces valeurs (votre configuration) dans le fichier web/src/firebase-config.js de votre application, comme ceci :
   
   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",
   };
   
   ...
   

Initialisez Firebase dans votre application

Enfin, pour initialiser Firebase, ajoutez le fichier web/src/index.js de votre application avec ce qui suit :

index.js

...

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

Essayez votre application

Maintenant que tout est configuré pour Firebase, vous pouvez essayer votre application Web fonctionnelle.

1. Actualisez le navigateur qui dessert votre application.
2. Vous devriez maintenant pouvoir vous connecter avec Google et commencer à publier des messages dans le chat. Si vous avez des fichiers image, vous pouvez même les télécharger !

11. Répliquez votre configuration dans tous les environnements

Terraform excelle dans la gestion de plusieurs infrastructures configurées de manière similaire (par exemple, la mise en place d'un projet Firebase intermédiaire similaire à un projet de production).

Dans cet atelier de programmation, vous allez créer un deuxième projet Firebase qui servira d'environnement de préproduction.

Pour répliquer une configuration existante afin de créer ce projet intermédiaire, vous disposez de deux options :

• Option 1 : Faire une copie de la configuration Terraform.
  Cette option offre la plus grande flexibilité quant à la mesure dans laquelle le projet répliqué peut différer du projet source.
• Option 2 : Réutiliser les configurations avec for_each .
  Cette option offre davantage de réutilisation du code si chaque projet ne doit pas différer de manière significative et si vous souhaitez propager les modifications à tous les projets en même temps.

Option 1 : faire une copie de la configuration Terraform

Cette option offre la plus grande flexibilité quant à la mesure dans laquelle le projet répliqué peut différer du projet source, par exemple en ayant des applications avec des noms d'affichage différents et des déploiements par étapes.

1. À la racine de votre répertoire web , créez un nouveau fichier de configuration Terraform appelé main_staging.tf .
2. Copiez tous les blocs de ressources de votre fichier main.tf (à l'exception des blocs terraform et provider ), puis collez-les dans votre fichier main_staging.tf .
3. Vous devez ensuite modifier chacun de vos blocs de ressources répliqués dans main_staging.tf pour qu'ils fonctionnent avec votre projet intermédiaire :
   • Étiquettes de ressources : utilisez un nouveau nom pour éviter les conflits. Par exemple, renommez resource "google_project" "default" en resource "google_project" "staging" .
   • Références de ressources : mettez à jour chacune d’entre elles. Par exemple, mettez à jour google_firebase_project.default.project vers google_firebase_project.staging.project .
   Vous pouvez trouver la configuration complète d'un fichier main_staging.tf dans le dépôt GitHub de cet atelier de programmation :
   
   web/terraform-checkpoints/replicate-config/main_staging-copypaste.tf
   
   Si vous souhaitez utiliser cette configuration, assurez-vous de procéder comme suit :
   1. Copiez la configuration depuis main_staging-copypaste.tf , puis collez-la dans votre fichier main_staging.tf .
   2. Dans votre fichier main_staging.tf , procédez comme suit :
      • Dans le bloc de ressources google_project , mettez à jour l'attribut name , l'attribut project-id et (si vous avez configuré l'authentification via Terraform) l'attribut billing_account avec vos propres valeurs.
      • Dans le bloc de ressources google_firebase_web_app , mettez à jour l'attribut display_name avec votre propre valeur.
      • Dans les blocs de ressources google_firestore_database et google_app_engine_application , mettez à jour les attributs location_id avec votre propre valeur.
   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. Exécutez terraform apply pour provisionner votre nouveau projet Firebase « intermédiaire » et toutes ses ressources et activer ses services.
5. Vérifiez que tout a été provisionné et activé comme prévu en les vérifiant dans la console Firebase comme auparavant.

Option 2 : Réutiliser les configurations avec for_each

Cette option offre davantage de réutilisation du code si chaque projet ne doit pas différer de manière significative et si vous souhaitez propager les modifications à tous les projets en même temps. Il utilise le méta-argument for_each dans le langage Terraform.

1. Ouvrez votre fichier main.tf
2. Dans chaque bloc de ressources que vous souhaitez répliquer, ajoutez un méta-argument for_each , comme ceci :
   
   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.
   

   Vous pouvez trouver la configuration complète d'un fichier main.tf qui utilise le méta-argument for_each dans le dépôt GitHub de cet atelier de programmation :
   
   web/terraform-checkpoints/replicate-config/main-foreach.tf
   
   Si vous souhaitez utiliser cette configuration, assurez-vous de procéder comme suit :
   1. Copiez la configuration depuis main-foreach.tf , puis collez-la dans votre fichier main.tf
   2. Dans votre fichier main.tf , procédez comme suit :
      • Dans le bloc de ressources google_project , mettez à jour l'attribut name , l'attribut project-id et (si vous configurez l'authentification via Terraform) l'attribut billing_account avec vos propres valeurs.
      • Dans le bloc de ressources google_firebase_web_app , mettez à jour l'attribut display_name avec votre propre valeur.
      • Dans les blocs de ressources google_firestore_database et google_app_engine_application , mettez à jour les attributs location_id avec votre propre valeur.
3. Au lieu d'appliquer cette configuration immédiatement, il est important de comprendre et de résoudre certaines choses sur la façon dont Terraform interprète cette configuration par rapport à l'infrastructure existante.
   1. À l'heure actuelle, si vous avez appliqué cette configuration qui utilise for_each , les adresses de ressource ressembleraient à ce qui suit:

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

      Cependant, le projet existant que vous avez créé dans la première partie de ce CodeLab est connu pour Terraform comme le suivant:

      google_project.default
      google_firebase_project.default
      google_firebase_android_app.default
      

   2. Exécutez terraform plan pour voir quelles actions Terraform prendrait compte tenu de l'état actuel.
      
      La sortie devrait montrer que Terraform supprimerait le projet que vous avez créé dans la première partie de ce CodeLab et créerait deux nouveaux projets. En effet, Terraform ne sait pas que le projet de l'adresse google_project.default a été déplacé vers la nouvelle adresse google_project.default["prod"] .
   3. Pour résoudre ce problème, exécutez la commande terraform state mv :

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

   4. De même, pour corriger tous les autres blocs de ressources, exécutez terraform state mv pour google_firebase_project , google_firebase_web_app et tous les autres blocs de ressources dans votre fichier main.tf
   5. Maintenant, si vous exécutez à nouveau terraform plan , cela ne devrait pas montrer que Terraform supprimerait le projet que vous avez créé dans la première partie de ce CodeLab.
4. Exécuter terraform apply pour provisionner votre nouveau projet de base de feu "Staging" et toutes ses ressources et activer ses services.
5. Vérifiez que tout a été fourni et activé comme prévu en les vérifiant dans la console Firebase comme auparavant.

12. Étape bonus: Déployez vos applications de mise en scène et de prod

1. Dans la base de code de votre application, modifiez plutôt le firebase-config.js pour utiliser la configuration de Firebase à partir de votre projet de mise en scène.
   
   Pour vous rappeler comment obtenir votre configuration de base de feu et l'ajouter à votre application, consultez l'étape précédente de ce codelab, ajoutez votre configuration de base de feu à votre application.
2. À la racine de votre répertoire web , exécutez la commande suivante pour déployer votre application dans votre projet Firebase de mise en scène.

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

3. Ouvrez votre application de mise en scène dans le navigateur via l'URL imprimé dans la sortie du firebase deploy . Essayez de vous connecter, d'envoyer des messages et de télécharger des images.
   
   Lorsque vous déployez une application dans un projet Firebase, il utilise de vraies ressources de base de feu, et non des ressources émulées. Lorsque vous interagissez avec votre application de mise en scène, vous devriez voir que les données et les images apparaissent dans votre projet de stadification dans la console Firebase.
4. Après avoir testé votre application en stadification, modifiez le firebase-config.js pour utiliser la configuration Firebase du projet ProD (le premier projet que vous avez créé dans ce CodeLab).
5. À la racine de votre répertoire web , exécutez la commande suivante pour déployer votre application dans votre projet Firebase de production.

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

6. Ouvrez votre application de production dans le navigateur via l'URL imprimé dans la sortie du firebase deploy . Essayez de vous connecter, d'envoyer des messages et de télécharger des images.
   
   Vous devriez voir que les données et les images apparaissent dans votre projet de production dans la console Firebase.
7. Lorsque vous avez fini d'interagir avec les deux applications pour ce CodeLab, vous pouvez empêcher Firebase de les servir. Exécutez la commande suivante pour chacun de vos projets:

   firebase hosting:disable --project=<STAGING_PROJECT_ID>
   

   firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>
   

13. Félicitations!

Vous avez utilisé Terraform pour configurer une application Web de chat en temps réel! Et vous avez suivi les meilleures pratiques pour les environnements de développement en créant des projets de base d'incendie séparés pour la mise en scène et les prod.

Ce que nous avons couvert

• Utilisation de la CLI Terraform pour gérer les ressources cloud
• Utilisation de Terraform pour configurer les produits Firebase (authentification, Firestore, Storage Cloud et Règles de sécurité)
• Exécution et tester une application Web localement à l'aide de la suite d'émulation locale Firebase
• Importation de Firebase dans une application Web
• Utilisation de Terraform pour reproduire une configuration dans plusieurs environnements

Pour plus d'informations sur Firebase et Terraform, visitez notre documentation . Vous pouvez trouver une liste de tous les produits Firebase avec support Terraform, exemples de configurations Terraform pour les cas d'utilisation courants et le dépannage utile et la FAQ.