Richten Sie Firebase-Projekte und -Produkte über Terraform ein und verwalten Sie sie

1. Einleitung

Ziele

Mit Terraform können Sie ein Firebase-Projekt einrichten und verwalten, einschließlich der programmgesteuerten Konfiguration von Infrastruktur und Firebase-Produkten.

In diesem Codelab wird zunächst beschrieben, wie Sie eine Terraform-Konfigurationsdatei erstellen, um ein neues Firebase-Projekt zu erstellen. Anschließend wird erläutert, wie Sie die Apps und Firebase-Produkte konfigurieren, die Sie in diesem Projekt verwenden möchten. Wir behandeln auch die Grundlagen der Terraform-Befehlszeile, wie die Vorschau der vorzunehmenden Änderungen und deren anschließende Implementierung.

Wenn Sie lernen möchten, wie Sie Firebase-Projekte und -Produkte mit Terraform einrichten und verwalten, dann ist dieses Codelab genau das Richtige für Sie!

Was Sie lernen werden

  • So erstellen Sie eine Terraform-Konfigurationsdatei ( *.tf )
  • So verwenden Sie Terraform-CLI-Befehle zur Verwaltung Ihrer Infrastruktur
  • So ändern Sie Ihre Konfiguration, um Ihre Ressourcen und Dienste zu aktualisieren
  • So wenden Sie Ihre Konfiguration auf eine echte Web-App an (genannt Friendly Chat )
  • So definieren Sie parallele (und synchrone) Konfigurationen in verschiedenen Umgebungen (Produktion, Staging usw.)

Was du brauchen wirst

Um mit diesem Codelab erfolgreich zu sein, benötigen Sie grundlegende Kenntnisse in Terraform und seiner Terminologie, einschließlich der folgenden Voraussetzungen:

Dieses Codelab bietet eine echte Beispiel-App, mit der Sie testen und interagieren können, was Sie über Terraform bereitstellen. Dazu benötigen Sie Folgendes:

  • Der Beispielcode für eine Web-App – laden Sie diesen Code im nächsten Schritt des Codelabs herunter
  • Der Paketmanager npm (der normalerweise mit Node.js geliefert wird) – installieren Sie diese Tools
  • Die Firebase-CLI – installieren Sie diese CLI und melden Sie sich an

2. Holen Sie sich den Startcode

In diesem Codelab können Sie mit einer echten Web-App testen, was Sie über Terraform bereitstellen. Wir empfehlen, dies zu tun, damit Sie alle Schritte verstehen, die zur Verwendung der von Terraform bereitgestellten Ressourcen erforderlich sind.

Klonen Sie das GitHub-Repository des Codelab über die Befehlszeile:

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

Alternativ können Sie, wenn Sie Git nicht installiert haben, das Repository als ZIP-Datei herunterladen .

3. Erstellen Sie eine Terraform-Konfiguration

Terraform eingerichtet

  1. Navigieren Sie in der Codebasis der heruntergeladenen Beispiel-App zum Stammverzeichnis des web .
  2. Erstellen Sie im Stammverzeichnis dieses Verzeichnisses eine Terraform-Konfigurationsdatei namens main.tf mit der folgenden Ersteinrichtung:

    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
}

Jeder der google-beta Anbieter verfügt über ein Attribut namens user_project_override , das bestimmt, wie die Vorgänge von Terraform auf Kontingente überprüft werden. Für die Bereitstellung der meisten Ressourcen sollten Sie user_project_override = true verwenden, was bedeutet, dass Sie das Kontingent mit Ihrem eigenen Firebase-Projekt vergleichen. Um Ihr neues Projekt jedoch so einzurichten, dass es Kontingentprüfungen akzeptiert, müssen Sie zunächst user_project_override=false verwenden. Mithilfe der Terraform- alias Syntax können Sie in den nächsten Schritten dieses Codelabs zwischen den beiden Anbieter-Setups unterscheiden.

Initialisieren Sie Terraform im Verzeichnis

Wenn Sie zum ersten Mal eine neue Konfiguration erstellen, müssen Sie den in der Konfiguration angegebenen Anbieter herunterladen.

Um diese Initialisierung durchzuführen, führen Sie den folgenden Befehl im Stammverzeichnis desselben Verzeichnisses wie Ihre main.tf -Konfigurationsdatei aus:

terraform init

4. Erstellen Sie ein Firebase-Projekt über Terraform

Beim „Erstellen eines Firebase-Projekts“ ist es wichtig, sich daran zu erinnern, dass es sich bei jedem Firebase-Projekt tatsächlich um ein Google Cloud-Projekt handelt, für das lediglich die Firebase-Dienste aktiviert sind.

