Konfiguruj projekty i produkty Firebase oraz zarządzaj nimi za pośrednictwem Terraform

1. Wstęp

Cele

Za pomocą Terraform możesz skonfigurować projekt Firebase i zarządzać nim, w tym programową konfiguracją infrastruktury i produktów Firebase.

W tym laboratorium z programowania najpierw opisano, jak zbudować plik konfiguracyjny Terraform w celu utworzenia nowego projektu Firebase, a następnie opisano, jak skonfigurować aplikacje i produkty Firebase, których chcesz używać w tym projekcie. Omówimy także podstawy wiersza poleceń Terraform, takie jak podgląd zmian, które należy wprowadzić, a następnie ich wdrożenie.

Jeśli chcesz dowiedzieć się, jak konfigurować projekty i produkty Firebase oraz zarządzać nimi za pomocą Terraform, to laboratorium z programowania jest dla Ciebie!

Czego się dowiesz

  • Jak utworzyć plik konfiguracyjny Terraform ( *.tf )
  • Jak używać poleceń Terraform CLI do zarządzania infrastrukturą
  • Jak zmodyfikować konfigurację, aby zaktualizować zasoby i usługi
  • Jak zastosować swoją konfigurację w prawdziwej aplikacji internetowej (zwanej Przyjaznym Czatem )
  • Jak zdefiniować konfiguracje równoległe (i zsynchronizowane) w różnych środowiskach (produkcja, przemieszczanie itp.)

Co będziesz potrzebował

Aby odnieść sukces w tych ćwiczeniach z programowania, potrzebujesz podstawowej znajomości Terraform i jego terminologii, łącznie z następującymi wymaganiami wstępnymi:

To ćwiczenie z programowania zapewnia prawdziwą przykładową aplikację, dzięki której możesz testować i wchodzić w interakcję z tym, co udostępniasz za pośrednictwem Terraform. Aby to zrobić, będziesz potrzebować:

  • Przykładowy kod aplikacji internetowej — pobierz ten kod w następnym kroku ćwiczeń z programowania
  • Menedżer pakietów npm (który zazwyczaj jest dostarczany z Node.js ) — zainstaluj te narzędzia
  • Interfejs CLI Firebase — zainstaluj ten interfejs CLI i zaloguj się

2. Zdobądź kod startowy

Podczas tych zajęć z programowania możesz przetestować to, co udostępniasz za pośrednictwem Terraform, w prawdziwej aplikacji internetowej. Zalecamy wykonanie tej czynności, aby zrozumieć wszystkie kroki niezbędne do korzystania z zasobów udostępnianych przez Terraform.

Sklonuj repozytorium GitHub Codelab z wiersza poleceń:

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

Alternatywnie, jeśli nie masz zainstalowanego gita, możesz pobrać repozytorium jako plik ZIP .

3. Utwórz konfigurację Terraform

Konfiguracja Terraformu

  1. W kodzie pobranej przykładowej aplikacji przejdź do katalogu głównego katalogu web .
  2. W katalogu głównym tego katalogu utwórz plik konfiguracyjny Terraform o nazwie main.tf z następującą konfiguracją początkową:

    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
}

Każdy z dostawców google-beta ma atrybut o nazwie user_project_override , który określa, w jaki sposób operacje z Terraform będą sprawdzane przydziału. Do udostępniania większości zasobów powinieneś użyć user_project_override = true , co oznacza sprawdzenie limitu w stosunku do własnego projektu Firebase. Aby jednak skonfigurować nowy projekt tak, aby akceptował sprawdzanie przydziału, musisz najpierw użyć user_project_override=false . Składnia alias Terraform umożliwia rozróżnienie między dwiema konfiguracjami dostawców w kolejnych krokach tego ćwiczenia z programowania.

Zainicjuj Terraform w katalogu

Tworzenie nowej konfiguracji po raz pierwszy wymaga pobrania dostawcy określonego w konfiguracji.

Aby wykonać tę inicjalizację, uruchom następującą komendę w katalogu głównym tego samego katalogu, w którym znajduje się plik konfiguracyjny main.tf :

terraform init

4. Utwórz projekt Firebase za pomocą Terraform

Aby „utworzyć projekt Firebase”, należy pamiętać, że każdy projekt Firebase jest w rzeczywistości projektem Google Cloud, tylko z włączonymi usługami Firebase.