Fügen Sie Blöcke für das zugrunde liegende Google Cloud-Projekt und die APIs hinzu

  1. Stellen Sie zunächst das zugrunde liegende Google Cloud-Projekt bereit.

    Fügen Sie Ihrer main.tf Konfigurationsdatei den folgenden Ressourcenblock hinzu.

    Sie müssen Ihren eigenen Projektnamen (z. B. "Terraform FriendlyChat Codelab" ) und Ihre eigene Projekt-ID (z. B. "terraform-codelab-your-initials" ) angeben. Beachten Sie, dass der name nur innerhalb von Firebase-Schnittstellen verwendet wird und für Endbenutzer nicht sichtbar ist. Der Wert project_id identifiziert Ihr Projekt jedoch eindeutig für Google. Stellen Sie daher sicher, dass Sie einen eindeutigen Wert angeben. 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. Als Nächstes müssen Sie die erforderlichen zugrunde liegenden APIs aktivieren: die Service Usage API und die Firebase Management API.

    Diese API-Aktivierung erfolgt normalerweise im Hintergrund, wenn Sie die Firebase-Konsole zum Erstellen eines Firebase-Projekts verwenden. Terraform muss jedoch ausdrücklich angewiesen werden, diese Aktivierung durchzuführen.

    Fügen Sie Ihrer main.tf Konfigurationsdatei (direkt unter dem Block, der das neue Cloud-Projekt erstellt) den folgenden Ressourcenblock hinzu:

    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
}
    Durch die Aktivierung der Service Usage API kann Ihr neues Projekt Kontingentprüfungen akzeptieren! Daher sollten Sie für alle nachfolgenden Ressourcenbereitstellungen und Dienstaktivierungen den Anbieter mit user_project_override verwenden (kein Alias ​​erforderlich).

Fügen Sie einen Block hinzu, um Firebase-Dienste zu aktivieren

Das Allerletzte, was zum „Erstellen eines Firebase-Projekts“ erforderlich ist, ist die Aktivierung von Firebase-Diensten für das Projekt.

Fügen Sie in Ihrer main.tf Konfigurationsdatei den folgenden Ressourcenblock hinzu.

Beachten Sie, wie oben erwähnt, dass dieser Ressourcenblock den Anbieter mit user_project_override verwendet (kein Alias ​​erforderlich).

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

Im Ressourcenblock oben fällt Ihnen möglicherweise die depends_on Klausel auf, die Terraform anweist, auf die Aktivierung der zugrunde liegenden APIs zu warten. Ohne diese Klausel kennt Terraform die Abhängigkeit nicht und kann bei der parallelen Bereitstellung von Ressourcen zu Fehlern führen.

Wenden Sie die Konfiguration an

  1. Um die neuen Ressourcen bereitzustellen und die in Ihrer Konfigurationsdatei angegebenen APIs zu aktivieren, führen Sie den folgenden Befehl im Stammverzeichnis desselben Verzeichnisses wie Ihre main.tf Datei (die web sein sollte) aus:
    terraform apply
  2. Im Terminal druckt Terraform einen Aktionsplan aus, den es ausführen wird.

    Wenn alles wie erwartet aussieht, genehmigen Sie die Aktionen, indem Sie yes eingeben.

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

Beachten Sie, dass Sie stattdessen den Befehl terraform plan verwenden können, wenn Sie nur eine Vorschau der Änderungen ohne Anwendung benötigen.

Validieren Sie die Änderungen

Nachdem Terraform die Ausführung beendet hat, können Sie den Status aller von Terraform bereitgestellten Ressourcen und aktivierten Dienste überprüfen, indem Sie den folgenden Befehl ausführen:

terraform show

Hier ist ein Beispiel dafür, was Sie gedruckt sehen sollten. Ihr Bundesstaat enthält projektspezifische Werte.

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

Alternativ können Sie überprüfen, ob das Projekt erstellt wurde, indem Sie es in der Firebase-Konsole anzeigen.

The Terraform FriendlyChat Codelab project selected on the Firebase console

5. Registrieren Sie Ihre Firebase-App über Terraform

Um Firebase verwenden zu können, müssen Sie jede Plattformvariante Ihrer App in Ihrem Firebase-Projekt registrieren. In diesem Codelab verwenden Sie eine echte App, um das, was Sie über Terraform bereitstellen, zu testen und damit zu interagieren. Da es sich bei dieser App um eine Web-App handelt, müssen Sie Terraform anweisen, eine Firebase-Web-App in Ihrem neu erstellten Firebase-Projekt zu registrieren.

Fügen Sie einen Block hinzu, um die Web-App zu registrieren

Um Ihre Web-App in Ihrem Firebase-Projekt zu registrieren, hängen Sie den folgenden Ressourcenblock an Ihre main.tf Datei an.

Sie müssen Ihren eigenen display_name für Ihre Web-App angeben. Beachten Sie, dass dieser Name nur innerhalb von Firebase-Schnittstellen verwendet wird und für Endbenutzer nicht sichtbar ist.

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

Wenden Sie die Konfiguration an

  1. Um die neue Ressource bereitzustellen, führen Sie den folgenden Befehl im Stammverzeichnis desselben Verzeichnisses aus wie Ihre main.tf Datei (die web lauten sollte).
    terraform apply
    Beachten Sie, dass dieser Befehl kein neues Google Cloud-Projekt neu erstellt. Terraform erkennt, dass ein Projekt mit der angegebenen Projekt-ID bereits existiert, vergleicht den aktuellen Status des Projekts mit dem, was in der .tf Datei enthalten ist, und nimmt alle gefundenen Änderungen vor.
  2. Sehen Sie sich den gedruckten Aktionsplan an. Wenn alles wie erwartet aussieht, geben Sie yes ein und drücken Sie die Eingabetaste, um die Aktionen zu genehmigen.

Validieren Sie die Änderungen

Sie können den Status der neu bereitgestellten Ressource überprüfen, indem Sie den folgenden Befehl ausführen:

terraform show

Alternativ können Sie überprüfen, ob die App erfolgreich in Ihrem Projekt registriert wurde, indem Sie sie in der Firebase-Konsole anzeigen. Gehen Sie zu Projekteinstellungen und scrollen Sie dann nach unten zum Abschnitt Ihre Apps .

6. Richten Sie die Firebase-Authentifizierung ein

Die Authentifizierung ist ein wichtiger Bestandteil jeder App. Damit sich Endbenutzer mit ihren Google-Konten bei Ihrer Web-App anmelden können, können Sie die Firebase-Authentifizierung aktivieren und die Methode „Anmeldung mit Google“ einrichten.

Beachten Sie, dass wir in diesem Codelab zwei verschiedene Optionen zum Einrichten der Firebase-Authentifizierung bereitstellen:

  • Option 1 (empfohlen) : Richten Sie die Firebase-Authentifizierung in der Konsole ein, für die kein GCIP erforderlich ist.
    • Wenn Sie diese Option verwenden, müssen Sie Ihr neues Projekt nicht mit einem Cloud-Rechnungskonto verknüpfen.
  • Option 2 : Richten Sie die Firebase-Authentifizierung über Terraform mithilfe der Google Cloud Identity Platform (GCIP)-APIs ein.
    • Die Verwendung dieser Option bedeutet, dass Sie Ihr neues Projekt mit einem Cloud-Rechnungskonto verknüpfen müssen, da GCIP erfordert, dass das Projekt im Blaze-Preisplan enthalten ist.

Option 1: Richten Sie die Authentifizierung über die Firebase-Konsole ein

Um die Firebase-Authentifizierung über die Firebase-Konsole einzurichten, muss Ihr Projekt nicht im Blaze-Preisplan enthalten sein.

So richten Sie die Firebase-Authentifizierung ein und melden sich bei Google an:

  1. Suchen Sie in der Firebase-Konsole im linken Bereich den Abschnitt „Build“ .
  2. Klicken Sie auf Authentifizierung , klicken Sie auf Erste Schritte und dann auf die Registerkarte Anmeldemethode (oder klicken Sie hier , um direkt dorthin zu gelangen).
  3. Klicken Sie auf Neuen Anbieter hinzufügen und wählen Sie im Abschnitt Zusätzliche Anbieter die Option Google aus.
  4. Aktivieren Sie den Schalter „Aktivieren“ .
  5. Legen Sie den öffentlich sichtbaren Namen Ihrer App auf etwa FriendlyChat fest (dieser muss nicht global eindeutig sein).
  6. Wählen Sie im Dropdown-Menü eine Projekt-Support-E-Mail aus und klicken Sie dann auf Speichern . Configuring Firebase Auth on the Firebase console
  7. Sie sollten Google als aktivierten Anmeldeanbieter sehen. Firebase console Authentication page: Google sign-in enabled

Option 2: Richten Sie die Authentifizierung über Terraform mit den APIs der Google Cloud Identity Platform (GCIP) ein

Um die Firebase-Authentifizierung über Terraform einzurichten, müssen Sie GCIP-APIs verwenden, was bedeutet, dass das Projekt im Blaze-Preisplan enthalten sein muss. Sie aktualisieren Ihr Firebase-Projekt, um den Blaze-Plan zu verwenden, indem Sie dem Projekt ein Cloud-Rechnungskonto zuordnen.

Aktivieren Sie die Abrechnung über Terraform

  1. Wenn Sie noch kein Cloud-Rechnungskonto haben, besteht der erste Schritt darin, ein neues Konto in der Google Cloud Console zu erstellen. Notieren Sie sich dabei die Rechnungskonto-ID . Die Rechnungskonto-ID finden Sie auf der Rechnungsseite in der mit Ihrem Projekt verknüpften Rechnungskonto-ID . Enabling a billing account using the Google Cloud console
  2. Um die Abrechnung in Ihrem Projekt über Terraform zu aktivieren, fügen Sie ein billing_account Attribut zur vorhandenen google_project Ressource in Ihrer main.tf Datei hinzu:

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

...