Dodaj bloki dla podstawowego projektu Google Cloud i interfejsów API

  1. Najpierw udostępnij podstawowy projekt Google Cloud.

    Do pliku konfiguracyjnego main.tf dodaj następujący blok zasobów.

    Musisz podać własną nazwę projektu (np. "Terraform FriendlyChat Codelab" ) i własny identyfikator projektu (np. "terraform-codelab-your-initials" ). Pamiętaj, że wartość name jest używana tylko w interfejsach Firebase i nie jest widoczna dla użytkowników końcowych. Wartość project_id jednoznacznie identyfikuje Twój projekt w oczach Google, dlatego upewnij się, że podałeś unikalną wartość. 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. Następnie musisz włączyć wymagane podstawowe interfejsy API: Service Usage API i Firebase Management API.

    To włączenie interfejsu API jest zwykle obsługiwane za kulisami, gdy używasz konsoli Firebase do tworzenia projektu Firebase, ale należy wyraźnie poinformować firmę Terraform, aby to włączyła.

    Do pliku konfiguracyjnego main.tf (tuż pod blokiem tworzącym nowy projekt Cloud) dodaj następujący blok zasobów:

    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
}
    Po włączeniu interfejsu Service Usage API Twój nowy projekt będzie mógł akceptować kontrole przydziału! Zatem przy każdym późniejszym udostępnianiu zasobów i włączaniu usług powinieneś używać dostawcy z user_project_override (nie jest potrzebny alias).

Dodaj blok, aby włączyć usługi Firebase

Ostatnią rzeczą wymaganą do „utworzenia projektu Firebase” jest włączenie usług Firebase w projekcie.

Kontynuując pracę w pliku konfiguracyjnym main.tf , dodaj następujący blok zasobów.

Jak wspomniano powyżej, zauważ, że ten blok zasobów korzysta z dostawcy z user_project_override (nie jest potrzebny alias).

main.tf

...

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

  project = google_project.default.project_id

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

W bloku zasobów powyżej możesz zauważyć klauzulę depends_on , która informuje Terraform, aby zaczekał na włączenie podstawowych interfejsów API. Bez tej klauzuli Terraform nie będzie wiedział o zależnościach i może napotkać błędy podczas równoległego udostępniania zasobów.

Zastosuj konfigurację

  1. Aby udostępnić nowe zasoby i włączyć interfejsy API określone w pliku konfiguracyjnym, uruchom następującą komendę w katalogu głównym tego samego katalogu, w którym znajduje się plik main.tf (który powinien być web ):
    terraform apply
  2. W terminalu Terraform drukuje plan działań, które wykona.

    Jeżeli wszystko wygląda zgodnie z oczekiwaniami, zatwierdź działania wpisując 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 # <----

Pamiętaj, że jeśli potrzebujesz tylko podglądu zmian bez ich stosowania, możesz zamiast tego użyć polecenia terraform plan .

Zatwierdź zmiany

Po zakończeniu działania Terraform możesz sprawdzić stan wszystkich udostępnionych zasobów i usług Terraform, uruchamiając następujące polecenie:

terraform show

Oto przykład tego, co powinno zostać wydrukowane. Twój stan będzie zawierał wartości specyficzne dla Twojego projektu.

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

Alternatywnie możesz sprawdzić, czy projekt został utworzony, przeglądając go w konsoli Firebase .

The Terraform FriendlyChat Codelab project selected on the Firebase console

5. Zarejestruj swoją aplikację Firebase za pośrednictwem Terraform

Aby korzystać z Firebase, musisz zarejestrować każdy wariant platformy swojej aplikacji w projekcie Firebase. Podczas tych zajęć z programowania będziesz używać prawdziwej aplikacji do testowania i interakcji z tym, co udostępniasz za pośrednictwem Terraform. Ta aplikacja jest aplikacją internetową, więc musisz poinformować Terraform, aby zarejestrował aplikację internetową Firebase w nowo utworzonym projekcie Firebase.

Dodaj blok, aby zarejestrować aplikację internetową

Aby zarejestrować aplikację internetową w projekcie Firebase, dołącz plik main.tf z następującym blokiem zasobów.

Musisz określić własną display_name dla swojej aplikacji internetowej. Pamiętaj, że ta nazwa jest używana tylko w interfejsach Firebase i nie jest widoczna dla użytkowników końcowych.

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

Zastosuj konfigurację

  1. Aby udostępnić nowy zasób, uruchom następujące polecenie w katalogu głównym tego samego katalogu, w którym znajduje się plik main.tf (który powinien mieć postać web ).
    terraform apply
    Pamiętaj, że to polecenie nie spowoduje ponownego utworzenia nowego projektu Google Cloud. Terraform wykryje, że projekt o podanym identyfikatorze już istnieje, porówna bieżący stan projektu z zawartością pliku .tf i wprowadzi wszelkie znalezione zmiany.
  2. Przejrzyj wydrukowany plan działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij klawisz Enter, aby zatwierdzić działania.