Aktivieren Sie die Firebase-Authentifizierung und melden Sie sich über Terraform bei Google an

  1. Um die Firebase-Authentifizierung mit GCIP bereitzustellen, fügen Sie Ihrer main.tf Datei die folgenden Ressourcenblöcke hinzu:

    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. Um die Anmeldung bei Google zu ermöglichen, benötigen Sie einen OAuth-Client . Gehen Sie zum Abschnitt „APIs & Dienste“ der Google Cloud Console, um diese Einrichtung durchzuführen.
  3. Da Sie zum ersten Mal eine Client-ID für dieses Projekt erstellen, müssen Sie Ihren OAuth-Zustimmungsbildschirm konfigurieren.
    1. Öffnen Sie die OAuth-Zustimmungsbildschirmseite und wählen Sie dann das gerade erstellte Projekt aus.
    2. Legen Sie den Benutzertyp auf „Extern“ fest und klicken Sie dann auf „Erstellen“ .
    3. Führen Sie im nächsten Bildschirm die folgenden Schritte aus und klicken Sie dann auf Speichern und fortfahren .
      • Legen Sie den öffentlich zugänglichen App-Namen Ihrer App auf etwa FriendlyChat fest (dieser muss nicht global eindeutig sein).
      • Wählen Sie im Dropdown-Menü eine E-Mail-Adresse für den Benutzersupport aus.
      • Geben Sie eine E-Mail-Adresse für die Kontaktinformationen des Entwicklers ein.
    4. Führen Sie in den nächsten Bildschirmen Folgendes aus:
      • Akzeptieren Sie die Standardeinstellungen auf der Seite „Bereiche“ und klicken Sie dann auf „Speichern und fortfahren“ .
      • Akzeptieren Sie die Standardeinstellungen auf der Seite „Benutzer testen“ und klicken Sie dann auf „Speichern und fortfahren“ .
      • Überprüfen Sie die Zusammenfassung und klicken Sie dann auf Zurück zum Dashboard .
      Configuring an OAuth2 client using the Google Cloud console
  4. Richten Sie auf der Seite „Anmeldeinformationen“ einen OAuth-Client ein, indem Sie wie folgt vorgehen:
    1. Klicken Sie auf Anmeldeinformationen erstellen und wählen Sie OAuth-Client-ID aus.
    2. Wählen Sie im Dropdown- Menü Anwendungstyp die Option Webanwendung aus.
    3. Geben Sie im Feld „Name“ den Namen Ihrer App ein, zum Beispiel FriendlyChat (dieser muss nicht global eindeutig sein).
    4. Erlauben Sie der URL Ihrer App, diesen OAuth-Client zu verwenden, indem Sie Folgendes festlegen:
      • Klicken Sie unter „Autorisierte JavaScript-Ursprünge“ auf „URI hinzufügen“ und geben Sie ein
        https://<PROJECT_ID>.firebaseapp.com , wobei <PROJECT_ID> die Projekt-ID ist, die Sie in main.tf festgelegt haben.
      • Klicken Sie unter „Autorisierte Weiterleitungs-URIs“ auf „URI hinzufügen“ und geben Sie ein
        https://<PROJECT_ID>.firebaseapp.com/__/auth/handler , wobei <PROJECT_ID> die Projekt-ID ist, die Sie in main.tf festgelegt haben.
    5. Klicken Sie auf Speichern .
    Obtaining the OAuth2 Client ID and secret from the Google Cloud console Credentials page
  5. Um die Anmeldung bei Google mit Ihrer OAuth-Client-ID und Ihrem Client-Geheimnis zu ermöglichen, fügen Sie Ihrer main.tf Datei den folgenden Block hinzu:

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

Wenden Sie die Konfiguration an

  1. Um die Authentifizierung gemäß Ihrer Konfiguration einzurichten, führen Sie die folgenden Befehle im Stammverzeichnis desselben Verzeichnisses wie Ihre main.tf Datei aus (dies sollte web sein):
    export TF_VAR_oauth_client_secret="<YOUR_OAUTH_CLIENT_SECRET>"

    terraform apply
    Beachten Sie, dass durch das Ausführen terraform apply keine Neuerstellung erfolgt ein neues Google Cloud-Projekt. Terraform erkennt, dass bereits ein Projekt mit der angegebenen Projekt-ID vorhanden ist, und vergleicht den aktuellen Status des Projekts mit dem, was in der .tf Datei enthalten ist. Anschließend werden alle gefundenen Änderungen vorgenommen.
  2. Sehen Sie sich den gedruckten Aktionsplan an. Wenn alles wie erwartet aussieht, geben Sie yes ein und drücken Sie die Eingabetaste, um die Aktionen zu genehmigen.

Validieren Sie die Änderungen

  1. Suchen Sie in der Firebase-Konsole im linken Bereich den Abschnitt „Build“ .
  2. Klicken Sie auf Authentifizierung und dann auf die Registerkarte Anmeldemethode (oder klicken Sie hier , um direkt dorthin zu gelangen).
  3. Sie sollten Google als aktivierten Anmeldeanbieter sehen. Firebase console Authentication page: Google sign-in enabled

7. Richten Sie eine Firestore-Datenbank und ihre Sicherheitsregeln ein