Zatwierdź zmiany

Możesz sprawdzić stan nowo udostępnionego zasobu, uruchamiając następującą komendę:

terraform show

Alternatywnie możesz sprawdzić, czy aplikacja została pomyślnie zarejestrowana w Twoim projekcie, przeglądając ją w konsoli Firebase. Przejdź do Ustawień projektu , a następnie przewiń w dół do sekcji Twoje aplikacje .

6. Skonfiguruj uwierzytelnianie Firebase

Uwierzytelnianie jest ważnym elementem każdej aplikacji. Aby umożliwić użytkownikom końcowym logowanie się do Twojej aplikacji internetowej przy użyciu swoich kont Google, możesz włączyć uwierzytelnianie Firebase i skonfigurować metodę logowania za pomocą Google.

Pamiętaj, że w tym ćwiczeniu z programowania udostępniamy dwie różne opcje konfiguracji uwierzytelniania Firebase:

  • Opcja 1 (zalecana) : skonfiguruj w konsoli uwierzytelnianie Firebase, które nie wymaga GCIP.
    • Użycie tej opcji oznacza, że ​​nie musisz kojarzyć swojego nowego projektu z kontem rozliczeniowym Cloud.
  • Opcja 2 : skonfiguruj uwierzytelnianie Firebase za pośrednictwem Terraform przy użyciu interfejsów API Google Cloud Identity Platform (GCIP).
    • Użycie tej opcji oznacza, że ​​musisz powiązać nowy projekt z kontem rozliczeniowym Cloud, ponieważ GCIP wymaga, aby projekt był objęty planem cenowym Blaze.

Opcja 1: Skonfiguruj uwierzytelnianie za pomocą konsoli Firebase

Aby skonfigurować uwierzytelnianie Firebase za pomocą konsoli Firebase, Twój projekt nie musi być objęty planem cenowym Blaze.

Oto jak skonfigurować uwierzytelnianie Firebase i zalogować się za pomocą Google:

  1. W konsoli Firebase znajdź sekcję Kompilacja w lewym panelu.
  2. Kliknij opcję Uwierzytelnianie , kliknij opcję Rozpocznij , a następnie kliknij kartę Metoda logowania (lub kliknij tutaj , aby przejść bezpośrednio tam).
  3. Kliknij Dodaj nowego dostawcę i w sekcji Dodatkowi dostawcy wybierz Google .
  4. Aktywuj przełącznik Włącz .
  5. Ustaw publicznie dostępną nazwę swojej aplikacji na przykład FriendlyChat (nie musi to być unikatowa na całym świecie).
  6. Z menu rozwijanego wybierz adres e-mail pomocy technicznej projektu , a następnie kliknij przycisk Zapisz . Configuring Firebase Auth on the Firebase console
  7. Powinieneś widzieć Google jako włączonego dostawcę logowania. Firebase console Authentication page: Google sign-in enabled

Opcja 2: skonfiguruj uwierzytelnianie za pośrednictwem Terraform przy użyciu interfejsów API Google Cloud Identity Platform (GCIP).

Aby skonfigurować uwierzytelnianie Firebase za pośrednictwem Terraform, musisz użyć interfejsów API GCIP, co oznacza, że ​​projekt musi być objęty planem cenowym Blaze. Aktualizujesz swój projekt Firebase, aby korzystać z planu Blaze, powiązując konto rozliczeniowe Cloud z projektem.

Włącz rozliczenia za pośrednictwem Terraform

  1. Jeśli nie masz jeszcze konta rozliczeniowego Cloud, pierwszym krokiem jest utworzenie nowego konta w Google Cloud Console . Gdy to zrobisz, zanotuj identyfikator jego konta rozliczeniowego . Identyfikator konta rozliczeniowego można znaleźć na stronie Rozliczenia w identyfikatorze konta rozliczeniowego powiązanego z Twoim projektem. Enabling a billing account using the Google Cloud console
  2. Aby włączyć rozliczenia w swoim projekcie za pośrednictwem Terraform, dodaj atrybut billing_account do istniejącego zasobu google_project w pliku 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"
  }
}

...

Włącz uwierzytelnianie Firebase i zaloguj się w Google za pośrednictwem Terraform

  1. Aby zapewnić uwierzytelnianie Firebase za pomocą GCIP, dołącz plik main.tf z następującymi blokami zasobów:

    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. Włączenie logowania za pomocą Google wymaga posiadania klienta OAuth . Aby przeprowadzić tę konfigurację, przejdź do sekcji API i usług w Google Cloud Console.
  3. Ponieważ po raz pierwszy tworzysz identyfikator klienta dla tego projektu, musisz skonfigurować ekran zgody OAuth.
    1. Otwórz stronę ekranu zgody OAuth i wybierz właśnie utworzony projekt.
    2. Ustaw Typ użytkownika na Zewnętrzny , a następnie kliknij Utwórz .
    3. Na następnym ekranie wykonaj poniższe czynności, a następnie kliknij Zapisz i kontynuuj .
      • Ustaw nazwę swojej aplikacji dostępną publicznie na przykład FriendlyChat (nie musi to być unikatowa na całym świecie).
      • Z menu rozwijanego wybierz adres e-mail pomocy technicznej użytkownika .
      • Wpisz adres e-mail zawierający dane kontaktowe programisty .
    4. Na kolejnych ekranach wykonaj następujące czynności:
      • Zaakceptuj ustawienia domyślne na stronie Zakresy , a następnie kliknij przycisk Zapisz i kontynuuj .
      • Zaakceptuj ustawienia domyślne na stronie Testuj użytkowników , a następnie kliknij przycisk Zapisz i kontynuuj .
      • Przejrzyj podsumowanie, a następnie kliknij opcję Powrót do pulpitu nawigacyjnego .
      Configuring an OAuth2 client using the Google Cloud console
  4. Skonfiguruj klienta OAuth na stronie Poświadczenia , wykonując następujące czynności:
    1. Kliknij opcję Utwórz dane uwierzytelniające i wybierz Identyfikator klienta OAuth .
    2. Z listy rozwijanej Typ aplikacji wybierz opcję Aplikacja internetowa .
    3. W polu Nazwa wpisz nazwę swojej aplikacji, na przykład FriendlyChat (nie musi być ona globalnie unikalna).
    4. Zezwól adresowi URL swojej aplikacji na korzystanie z tego klienta OAuth, ustawiając następujące ustawienia:
      • W obszarze Autoryzowane źródła JavaScript kliknij opcję Dodaj identyfikator URI i wprowadź
        https://<PROJECT_ID>.firebaseapp.com , gdzie <PROJECT_ID> to identyfikator projektu ustawiony w main.tf
      • W obszarze Autoryzowane identyfikatory URI przekierowań kliknij opcję Dodaj URI i wprowadź
        https://<PROJECT_ID>.firebaseapp.com/__/auth/handler , gdzie <PROJECT_ID> to identyfikator projektu ustawiony w main.tf
    5. Kliknij Zapisz .
    Obtaining the OAuth2 Client ID and secret from the Google Cloud console Credentials page
  5. Aby umożliwić logowanie się w Google przy użyciu identyfikatora klienta OAuth i sekretu klienta, dołącz do pliku main.tf następujący blok:

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

Zastosuj konfigurację

  1. Aby skonfigurować uwierzytelnianie zgodnie z konfiguracją, uruchom następujące polecenia w katalogu głównym tego samego katalogu, w którym znajduje się plik main.tf (który powinien być web ):
    export TF_VAR_oauth_client_secret="<YOUR_OAUTH_CLIENT_SECRET>"

    terraform apply
    Pamiętaj, że uruchomienie terraform apply nie spowoduje ponownego utworzenia nowy projekt Google Cloud. Terraform wykryje, że projekt o podanym identyfikatorze już istnieje i porówna bieżący stan projektu z zawartością pliku .tf . Następnie dokona wszelkich znalezionych zmian.
  2. Przejrzyj wydrukowany plan działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij klawisz Enter, aby zatwierdzić działania.

Zatwierdź zmiany

  1. W konsoli Firebase znajdź sekcję Kompilacja w lewym panelu.
  2. Kliknij opcję Uwierzytelnianie , a następnie kliknij kartę Metoda logowania (lub kliknij tutaj , aby przejść bezpośrednio tam).
  3. Powinieneś widzieć Google jako włączonego dostawcę logowania. Firebase console Authentication page: Google sign-in enabled

7. Skonfiguruj bazę danych Firestore i jej reguły bezpieczeństwa