Für die Web-App dieses Codelabs speichern Sie Nachrichten zwischen Endbenutzern in einer Firestore-Datenbank.

  1. Um die erforderlichen APIs zu aktivieren und die Datenbankinstanz bereitzustellen, hängen Sie Ihre main.tf Datei mit den folgenden Ressourcenblöcken an:

    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. Ändern Sie <NAME_OF_DESIRED_REGION> in die Region, in der sich die Datenbank befinden soll.

    Wenn Sie eine Produktions-App entwickeln, möchten Sie, dass diese sich in einer Region befindet, die der Mehrheit der Benutzer nahe kommt und mit anderen Firebase-Diensten wie Cloud Functions gemeinsam ist. Für dieses Codelab können Sie us-east1 (South Carolina) oder die Region in Ihrer Nähe verwenden (siehe Cloud Firestore-Standorte ).
  3. Jede Firestore-Datenbankinstanz, auf die Firebase zugreifen kann, muss durch Firebase-Sicherheitsregeln geschützt sein.

    Der Beispielcode dieses Codelabs stellt eine Reihe sicherer Firestore-Regeln in der Datei firestore.rules bereit, die Sie im Stammverzeichnis des web finden.
  4. Hängen Sie Ihre main.tf Datei mit den folgenden Ressourcenblöcken an, um Folgendes zu tun:
    • Erstellen Sie einen Regelsatz mit Firebase-Sicherheitsregeln aus der lokalen Datei firestore.rules .
    • Geben Sie den Regelsatz für die Firestore-Instanz frei.
    Beachten Sie, dass diese Ressourcenblöcke das Äquivalent zum Klicken auf die Schaltfläche „Veröffentlichen“ in der Firebase-Konsole oder zum Ausführen von firebase deploy --only firestore:rules bewirken.

    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. Führen Sie terraform apply , um die Firestore-Datenbank bereitzustellen und ihre Sicherheitsregeln bereitzustellen.
  6. Stellen Sie sicher, dass die Datenbank bereitgestellt und ihre Sicherheitsregeln bereitgestellt werden:
    1. Suchen Sie in der Firebase-Konsole im linken Bereich den Abschnitt „Build“ .
    2. Gehen Sie zum Abschnitt „Firestore-Datenbank“ und klicken Sie dann auf die Registerkarte „Regeln“ .
    Verifying Cloud Firestore rules using the Firebase console

8. Richten Sie einen Cloud Storage-Bucket und seine Sicherheitsregeln ein

Für die Web-App dieses Codelabs speichern Sie Bilder, die von Endbenutzern gemeinsam genutzt werden, in einem Cloud Storage-Bucket.

  1. Um die erforderlichen APIs zu aktivieren und Ihren Cloud Storage-Standard-Bucket bereitzustellen, hängen Sie Ihre main.tf Datei mit den folgenden Ressourcenblöcken an.

    Beachten Sie, dass der Standard-Cloud-Storage-Bucket für Ihr Projekt über Google App Engine bereitgestellt wird und denselben Speicherort wie Ihre Firestore-Datenbank haben muss. Weitere Informationen finden Sie unter App Engine-Standorte .

    Wenn Sie mehrere Buckets in Ihrem Projekt haben möchten, stellen Sie diese mit der Ressource google_storage_bucket bereit (in diesem Codelab nicht angezeigt).

    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. Jeder Cloud Storage-Bucket, auf den Firebase zugreifen kann, muss durch Firebase-Sicherheitsregeln geschützt sein.

    Der Beispielcode dieses Codelabs stellt eine Reihe sicherer Firestore-Regeln in der Datei storage.rules bereit, die Sie im Stammverzeichnis des web finden.
  3. Hängen Sie Ihre main.tf Datei mit den folgenden Ressourcenblöcken an, um Folgendes zu tun:
    • Erstellen Sie einen Regelsatz mit Firebase-Sicherheitsregeln aus der lokalen Datei.
    • Geben Sie den Regelsatz für den Storage-Bucket frei.
    Beachten Sie, dass diese Ressourcenblöcke das Äquivalent zum Klicken auf die Schaltfläche „Veröffentlichen “ in der Firebase-Konsole oder zum Ausführen von firebase deploy --only storage bewirken.

    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. Führen Sie terraform apply , um den standardmäßigen Cloud Storage-Bucket bereitzustellen und seine Sicherheitsregeln bereitzustellen.
  5. Stellen Sie sicher, dass der Bucket bereitgestellt und seine Sicherheitsregeln bereitgestellt sind:
    1. Suchen Sie in der Firebase-Konsole im linken Bereich den Abschnitt „Build“ .
    2. Gehen Sie zum Abschnitt „Speicher“ und klicken Sie dann auf die Registerkarte „Regeln“ .
    Verifying security rules using the Firebase console

9. Führen Sie Ihre App lokal aus