W przypadku aplikacji internetowej tego laboratorium programistycznego będziesz przechowywać wiadomości między użytkownikami końcowymi w bazie danych Firestore.

  1. Aby włączyć wymagane interfejsy API i udostępnić instancję bazy danych, dołącz plik main.tf z następującymi blokami zasobów:

    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. Zmień <NAME_OF_DESIRED_REGION> na region, w którym ma się znajdować baza danych.

    Tworząc aplikację produkcyjną, chcesz, aby znajdowała się ona w regionie bliskim większości użytkowników i wspólnym z innymi usługami Firebase, takimi jak Cloud Functions. W przypadku tych zajęć z programowania możesz użyć us-east1 (Karolina Południowa) lub skorzystać z najbliższego regionu (zobacz lokalizacje Cloud Firestore ).
  3. Każda instancja bazy danych Firestore dostępna dla Firebase musi być chroniona regułami bezpieczeństwa Firebase .

    Przykładowy kod tego laboratorium programistycznego udostępnia zestaw bezpiecznych reguł Firestore w pliku firestore.rules , który można znaleźć w katalogu głównym katalogu web .
  4. Dołącz plik main.tf z następującymi blokami zasobów, aby wykonać następujące czynności:
    • Utwórz zestaw reguł reguł bezpieczeństwa Firebase z lokalnego pliku firestore.rules .
    • Zwolnij zestaw reguł dla instancji Firestore.
    Pamiętaj, że te bloki zasobów odpowiadają kliknięciu przycisku Publikuj w konsoli Firebase lub uruchomieniu 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. Uruchom terraform apply , aby udostępnić bazę danych Firestore i wdrożyć jej reguły bezpieczeństwa.
  6. Sprawdź, czy baza danych jest udostępniona i czy wdrożono jej reguły bezpieczeństwa:
    1. W konsoli Firebase znajdź sekcję Kompilacja w lewym panelu.
    2. Przejdź do sekcji Baza danych Firestore , a następnie kliknij zakładkę Reguły .
    Verifying Cloud Firestore rules using the Firebase console

8. Skonfiguruj segment Cloud Storage i jego reguły bezpieczeństwa

W przypadku aplikacji internetowej tego laboratorium programistycznego będziesz przechowywać obrazy udostępniane użytkownikom końcowym w zasobniku Cloud Storage.

  1. Aby włączyć wymagane interfejsy API i udostępnić domyślny zasobnik Cloud Storage, dołącz plik main.tf z następującymi blokami zasobów.

    Pamiętaj, że domyślny zasobnik Cloud Storage dla Twojego projektu jest udostępniany przez Google App Engine i musi znajdować się w tej samej lokalizacji, co Twoja baza danych Firestore. Aby uzyskać więcej informacji, zobacz lokalizacje App Engine .

    Jeśli chcesz mieć w swoim projekcie wiele zasobników, udostępnij je przy użyciu zasobu google_storage_bucket (niepokazanego w tym ćwiczeniu z programowania).

    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. Każdy wiadro Cloud Storage dostępne dla Firebase musi być chronione regułami bezpieczeństwa Firebase .

    Przykładowy kod tego laboratorium programistycznego udostępnia zestaw bezpiecznych reguł Firestore w pliku storage.rules , który można znaleźć w katalogu głównym katalogu web .
  3. Dołącz plik main.tf z następującymi blokami zasobów, aby wykonać następujące czynności:
    • Utwórz zestaw reguł reguł zabezpieczeń Firebase z pliku lokalnego.
    • Zwolnij zestaw reguł dla zasobnika pamięci.
    Zauważ, że te bloki zasobów odpowiadają kliknięciu przycisku Publikuj w konsoli Firebase lub uruchomieniu 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. Uruchom terraform apply , aby udostępnić domyślny zasobnik Cloud Storage i wdrożyć jego reguły bezpieczeństwa.
  5. Sprawdź, czy zasobnik jest udostępniony i czy wdrożono jego reguły bezpieczeństwa:
    1. W konsoli Firebase znajdź sekcję Kompilacja w lewym panelu.
    2. Przejdź do sekcji Przechowywanie , a następnie kliknij zakładkę Reguły .
    Verifying security rules using the Firebase console

9. Uruchom aplikację lokalnie

Możesz teraz uruchomić swoją aplikację internetową po raz pierwszy! Będziesz używać emulatora Firebase Hosting do lokalnego udostępniania swojej aplikacji.

  1. Otwórz nowe okno terminala i z katalogu web uruchom następujące polecenie Firebase CLI, aby uruchomić emulator:
    firebase emulators:start --project=<PROJECT_ID>
  2. W przeglądarce otwórz aplikację internetową pod lokalnym adresem URL zwróconym przez interfejs CLI (zwykle http://localhost:5000 ).

Powinieneś zobaczyć interfejs użytkownika aplikacji FriendlyChat, który (jeszcze!) nie działa. Aplikacja nie jest jeszcze połączona z Firebase, ale po wykonaniu kolejnych kroków ćwiczeń z programowania będzie to możliwe!

Pamiętaj, że za każdym razem, gdy wprowadzasz zmiany w aplikacji internetowej (tak jak zrobisz to w kolejnych krokach tego ćwiczenia z kodowania), odśwież przeglądarkę, aby zaktualizować lokalny adres URL tymi zmianami.

10. Zainstaluj, skonfiguruj i zainicjuj Firebase

Aby aplikacja działała z Firebase, potrzebuje ona pakietu SDK Firebase i konfiguracji Firebase dla projektu Firebase.

Przykładowy kod do tego ćwiczenia z programowania jest już działającą aplikacją ze wszystkimi zależnościami i funkcjami wymaganymi do korzystania z różnych produktów Firebase w aplikacji. Jeśli chcesz zobaczyć, co już zostało zrobione, możesz zajrzeć do web/package.json i web/src/index.js .

Mimo że przykładowy kod jest w większości kompletny, nadal musisz wykonać kilka czynności, aby uruchomić aplikację, w tym: zainstalować pakiet SDK Firebase, rozpocząć kompilację, dodać konfigurację Firebase do swojej aplikacji i na koniec zainicjalizować Firebase.

Zainstaluj pakiet SDK Firebase i rozpocznij kompilację pakietu internetowego

Aby rozpocząć kompilację aplikacji, musisz uruchomić kilka poleceń.

  1. Otwórz nowe okno terminala.
  2. Upewnij się, że jesteś w katalogu głównym katalogu web .
  3. Uruchom npm install , aby pobrać pakiet SDK Firebase.
  4. Uruchom npm update , aby zaktualizować wszelkie zależności.
  5. Uruchom npm run start , aby uruchomić pakiet internetowy.

Przez resztę zajęć z programowania pakiet webpack będzie teraz stale odbudowywał kod źródłowy.

Dodaj konfigurację Firebase do swojej aplikacji

Musisz także dodać konfigurację Firebase do swojej aplikacji, aby zestawy SDK Firebase wiedziały, z którego projektu Firebase mają korzystać.

W przypadku tych zajęć z programowania masz dwie różne opcje uzyskania konfiguracji Firebase:

  • Opcja 1 : Uzyskaj konfigurację Firebase z konsoli Firebase.
  • Opcja 2 : Uzyskaj konfigurację Firebase za pośrednictwem Terraform.

Opcja 1: Uzyskaj konfigurację z konsoli Firebase i dodaj ją do swojej bazy kodu

  1. W konsoli Firebase przejdź do ustawień projektu .
  2. Przewiń w dół do karty Twoje aplikacje , a następnie wybierz aplikację internetową.
  3. Wybierz opcję Konfiguracja w panelu fragmentu kodu SDK Firebase, a następnie skopiuj fragment konfiguracji.
  4. Wklej swoją konfigurację do pliku web/src/firebase-config.js swojej aplikacji, w następujący sposób:

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

...

Opcja 2: Uzyskaj konfigurację za pośrednictwem Terraform i dodaj ją do swojej bazy kodu

Alternatywnie możesz uzyskać konfigurację Firebase za pośrednictwem Terraform jako wartość wyjściową w interfejsie CLI.

  1. W pliku main.tf znajdź blok zasobów google_firebase_web_app (blok, który zarejestrował aplikację internetową w Twoim projekcie).
  2. Zaraz po tym bloku dodaj następujące bloki:

    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. Ponieważ blok data i blok output nie są przeznaczone do modyfikowania infrastruktury w żaden sposób, wystarczy uruchomić następujące polecenia.
    1. Aby załadować konfigurację Firebase swojej aplikacji internetowej do stanu Terraform w swoim katalogu, uruchom to polecenie:
      terraform refresh
    2. Aby wydrukować wartości konfiguracyjne Firebase, uruchom to polecenie:
      terraform output –json
      Poniżej znajduje się przykładowy wynik pliku config. Wydrukowane dane będą zawierać wartości projektu i aplikacji.
      {
  "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. Skopiuj wartości z mapy value .
  5. Wklej te wartości (swoją konfigurację) do pliku web/src/firebase-config.js swojej aplikacji, w następujący sposób:

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

...

Zainicjuj Firebase w swojej aplikacji

Na koniec, aby zainicjować Firebase, dołącz do pliku web/src/index.js swojej aplikacji następujące elementy:

indeks.js

...

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

Wypróbuj swoją aplikację

Teraz, gdy wszystko jest skonfigurowane dla Firebase, możesz wypróbować swoją funkcjonalną aplikację internetową.

  1. Odśwież przeglądarkę obsługującą Twoją aplikację.
  2. Teraz powinno być możliwe zalogowanie się w Google i rozpoczęcie wysyłania wiadomości na czacie. Jeśli masz pliki obrazów, możesz je nawet przesłać!

11. Replikuj swoją konfigurację w różnych środowiskach

Terraform specjalizuje się w zarządzaniu wieloma podobnie skonfigurowanymi infrastrukturami (na przykład konfigurując tymczasowy projekt Firebase podobny do projektu prod).

Podczas tych zajęć z programowania utworzysz drugi projekt Firebase, który będzie środowiskiem przejściowym.

Aby zreplikować istniejącą konfigurację w celu utworzenia tego projektu tymczasowego, masz dwie możliwości:

  • Opcja 1 : Zrób kopię konfiguracji Terraform.
    Ta opcja zapewnia największą elastyczność w zakresie tego, jak bardzo zreplikowany projekt może różnić się od projektu źródłowego.
  • Opcja 2 : Użyj ponownie konfiguracji za pomocą for_each .
    Ta opcja zapewnia większe możliwości ponownego wykorzystania kodu, jeśli każdy projekt nie powinien różnić się znacząco i chcesz propagować zmiany we wszystkich projektach jednocześnie.

Opcja 1: Utwórz kopię konfiguracji Terraform

Ta opcja zapewnia największą elastyczność w zakresie tego, jak bardzo zreplikowany projekt może różnić się od projektu źródłowego, np. posiadanie aplikacji o różnych nazwach wyświetlanych i wdrażanie etapowe.

  1. W katalogu głównym swojego katalogu web utwórz nowy plik konfiguracyjny Terraform o nazwie main_staging.tf .
  2. Skopiuj wszystkie bloki zasobów z pliku main.tf (z wyjątkiem bloków terraform i provider ), a następnie wklej je do pliku main_staging.tf .
  3. Następnie musisz zmodyfikować każdy z replikowanych bloków zasobów w main_staging.tf , aby działały z projektem testowym:
    • Etykiety zasobów: Użyj nowej nazwy, aby uniknąć konfliktów. Na przykład zmień nazwę resource "google_project" "default" na resource "google_project" "staging" .
    • Odniesienia do zasobów: zaktualizuj każdy z nich. Na przykład zaktualizuj google_firebase_project.default.project do google_firebase_project.staging.project .
    Pełną konfigurację pliku main_staging.tf można znaleźć w repozytorium GitHub tego laboratorium programistycznego:

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

    Jeśli chcesz użyć tej konfiguracji, wykonaj następujące czynności:
    1. Skopiuj konfigurację z main_staging-copypaste.tf , a następnie wklej ją do pliku main_staging.tf .
    2. W pliku main_staging.tf wykonaj następujące czynności:
      • W bloku zasobów google_project zaktualizuj atrybut name , atrybut project-id i (jeśli skonfigurujesz uwierzytelnianie za pośrednictwem Terraform) atrybut billing_account , wprowadzając własne wartości.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name własną wartością.
      • W blokach zasobów google_firestore_database i google_app_engine_application zaktualizuj location_id własną wartością.
    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. Uruchom terraform apply , aby udostępnić swój nowy „pomostowy” projekt Firebase i wszystkie jego zasoby oraz włączyć jego usługi.
  5. Sprawdź, czy wszystko zostało udostępnione i włączone zgodnie z oczekiwaniami, sprawdzając je w konsoli Firebase, jak poprzednio.

Opcja 2: Użyj ponownie konfiguracji za pomocą for_each

Ta opcja zapewnia większe możliwości ponownego wykorzystania kodu, jeśli każdy projekt nie powinien różnić się znacząco i chcesz propagować zmiany we wszystkich projektach jednocześnie. Używa metaargumentu for_each w języku Terraform.

  1. Otwórz plik main.tf
  2. Do każdego bloku zasobów, który chcesz replikować, dodaj metaargument for_each w następujący sposób:

    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.
    Pełną konfigurację pliku main.tf , który używa metaargumentu for_each , można znaleźć w repozytorium GitHub tego laboratorium programistycznego:

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

    Jeśli chcesz użyć tej konfiguracji, wykonaj następujące czynności:
    1. Skopiuj konfigurację z main-foreach.tf , a następnie wklej ją do pliku main.tf
    2. W pliku main.tf wykonaj następujące czynności:
      • W bloku zasobów google_project zaktualizuj atrybut name , atrybut project-id i (jeśli skonfigurujesz uwierzytelnianie za pośrednictwem Terraform) atrybut billing_account z własnymi wartościami.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name o własnej wartości.
      • W blokach google_firestore_database i google_app_engine_application zaktualizuj atrybuty location_id o własną wartość.
  3. Zamiast od razu stosować tę konfigurację, ważne jest, aby zrozumieć i naprawić kilka rzeczy na temat tego, jak Terraform interpretuje tę konfigurację w porównaniu z istniejącą infrastrukturą.
    1. W tej chwili, jeśli zastosowałeś tę konfigurację, która korzysta for_each , adresy zasobów wyglądałyby jak następujące:
      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"]
      Jednak istniejący projekt utworzony w pierwszej części tego kodelab jest znany Terraformowi jako:
      google_project.default
google_firebase_project.default
google_firebase_android_app.default
    2. Uruchom terraform plan , aby zobaczyć, jakie działania podejmuje Terraform, biorąc pod uwagę obecny stan.

      Wyjście powinno pokazać, że Terraform usunie projekt utworzony w pierwszej części tego Codelab i stworzy dwa nowe projekty. Wynika to z faktu, że Terraform nie wie, że projekt pod adresem google_project.default został przeniesiony na nowy adres google_project.default["prod"] .
    3. Aby to naprawić, uruchom polecenie terraform state mv :
      terraform state mv "google_project.default" "google_project.default[\"prod\"]"
    4. Podobnie, aby naprawić wszystkie inne bloki zasobów, uruchom terraform state mv dla google_firebase_project , google_firebase_web_app i wszystkie inne bloki zasobów w pliku main.tf
    5. Teraz, jeśli ponownie uruchomisz terraform plan , nie powinno to pokazywać, że Terraform usunie projekt, który stworzyłeś w pierwszej części tego kodelab.
  4. Run terraform apply , aby zapewnić nowy projekt Firebase „inscenizacji” i wszystkie jego zasoby i umożliwiają jego usługi.
  5. Sprawdź, czy wszystko zostało udostępnione i włączone zgodnie z oczekiwaniami, sprawdzając je w konsoli Firebase jak poprzednio.

12. Krok bonusowy: Wdrożenie aplikacji inscenizacji i produktów

  1. W bazie kodu aplikacji zmień firebase-config.js aby zamiast tego użyć konfiguracji FireBase z projektu inscenizacji.

    Aby przypomnieć sobie, jak uzyskać konfigurację FireBase i dodać ją do aplikacji, zobacz wcześniejszy krok tego kodelab, dodaj konfigurację Firebase do swojej aplikacji.
  2. U podstaw katalogu web uruchom następujące polecenie, aby wdrożyć aplikację w projekcie inscenizacji Firebase.
    firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
  3. Otwórz aplikację inscenizacyjną w przeglądarce za pomocą adresu URL wydrukowanego na wyjściu firebase deploy . Spróbuj zalogować się, wysyłać wiadomości i przesyłać obrazy.

    Po wdrożeniu aplikacji do projektu Firebase wykorzystuje prawdziwe zasoby Firebase, a nie naśladowane zasoby. Podczas interakcji z aplikacją inscenizacyjną powinieneś zobaczyć dane i obrazy w projekcie inscenizacji w konsoli Firebase.
  4. Po przetestowaniu aplikacji na inscenizacji zmień firebase-config.js z powrotem na korzystanie z konfiguracji FireBase Project (pierwszy projekt utworzony w tym Codelab).
  5. U podstaw katalogu web uruchom następujące polecenie, aby wdrożyć aplikację do produkcyjnego projektu FireBase.
    firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
  6. Otwórz aplikację produkcyjną w przeglądarce za pośrednictwem adresu URL wydrukowanego na wyjściu firebase deploy . Spróbuj zalogować się, wysyłać wiadomości i przesyłać obrazy.

    Powinieneś zobaczyć dane i obrazy w swoim projekcie produkcyjnym w konsoli Firebase.
  7. Po zakończeniu interakcji z dwiema aplikacjami do tego kodelab możesz powstrzymać Firebase przed ich obsługą. Uruchom następujące polecenie dla każdego z twoich projektów:
    firebase hosting:disable --project=<STAGING_PROJECT_ID>

    firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>

13. Gratulacje!

Użyłeś Terraform, aby skonfigurować aplikację czatu w czasie rzeczywistym! Postępowałeś zgodnie z najlepszymi praktykami dla środowisk programistycznych, tworząc osobne projekty Firebase w zakresie inscenizacji i produkcji.

Co omówiliśmy

  • Korzystanie z CLI Terraform do zarządzania zasobami w chmurze
  • Korzystanie z Terraform do konfigurowania produktów FireBase (uwierzytelnianie, Firestore, przechowywanie w chmurze i zasady bezpieczeństwa)
  • Uruchamianie i testowanie aplikacji internetowej lokalnie za pomocą pakietu Emulatora FireBase lokalnego
  • Importowanie Firebase do aplikacji internetowej
  • Korzystanie z Terraform do powtórzenia konfiguracji w wielu środowiskach

Aby uzyskać więcej informacji na temat FireBase i Terraform, odwiedź naszą dokumentację . Listę wszystkich produktów FireBase z obsługą Terraform, przykładowymi konfiguracją Terraform dla typowych przypadków użycia oraz pomocne rozwiązywanie problemów i FAQ.