Jetzt können Sie Ihre Web-App zum ersten Mal ausführen! Sie verwenden den Firebase Hosting-Emulator, um Ihre App lokal bereitzustellen.

  1. Öffnen Sie ein neues Terminalfenster und führen Sie im web den folgenden Firebase-CLI-Befehl aus, um den Emulator zu starten:
    firebase emulators:start --project=<PROJECT_ID>
  2. Öffnen Sie in Ihrem Browser Ihre Web-App unter der lokalen URL, die von der CLI zurückgegeben wird (normalerweise http://localhost:5000 ).

Sie sollten die Benutzeroberfläche Ihrer FriendlyChat-App sehen, die (noch!) nicht funktioniert. Die App ist noch nicht mit Firebase verbunden, aber wenn Sie die nächsten Schritte dieses Codelabs ausführen, wird sie es sein!

Beachten Sie, dass Sie Ihren Browser jedes Mal aktualisieren, wenn Sie Änderungen an Ihrer Web-App vornehmen (wie in den folgenden Schritten dieses Codelabs), um die lokale URL mit diesen Änderungen zu aktualisieren.

10. Installieren, konfigurieren und initialisieren Sie Firebase

Damit eine App mit Firebase funktioniert, benötigt Ihre App das Firebase SDK und die Firebase-Konfiguration für Ihr Firebase-Projekt.

Der Beispielcode für dieses Codelab ist bereits eine funktionierende App mit allen Abhängigkeiten und erforderlichen Funktionen für die Verwendung verschiedener Firebase-Produkte in der App. Sie können in web/package.json und web/src/index.js nachsehen, wenn Sie sehen möchten, was bereits getan wurde.

Auch wenn der Beispielcode größtenteils vollständig ist, müssen Sie noch einige Dinge tun, um Ihre App zum Laufen zu bringen, darunter: das Firebase SDK installieren, Ihren Build starten, die Firebase-Konfiguration zu Ihrer App hinzufügen und schließlich Firebase initialisieren.

Installieren Sie das Firebase SDK und starten Sie Ihren Webpack-Build

Sie müssen einige Befehle ausführen, um mit der Erstellung Ihrer App zu beginnen.

  1. Öffnen Sie ein neues Terminalfenster.
  2. Stellen Sie sicher, dass Sie sich im Stammverzeichnis des web befinden.
  3. Führen Sie npm install , um das Firebase SDK herunterzuladen.
  4. Führen Sie npm update aus, um alle Abhängigkeiten zu aktualisieren.
  5. Führen Sie npm run start , um das Webpack zu starten.

Für den Rest des Codelabs wird Webpack Ihren Quellcode nun kontinuierlich neu erstellen.

Fügen Sie Ihre Firebase-Konfiguration zu Ihrer App hinzu

Sie müssen Ihrer App außerdem Ihre Firebase-Konfiguration hinzufügen, damit die Firebase-SDKs wissen, welches Firebase-Projekt sie verwenden sollen.

Für dieses Codelab haben Sie zwei verschiedene Möglichkeiten, Ihre Firebase-Konfiguration zu erhalten:

  • Option 1 : Rufen Sie Ihre Firebase-Konfiguration von der Firebase-Konsole ab.
  • Option 2 : Beziehen Sie Ihre Firebase-Konfiguration über Terraform.

Option 1: Rufen Sie die Konfiguration von der Firebase-Konsole ab und fügen Sie sie Ihrer Codebasis hinzu

  1. Gehen Sie in der Firebase-Konsole zu Ihren Projekteinstellungen .
  2. Scrollen Sie nach unten zur Karte „Ihre Apps“ und wählen Sie dann Ihre Web-App aus.
  3. Wählen Sie im Firebase SDK-Snippet-Bereich „Config“ aus und kopieren Sie dann den Konfigurations-Snippet.
  4. Fügen Sie Ihre Konfiguration wie folgt in die Datei web/src/firebase-config.js Ihrer App ein:

    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: Rufen Sie die Konfiguration über Terraform ab und fügen Sie sie Ihrer Codebasis hinzu

Alternativ können Sie Ihre Firebase-Konfiguration über Terraform als Ausgabewert in der CLI erhalten.

  1. Suchen Sie in Ihrer main.tf Datei Ihren Ressourcenblock google_firebase_web_app (den Block, der eine Web-App bei Ihrem Projekt registriert hat).
  2. Fügen Sie unmittelbar nach diesem Block die folgenden Blöcke hinzu:

    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. Da der data und der output nicht dazu gedacht sind, die Infrastruktur in irgendeiner Weise zu ändern, müssen Sie nur die folgenden Befehle ausführen.
    1. Um die Firebase-Konfiguration Ihrer Web-App in den Terraform-Status Ihres Verzeichnisses zu laden, führen Sie diesen Befehl aus:
      terraform refresh
    2. Um die Firebase-Konfigurationswerte zu drucken, führen Sie diesen Befehl aus:
      terraform output –json
      Das Folgende ist eine Beispielausgabe einer Konfiguration. Ihre gedruckte Ausgabe enthält die Werte Ihres Projekts und Ihrer 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. Kopieren Sie die Werte aus der value .
  5. Fügen Sie diese Werte (Ihre Konfiguration) wie folgt in die Datei web/src/firebase-config.js Ihrer App ein:

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

...

Initialisieren Sie Firebase in Ihrer App

Um Firebase zu initialisieren, hängen Sie schließlich Folgendes an die Datei web/src/index.js Ihrer App an:

index.js

...

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

Probieren Sie Ihre App aus

Nachdem nun alles für Firebase konfiguriert ist, können Sie Ihre funktionsfähige Web-App ausprobieren.

  1. Aktualisieren Sie den Browser, der Ihre App bereitstellt.
  2. Sie sollten sich jetzt bei Google anmelden und mit dem Posten von Nachrichten im Chat beginnen können. Wenn Sie Bilddateien haben, können Sie diese sogar hochladen!

11. Replizieren Sie Ihre Konfiguration umgebungsübergreifend

Terraform zeichnet sich durch die Verwaltung mehrerer ähnlich konfigurierter Infrastrukturen aus (z. B. die Einrichtung eines Staging-Firebase-Projekts, das einem Produktprojekt ähnelt).

In diesem Codelab erstellen Sie ein zweites Firebase-Projekt als Staging-Umgebung.

Um eine vorhandene Konfiguration zu replizieren, um dieses Staging-Projekt zu erstellen, haben Sie zwei Möglichkeiten:

  • Option 1 : Erstellen Sie eine Kopie der Terraform-Konfiguration.
    Diese Option bietet die größte Flexibilität hinsichtlich der Abweichungen zwischen dem replizierten Projekt und dem Quellprojekt.
  • Option 2 : Konfigurationen mit for_each wiederverwenden.
    Diese Option bietet mehr Code-Wiederverwendung, wenn sich die einzelnen Projekte nicht wesentlich unterscheiden sollen und Sie Änderungen gleichzeitig an alle Projekte weitergeben möchten.

Option 1: Erstellen Sie eine Kopie der Terraform-Konfiguration

Diese Option bietet die größte Flexibilität hinsichtlich der Abweichungen zwischen dem replizierten Projekt und dem Quellprojekt, z. B. bei Apps mit unterschiedlichen Anzeigenamen und gestaffelten Rollouts.

  1. Erstellen Sie im Stammverzeichnis Ihres web eine neue Terraform-Konfigurationsdatei mit dem Namen main_staging.tf .
  2. Kopieren Sie alle Ressourcenblöcke aus Ihrer main.tf Datei (mit Ausnahme der terraform und provider -Blöcke) und fügen Sie sie dann in Ihre main_staging.tf Datei ein.
  3. Anschließend müssen Sie jeden Ihrer replizierten Ressourcenblöcke in main_staging.tf ändern, damit sie mit Ihrem Staging-Projekt funktionieren:
    • Ressourcenbezeichnungen: Verwenden Sie einen neuen Namen, um Konflikte zu vermeiden. Benennen Sie beispielsweise resource "google_project" "default" in resource "google_project" "staging" um.
    • Ressourcenverweise: Aktualisieren Sie alle. Aktualisieren Sie beispielsweise google_firebase_project.default.project auf google_firebase_project.staging.project .
    Die vollständige Konfiguration einer main_staging.tf Datei finden Sie im GitHub-Repository dieses Codelabs:

    web/terraform-checkpoints/replicate-config/main_staging-copypaste.tf

    Wenn Sie diese Konfiguration verwenden möchten, stellen Sie sicher, dass Sie Folgendes tun:
    1. Kopieren Sie die Konfiguration aus main_staging-copypaste.tf und fügen Sie sie dann in Ihre Datei main_staging.tf ein.
    2. Gehen Sie in Ihrer main_staging.tf Datei wie folgt vor:
      • Aktualisieren Sie im Ressourcenblock google_project das Attribut name , das Attribut „ project-id “ und (wenn Sie die Authentifizierung über Terraform einrichten) das Attribut „ billing_account “ mit Ihren eigenen Werten.
      • Aktualisieren Sie im Ressourcenblock google_firebase_web_app das Attribut display_name mit Ihrem eigenen Wert.
      • Aktualisieren Sie in den Ressourcenblöcken google_firestore_database und google_app_engine_application die location_id Attribute mit Ihrem eigenen Wert.
    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. Führen Sie terraform apply , um Ihr neues „Staging“-Firebase-Projekt und alle seine Ressourcen bereitzustellen und seine Dienste zu aktivieren.
  5. Stellen Sie sicher, dass alles wie erwartet bereitgestellt und aktiviert wurde, indem Sie es wie zuvor in der Firebase-Konsole überprüfen.

Option 2: Konfigurationen mit for_each wiederverwenden

Diese Option bietet mehr Code-Wiederverwendung, wenn sich die einzelnen Projekte nicht wesentlich unterscheiden sollen und Sie Änderungen gleichzeitig an alle Projekte weitergeben möchten. Es verwendet das Metaargument for_each in der Terraform-Sprache.

  1. Öffnen Sie Ihre main.tf Datei.
  2. Fügen Sie in jeden Ressourcenblock, den Sie replizieren möchten, ein for_each -Metaargument hinzu, etwa so:

    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.
    Die vollständige Konfiguration einer main.tf Datei, die das Metaargument for_each verwendet, finden Sie im GitHub-Repository dieses Codelabs:

    web/terraform-checkpoints/replicate-config/main-foreach.tf

    Wenn Sie diese Konfiguration verwenden möchten, stellen Sie sicher, dass Sie Folgendes tun:
    1. Kopieren Sie die Konfiguration aus main-foreach.tf und fügen Sie sie dann in Ihre main.tf Datei ein.
    2. Gehen Sie in Ihrer main.tf Datei wie folgt vor:
      • Aktualisieren Sie im Ressourcenblock google_project das Namensattribut name , das project-id Attribut und (wenn Sie die Authentifizierung über Terraform einrichten) das Attribut billing_account mit Ihren eigenen Werten.
      • Aktualisieren Sie im Ressourcenblock google_firebase_web_app das Attribut display_name mit Ihrem eigenen Wert.
      • Aktualisieren Sie in den Ressourcenblöcken google_firestore_database und google_app_engine_application die Attribute location_id mit Ihrem eigenen Wert.
  3. Anstatt diese Konfiguration sofort anzuwenden, ist es wichtig, einige Dinge darüber zu verstehen und zu beheben, wie Teraform diese Konfiguration im Vergleich zur vorhandenen Infrastruktur interpretiert.
    1. Wenn Sie diese Konfiguration angewendet haben, die for_each verwendet, würden die Ressourcenadressen wie folgt aussehen:
      google_project.default
google_firebase_project.default
google_firebase_android_app.default

      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"]
      ist jedoch das vorhandene Projekt, das Sie im ersten Teil dieses Codelabs erstellt haben
    2. Führen Sie terraform plan aus, um zu sehen, welche Aktionen Terraform angesichts des aktuellen Zustands ergreifen würden.

      Die Ausgabe sollte zeigen, dass Terraform das Projekt löschen würde, das Sie im ersten Teil dieses Codelabs erstellt und zwei neue Projekte erstellen würden. Dies liegt daran, dass Terraform nicht weiß, dass das Projekt an der Adresse google_project.default in die neue Adresse google_project.default["prod"] verschoben wurde.
    3. Um dies zu beheben, führen Sie den Befehl terraform state mv aus:
      terraform state mv "google_project.default" "google_project.default[\"prod\"]"
    4. Um alle anderen Ressourcenblöcke zu beheben, führen Sie terraform state mv für google_firebase_project , google_firebase_web_app und alle anderen Ressourcenblöcke in Ihrer main.tf -Datei aus.
    5. Wenn Sie jetzt erneut terraform plan ausführen, sollte es nicht zeigen, dass Terraform das Projekt löschen würde, das Sie im ersten Teil dieses Codelabs erstellt haben.
  4. Run terraform apply für die Bereitstellung Ihres neuen "Staging" Firebase Project und alle seine Ressourcen und ermöglichen seine Dienste.
  5. Stellen Sie sicher, dass alles wie erwartet alles bereitgestellt und aktiviert wurde, indem Sie sie wie zuvor in der Firebase -Konsole überprüfen.

12. Bonusschritt: Bereitstellen Sie Ihre Inszenierungs- und Produkt -Apps bereit

  1. Ändern Sie in der Codebasis Ihrer App die firebase-config.js , um stattdessen die Firebase-Konfiguration aus Ihrem Staging-Projekt zu verwenden.

    Um sich daran zu erinnern, wie Sie Ihre Firebase -Konfiguration erhalten und Ihrer App hinzufügen können, finden Sie im früheren Schritt dieses Codelabs Ihre Firebase -Konfiguration zu Ihrer App.
  2. Führen Sie im Root Ihres web den folgenden Befehl aus, um Ihre App in Ihrem Staging Firebase -Projekt bereitzustellen.
    firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
  3. Öffnen Sie Ihre Staging -App im Browser über die URL, die in der Ausgabe von firebase deploy gedruckt ist. Versuchen Sie, sich anzumelden, Nachrichten zu senden und Bilder hochzuladen.

    Wenn Sie eine App für ein FireBase -Projekt bereitstellen, verwendet sie reale Firebase -Ressourcen und keine emulierten Ressourcen. Wenn Sie mit Ihrer Staging -App interagieren, sollten Sie Daten sehen, und Bilder werden in Ihrem Staging -Projekt in der Firebase -Konsole angezeigt.
  4. Ändern Sie nach dem Testen Ihrer App in Staging die firebase-config.js FireBase-config.js in die Firebase-Konfiguration des Produktprojekts (das erste Projekt, das Sie in diesem Codelab erstellt haben).
  5. Führen Sie im Root Ihres web den folgenden Befehl aus, um Ihre App in Ihrem Produktionsfeuerbasisprojekt bereitzustellen.
    firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
  6. Öffnen Sie Ihre Produktions -App im Browser über die URL, die in der Ausgabe von firebase deploy gedruckt ist. Versuchen Sie, sich anzumelden, Nachrichten zu senden und Bilder hochzuladen.

    Sie sollten Daten sehen und Bilder in Ihrem Produktionsprojekt in der Firebase -Konsole erscheinen.
  7. Wenn Sie mit den beiden Apps für dieses Codelab fertig werden, können Sie das Servieren von Firebase verhindern. Führen Sie den folgenden Befehl für jedes Ihrer Projekte aus:
    firebase hosting:disable --project=<STAGING_PROJECT_ID>

    firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>

13. Herzlichen Glückwunsch!

Sie haben Terraform verwendet, um eine Echtzeit-Chat-Webanwendung zu konfigurieren! Und Sie haben Best Practices für Entwicklungsumgebungen befolgt, indem Sie separate Firebase -Projekte für Inszenierung und Prodat erstellt haben.

Was wir abgedeckt haben

  • Nutzung der Terraform -CLI zur Verwaltung von Cloud -Ressourcen
  • Verwenden von Terraform zur Konfiguration von Firebase -Produkten (Authentifizierung, Firestore, Cloud -Speicher und Sicherheitsregeln)
  • Ausführen und Testen einer Web -App lokal mit der FireBase Local Emulator Suite
  • Importieren von Firebase in eine Web -App
  • Verwenden von Terraform, um eine Konfiguration über mehrere Umgebungen hinweg zu replizieren

Weitere Informationen zu Firebase und Terraform finden Sie in unserer Dokumentation . Sie finden eine Liste aller Firebase -Produkte mit Terraformunterstützung, Muster -Terraform -Konfigurationen für gemeinsame Anwendungsfälle sowie hilfreiche Fehlerbehebung und FAQ.