Konfigurowanie projektów i usług Firebase oraz zarządzanie nimi za pomocą Terraform

1. Wprowadzenie

Cele

Za pomocą Terraform możesz skonfigurować projekt Firebase i zarządzać nim, w tym zautomatyzowaną konfigurację infrastruktury i usług Firebase.

W ramach tego ćwiczenia w Codelabs dowiesz się, jak utworzyć plik konfiguracji Terraform, aby utworzyć nowy projekt Firebase. Potem dowiesz się, jak skonfigurować aplikacje i usługi Firebase, których chcesz używać w tym projekcie. Omówimy również podstawy wiersza poleceń Terraform, takie jak wyświetlanie podglądu zmian, które należy wprowadzić, i ich wdrożenie.

Jeśli chcesz dowiedzieć się, jak konfigurować projekty i usługi Firebase oraz nimi zarządzać za pomocą Terraform, to ćwiczenie z programowania jest właśnie dla Ciebie.

Czego się nauczysz

  • Jak utworzyć plik konfiguracyjny Terraform (*.tf)
  • Jak zarządzać infrastrukturą za pomocą poleceń interfejsu wiersza poleceń Terraform
  • Jak zmodyfikować konfigurację, aby zaktualizować zasoby i usługi
  • jak zastosować konfigurację w rzeczywistej aplikacji internetowej (tzw. przyjazny czat).
  • Definiowanie konfiguracji równoległych i zsynchronizowanych w różnych środowiskach (produkcyjnych, przejściowych itp.)

Czego potrzebujesz

Aby wykonać te ćwiczenia, musisz opanować Terraform i jego terminologię, w tym te wymagania wstępne:

To ćwiczenie w Codelabs zawiera prawdziwą przykładową aplikację, dzięki której możesz testować i udostępniać zasoby udostępniane za pomocą Terraform. Potrzebujesz do tego:

  • Przykładowy kod aplikacji internetowej – pobierz ten kod w następnym kroku ćwiczenia z programowania
  • Menedżer pakietów npm (zwykle dołączony do Node.js) – zainstaluj te narzędzia.
  • Interfejs wiersza poleceń Firebase – zainstaluj ten interfejs wiersza poleceń i zaloguj się

2. Pobierz kod początkowy

Dzięki temu ćwiczeniu w Codelabs możesz sprawdzić, co udostępniasz za pomocą Terraform za pomocą rzeczywistej aplikacji internetowej. Zalecamy wykonanie tej czynności, aby zrozumieć wszystkie kroki niezbędne do korzystania z zasobów udostępnionych przez Terraform.

Skopiuj repozytorium GitHub ćwiczenia z programowania za pomocą wiersza poleceń:

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

Jeśli nie masz zainstalowanej aplikacji git, możesz pobrać repozytorium jako plik ZIP.

3. Tworzenie konfiguracji Terraform

Konfiguracja Terraform

  1. W bazie kodu pobranej przykładowej aplikacji przejdź do głównego katalogu katalogu web.
  2. W katalogu głównym tego katalogu utwórz plik konfiguracyjny Terraform o nazwie main.tf z tą 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 sposób sprawdzania limitów operacji z Terraform. Do obsługi administracyjnej większości zasobów należy używać narzędzia user_project_override = true, co oznacza, że można sprawdzić limit w swoim projekcie Firebase. Aby jednak skonfigurować nowy projekt tak, aby akceptował kontrole limitów, musisz najpierw użyć usługi user_project_override=false. Składnia alias Terraform umożliwia rozróżnianie 2 konfiguracji dostawców w następnych krokach tego ćwiczenia z programowania.

Zainicjuj Terraform w katalogu

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

Aby to zrobić, uruchom to polecenie w katalogu głównym tego samego katalogu, w którym znajduje się plik konfiguracyjny main.tf:

terraform init

4. Tworzenie projektu Firebase za pomocą Terraform

Aby utworzyć projekt Firebase, pamiętaj, że każdy projekt Firebase jest w rzeczywistości projektem Google Cloud, tylko że mają w nim włączone usługi Firebase.

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

  1. Najpierw udostępnij bazowy projekt Google Cloud.

    Do pliku konfiguracyjnego main.tf dodaj poniższy blok zasobów.

    Musisz podać nazwę własnego projektu (np. "Terraform FriendlyChat Codelab") i identyfikator własnego 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. Wartość project_id jednoznacznie identyfikuje Twój projekt dla Google, więc musisz określić 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 bazowe interfejsy API: Service Usage API i Firebase Management API.

    To działanie jest zwykle wykonywane za kulisami, gdy tworzysz projekt Firebase za pomocą konsoli Firebase, ale do Terraform trzeba wyraźnie poprosić o jego włączenie.

    Do pliku konfiguracyjnego main.tf (tuż pod blokiem, który tworzy nowy projekt Cloud) dodaj ten 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
}
    Gdy włączysz interfejs Service Usage API, Twój nowy projekt będzie mógł akceptować kontrole limitów. Dlatego do obsługi administracyjnej zasobów i włączania usług należy używać dostawcy z user_project_override (aliasem nie jest potrzebny).

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

Ostatnią rzeczą, jaka jest wymagana do utworzenia projektu Firebase, włącza usługi Firebase w projekcie.

Kontynuując plik konfiguracyjny main.tf, dodaj poniższy blok zasobów.

Jak wspomnieliśmy powyżej, blok zasobów korzysta z dostawcy z user_project_override (alias nie jest potrzebny).

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, że oczekuje na włączenie bazowych interfejsów API. Bez tej klauzuli Terraform nie wie o zależności 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 to polecenie 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 wyświetla plan działań, które wykona.

    Jeśli 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 # <----

Jeśli chcesz tylko wyświetlić podgląd zmian bez ich zastosowania, zamiast tego możesz użyć polecenia terraform plan.

Zweryfikuj zmiany

Po zakończeniu działania Terraform możesz sprawdzić stan wszystkich włączonych zasobów i usług Terraform, uruchamiając to polecenie:

terraform show

Oto przykład, co powinno być wydrukowane. Twój stan będzie zawierał wartości właściwe 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"
}

Możesz też sprawdzić, czy projekt został utworzony, wyświetlając go w konsoli Firebase.

Projekt Terraform z FriendsChat Codelab wybrany w konsoli Firebase

5. Rejestrowanie aplikacji Firebase za pomocą Terraform

Aby korzystać z Firebase, musisz zarejestrować każdy wariant platformy swojej aplikacji w projekcie Firebase. W ramach tego ćwiczenia w Codelabs wykorzystasz prawdziwą aplikację do testowania i interakcji z elementami udostępnianymi za pomocą Terraform. Jest to aplikacja internetowa, dlatego musisz poprosić Terraform o zarejestrowanie aplikacji internetowej Firebase w nowo utworzonym projekcie Firebase.

Dodaj blok, aby zarejestrować aplikację internetową

Aby zarejestrować swoją aplikację internetową w projekcie Firebase, dołącz do pliku main.tf poniższy blok zasobów.

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

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 poniższe polecenie w katalogu głównym tego samego katalogu, w którym znajduje się plik main.tf (który powinien być web).
    terraform apply
    Pamiętaj, że to polecenie nie spowoduje odtworzenia nowego projektu Google Cloud. Terraform wykryje, że projekt o podanym identyfikatorze już istnieje, a następnie porówna jego bieżący stan z zawartością pliku .tf i wprowadzi znalezione zmiany.
  2. Zapoznaj się z wydrukowanym planem działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij Enter, aby zatwierdzić działania.

Zweryfikuj zmiany

Stan nowo udostępnionego zasobu możesz sprawdzić, uruchamiając to polecenie:

terraform show

Możesz też sprawdzić, czy aplikacja została zarejestrowana w Twoim projekcie, wyświetlając ją w konsoli Firebase. Otwórz Ustawienia projektu i przewiń w dół do sekcji Twoje aplikacje.

6. Skonfiguruj Uwierzytelnianie Firebase

Uwierzytelnianie to ważny element każdej aplikacji. Aby umożliwić użytkownikom logowanie się w Twojej aplikacji internetowej za pomocą kont Google, możesz włączyć Uwierzytelnianie Firebase i skonfigurować metodę logowania przez Google.

W ramach tego ćwiczenia z programowania dostępne są 2 opcje konfiguracji uwierzytelniania Firebase:

  • Opcja 1 (zalecana): skonfiguruj Uwierzytelnianie Firebase w konsoli, które nie wymaga GCIP.
    • Dzięki tej opcji nie musisz wiązać nowego projektu z kontem rozliczeniowym Cloud.
  • Opcja 2. Skonfiguruj Uwierzytelnianie Firebase za pomocą Terraform z użyciem interfejsów API Google Cloud Identity Platform (GCIP).
    • Jeśli użyjesz tej opcji, musisz powiązać nowy projekt z kontem rozliczeniowym Cloud, ponieważ GCIP wymaga, aby projekt był objęty abonamentem Blaze.

Opcja 1. Konfigurowanie uwierzytelniania za pomocą konsoli Firebase

Aby można było skonfigurować Uwierzytelnianie Firebase za pomocą konsoli Firebase, Twój projekt nie musi być objęty abonamentem Blaze.

Aby skonfigurować Uwierzytelnianie Firebase i logować się przez Google:

  1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
  2. Kliknij Uwierzytelnianie, Rozpocznij i wybierz kartę Metoda logowania (lub kliknij tutaj, aby przejść bezpośrednio do tej usługi).
  3. Kliknij Dodaj nowego dostawcę i w sekcji Dodatkowi dostawcy wybierz Google.
  4. Kliknij przełącznik Włącz.
  5. Ustaw nazwę aplikacji, która będzie widoczna publicznie, na przykład na FriendlyChat (nie musi być globalnie niepowtarzalna).
  6. W menu wybierz Adres e-mail zespołu pomocy projektu, a potem kliknij Zapisz.Konfigurowanie uwierzytelniania Firebase w konsoli Firebase
  7. Google powinien być widoczny jako włączony dostawca logowania.Strona Uwierzytelnianie w konsoli Firebase: logowanie przez Google jest włączone

Opcja 2. Konfigurowanie uwierzytelniania przez Terraform za pomocą interfejsów API Google Cloud Identity Platform (GCIP)

Aby skonfigurować uwierzytelnianie Firebase za pomocą Terraform, musisz użyć interfejsów GCIP API, co oznacza, że projekt musi być objęty abonamentem Blaze. Aby przenieść projekt Firebase na wyższy abonament Blaze, powiąż z nim konto rozliczeniowe Cloud.

Włącz płatności za pomocą Terraform

  1. Jeśli nie masz jeszcze konta rozliczeniowego Cloud, pierwszym krokiem jest utworzenie nowego konta w konsoli Google Cloud. W takim przypadku zwróć uwagę na identyfikator konta rozliczeniowego. Identyfikator konta rozliczeniowego znajdziesz na stronie Płatności w sekcji Identyfikator konta rozliczeniowego powiązanego z Twoim projektem.Włączanie konta rozliczeniowego za pomocą konsoli Google Cloud
  2. Aby włączyć płatności w projekcie za pomocą 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łączanie uwierzytelniania Firebase i logowanie się przez Google za pomocą Terraform

  1. Aby udostępnić uwierzytelnianie Firebase za pomocą GCIP, dołącz do pliku main.tf następujące bloki 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. Aby włączyć logowanie się przez Google, musisz mieć klienta OAuth. Przejdź do interfejsów API i konsoli Google Cloud, aby przeprowadzić tę konfigurację.
  3. Ponieważ po raz pierwszy tworzysz identyfikator klienta dla tego projektu, musisz skonfigurować ekran zgody OAuth.
    1. Otwórz stronę ekranu akceptacji OAuth i wybierz utworzony przed chwilą projekt.
    2. Ustaw Typ użytkownika na Zewnętrzne, a następnie kliknij Utwórz.
    3. Na następnym ekranie wykonaj te czynności, a potem kliknij Zapisz i kontynuuj.
      • Ustaw publiczną nazwę aplikacji na przykład na FriendlyChat (nie musi być globalnie unikalna).
      • W menu wybierz Adres e-mail pomocy technicznej dla użytkowników.
      • Wpisz adres e-mail do danych kontaktowych dewelopera.
    4. Na kolejnych ekranach wykonaj te czynności:
      • Zaakceptuj wartości domyślne na stronie Zakresy, a potem kliknij Zapisz i kontynuuj.
      • Zaakceptuj wartości domyślne na stronie Użytkownicy testowi, a potem kliknij Zapisz i kontynuuj.
      • Sprawdź podsumowanie i kliknij Powrót do panelu.
      Konfigurowanie klienta OAuth2 za pomocą konsoli Google Cloud
  4. Skonfiguruj klienta OAuth na stronie Dane logowania, wykonując te czynności:
    1. Kliknij Utwórz dane logowania i wybierz Identyfikator klienta OAuth.
    2. Z menu Typ aplikacji wybierz Aplikacja internetowa.
    3. W polu Nazwa wpisz nazwę aplikacji, na przykład FriendlyChat (nie musi być globalnie unikalna).
    4. Aby zezwolić adresowi URL aplikacji na używanie tego klienta OAuth, skonfiguruj te ustawienia:
      • W sekcji Autoryzowane źródła JavaScript kliknij Dodaj identyfikator URI i wpisz
        https://<PROJECT_ID>.firebaseapp.com, gdzie <PROJECT_ID> to identyfikator projektu ustawiony w main.tf.
      • W sekcji Autoryzowane identyfikatory URI przekierowania kliknij Dodaj identyfikator URI i wpisz
        https://<PROJECT_ID>.firebaseapp.com/__/auth/handler, gdzie <PROJECT_ID> to identyfikator projektu ustawiony w main.tf.
    5. Kliknij Zapisz.
    Uzyskiwanie identyfikatora klienta i obiektu tajnego OAuth2 ze strony Dane logowania w konsoli Google Cloud
  5. Aby umożliwić logowanie się przez Google przy użyciu identyfikatora klienta OAuth i klucza klienta, dołącz do pliku main.tf ten 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 Twoją konfiguracją, uruchom te 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 odtworzenia nowego projektu Google Cloud. Terraform wykryje, że projekt o podanym identyfikatorze już istnieje, i porówna jego bieżący stan z zawartością pliku .tf. Następnie wprowadza wszelkie znalezione zmiany.
  2. Zapoznaj się z wydrukowanym planem działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij Enter, aby zatwierdzić działania.

Zweryfikuj zmiany

  1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
  2. Kliknij Authentication (Uwierzytelnianie), a następnie wybierz kartę Sign-inMethod (Metoda logowania) (lub kliknij tutaj, aby przejść bezpośrednio do tej usługi).
  3. Google powinien być widoczny jako włączony dostawca logowania.Strona Uwierzytelnianie w konsoli Firebase: logowanie przez Google jest włączone

7. Konfigurowanie bazy danych Firestore i jej reguł zabezpieczeń

Na potrzeby aplikacji internetowej w ramach tego ćwiczenia w Codelabs będziesz przechowywać wiadomości między użytkownikami w bazie danych Firestore.

  1. Aby włączyć wymagane interfejsy API i udostępnić instancję bazy danych, dołącz do pliku main.tf te bloki 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.

    Gdy tworzysz aplikację produkcyjną, najlepiej, aby znajdowała się ona w regionie zbliżonym do większości użytkowników i typowym dla innych usług Firebase, takich jak Cloud Functions. W tym ćwiczeniu w Codelabs możesz użyć środowiska us-east1 (Karolina Południowa) lub najbliższego regionu (zobacz lokalizacje Cloud Firestore).
  3. Każda instancja bazy danych Firestore dostępna dla Firebase musi być chroniona przez reguły zabezpieczeń Firebase.

    Przykładowy kod z ćwiczenia z programowania zapewnia zestaw bezpiecznych reguł Firestore w pliku firestore.rules, które można znaleźć w katalogu głównym katalogu web.
  4. Dołącz plik main.tf z następującymi blokami zasobów, aby:
    • Utwórz zestaw reguł zabezpieczeń Firebase na podstawie lokalnego pliku firestore.rules.
    • Zwolnij zestaw reguł dla instancji Firestore.
    . Pamiętaj, że te bloki zasobów odpowiadają kliknięciu przycisku Opublikuj 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 zabezpieczeń.
  6. Sprawdź, czy baza danych jest udostępniona i czy jej reguły zabezpieczeń zostały wdrożone:
    1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
    2. Przejdź do sekcji Baza danych Firestore i kliknij kartę Reguły.
    Weryfikowanie reguł Cloud Firestore przy użyciu konsoli Firebase

8. Konfigurowanie zasobnika Cloud Storage i jego reguł zabezpieczeń

W przypadku aplikacji internetowej należącej do tego ćwiczenia w programie, w zasobniku Cloud Storage będziesz przechowywać obrazy współdzielone przez użytkowników.

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

    Pamiętaj, że domyślny zasobnik Cloud Storage dla Twojego projektu jest udostępniany przez Google App Engine i musi mieć tę samą lokalizację co baza danych Firestore. Więcej informacji znajdziesz w artykule o lokalizacjach App Engine.

    Jeśli chcesz mieć w projekcie wiele zasobników, udostępnij je za pomocą zasobu google_storage_bucket (nie pokazano 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 zasobnik Cloud Storage dostępny dla Firebase musi być chroniony przez reguły zabezpieczeń Firebase.

    Ten przykładowy kod z ćwiczenia z programowania zapewnia zestaw bezpiecznych reguł Firestore w pliku storage.rules, które można znaleźć w katalogu głównym katalogu web.
  3. Dołącz plik main.tf z następującymi blokami zasobów, aby:
    • Utwórz zestaw reguł zabezpieczeń Firebase na podstawie pliku lokalnego.
    • Zwolnij zestaw reguł dla zasobnika na dane.
    . Pamiętaj, że te bloki zasobów odpowiadają kliknięciu przycisku Opublikuj 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 zabezpieczeń.
  5. Sprawdź, czy zasobnik został udostępniony i czy zostały wdrożone jego reguły zabezpieczeń:
    1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
    2. Przejdź do sekcji Miejsce na dane i kliknij kartę Reguły.
    Weryfikowanie reguł zabezpieczeń w konsoli Firebase

9. Uruchamianie aplikacji lokalnie

Teraz możesz już po raz pierwszy uruchomić aplikację internetową. Do udostępniania aplikacji lokalnie będziesz używać emulatora Hostingu Firebase.

  1. Otwórz nowe okno terminala i w katalogu web uruchom to polecenie interfejsu wiersza poleceń Firebase, 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 wiersza poleceń (zwykle http://localhost:5000).

Powinien pojawić się interfejs Twojej aplikacji FriendsChat, który (jeszcze) nie działa. Aplikacja nie jest jeszcze połączona z Firebase, ale jeśli wykonasz kolejne kroki tego ćwiczenia w programie, będzie to możliwe.

Pamiętaj, że za każdym razem, gdy wprowadzasz zmiany w aplikacji internetowej (tak jak w przypadku kroków opisanych w tym ćwiczeniu z programowania), odśwież przeglądarkę, aby zastosować te zmiany do lokalnego adresu URL.

10. Instalowanie, konfigurowanie i inicjowanie Firebase

Aby aplikacja mogła współpracować z Firebase, musi mieć pakiet SDK Firebase oraz konfigurację Firebase dla Twojego projektu Firebase.

Przykładowy kod tego ćwiczenia jest już działającą aplikacją ze wszystkimi zależnościami i funkcjami wymaganymi do korzystania z różnych usług Firebase w aplikacji. Aby zobaczyć, co zostało już zrobione, zajrzyj do web/package.json i web/src/index.js.

Mimo że przykładowy kod jest w większości gotowy, musisz jeszcze wykonać kilka czynności, aby uruchomić aplikację, w tym zainstalować pakiet SDK Firebase, rozpocząć kompilację, dodać do aplikacji konfigurację Firebase i na koniec zainicjować 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 web.
  3. Uruchom npm install, aby pobrać pakiet SDK Firebase.
  4. Uruchom npm update, aby zaktualizować zależności.
  5. Uruchom npm run start, aby uruchomić pakiet internetowy.

Do końca lekcji z programowania Webpack będzie stale ponownie kompilować kod źródłowy.

Dodaj konfigurację Firebase do aplikacji

Musisz też dodać do aplikacji konfigurację Firebase, aby pakiety SDK Firebase wiedzieli, którego projektu Firebase mają używać.

W tym ćwiczeniu w Codelabs możesz pobrać konfigurację Firebase na 2 sposoby:

  • Opcja 1. Uzyskaj konfigurację Firebase z konsoli Firebase.
  • Opcja 2. Uzyskaj konfigurację Firebase za pomocą Terraform.

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

  1. W konsoli Firebase otwórz Ustawienia projektu.
  2. Przewiń w dół do karty Twoje aplikacje, a potem wybierz aplikację internetową.
  3. W panelu fragmentu kodu pakietu SDK Firebase kliknij Konfiguracja, a potem skopiuj fragment kodu konfiguracji.
  4. Wklej konfigurację do pliku web/src/firebase-config.js aplikacji, na przykład:

    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 pomocą Terraform i dodaj ją do bazy kodu

Konfigurację Firebase możesz też uzyskać za pomocą Terraform jako wartości wyjściowej w interfejsie wiersza poleceń.

  1. W pliku main.tf znajdź blok zasobów google_firebase_web_app (blok, który zarejestrował aplikację internetową w projekcie).
  2. Bezpośrednio po nim dodaj te 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. Blok data i output nie są przeznaczone do modyfikowania infrastruktury, więc wystarczy uruchomić podane niżej polecenia.
    1. Aby wczytać konfigurację Firebase aplikacji internetowej do stanu Terraform w katalogu, uruchom to polecenie:
      terraform refresh
    2. Aby wyświetlić wartości konfiguracji Firebase, uruchom to polecenie:
      terraform output –json
      Poniżej znajdziesz przykładowe dane wyjściowe konfiguracji. Wydrukowane dane wyjściowe 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 aplikacji, na przykład:

    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

Aby zainicjować Firebase, dołącz do pliku web/src/index.js swojej aplikacji ten ciąg znaków:

Plik index.js

...

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

Wypróbuj aplikację

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

  1. Odśwież przeglądarkę, w której działa aplikacja.
  2. Teraz możesz już zalogować się przez Google i zacząć publikować wiadomości na czacie. Jeśli masz pliki graficzne, możesz je nawet przesłać.

11. Replikowanie konfiguracji w różnych środowiskach

Terraform świetnie radzi sobie z zarządzaniem wieloma podobnie skonfigurowaną infrastrukturą (na przykład konfigurowaniem przejściowym projektu Firebase, który jest podobny do projektu produkcyjnego).

W ramach tego ćwiczenia w Codelabs utworzysz drugi projekt Firebase, który będzie środowiskiem testowym.

Jeśli chcesz odtworzyć istniejącą konfigurację w celu utworzenia tego projektu przejściowego, masz 2 możliwości:

  • Opcja 1. Utwórz kopię konfiguracji Terraform.
    Ta opcja zapewnia największą elastyczność w zakresie tego, jak bardzo zreplikowany projekt może się różnić od projektu źródłowego.
  • Opcja 2. Użyj ponownie konfiguracji, używając parametru for_each.
    Ta opcja umożliwia ponowne użycie kodu, jeśli każdy projekt nie powinien się znacząco różnić i chcesz wprowadzić zmiany we wszystkich projektach jednocześnie.

Opcja 1. Utwórz kopię konfiguracji Terraform

Ta opcja zapewnia największą elastyczność w zakresie różnic między replikowanym projektem a projektem źródłowym. Obejmuje to na przykład używanie aplikacji o różnych wyświetlanych nazwach i wdrażanie etapowe.

  1. W katalogu głównym katalogu web utwórz nowy plik konfiguracyjny Terraform o nazwie main_staging.tf.
  2. Skopiuj wszystkie bloki zasobów z pliku main.tf (oprócz bloków terraform i provider), a następnie wklej je do pliku main_staging.tf.
  3. Następnie musisz zmodyfikować każdy zreplikowanych bloków zasobów w main_staging.tf, aby współpracowały z projektem przejściowym:
    • Etykiety zasobów: aby uniknąć konfliktu, użyj nowej nazwy. Możesz na przykład zmienić nazwę resource "google_project" "default" na resource "google_project" "staging".
    • Materiały referencyjne: zaktualizuj każdy z nich. Na przykład zmień google_firebase_project.default.project na google_firebase_project.staging.project.
    . Pełną konfigurację pliku main_staging.tf znajdziesz w repozytorium GitHub tego ćwiczenia z programowania:

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

    Jeśli chcesz użyć tej konfiguracji, wykonaj te czynności:
    1. Skopiuj konfigurację z narzędzia main_staging-copypaste.tf, a następnie wklej ją do pliku main_staging.tf.
    2. W pliku main_staging.tf wykonaj te czynności:
      • W google_projectbloku zasobów zaktualizuj atrybuty name, atrybut project-id i (jeśli konfigurujesz uwierzytelnianie za pomocą Terraform) własne wartości dla atrybutu billing_account.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name o własną wartość.
      • W blokach zasobów google_firestore_database i google_app_engine_application zaktualizuj atrybuty 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ć nowy „etap przejściowy” projekt Firebase i wszystkie jego zasoby oraz włączyć usługi.
  5. Upewnij się, że wszystkie elementy zostały udostępnione i włączone zgodnie z oczekiwaniami. W tym celu sprawdź to wcześniej w konsoli Firebase.

Opcja 2. Użyj ponownie konfiguracji w for_each

Ta opcja umożliwia ponowne użycie kodu, jeśli każdy projekt nie powinien się znacząco różnić i chcesz propagować zmiany we wszystkich projektach jednocześnie. Wykorzystuje metaargument for_each w języku Terraform.

  1. Otwórz plik main.tf.
  2. Do każdego bloku zasobów, który chcesz zreplikować, 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, znajdziesz w repozytorium GitHub tego ćwiczenia z programowania:

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

    Jeśli chcesz użyć tej konfiguracji, wykonaj te czynności:
    1. Skopiuj konfigurację z narzędzia main-foreach.tf, a następnie wklej ją do pliku main.tf.
    2. W pliku main.tf wykonaj te czynności:
      • W google_projectbloku zasobów zaktualizuj atrybuty name, atrybut project-id i (jeśli konfigurujesz uwierzytelnianie za pomocą Terraform) własne wartości dla atrybutu billing_account.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name o własną wartość.
      • W blokach zasobów google_firestore_database i google_app_engine_application zaktualizuj atrybuty location_id własną wartością.
  3. Zamiast stosować tę konfigurację od razu, warto zrozumieć i naprawić kilka rzeczy dotyczących tego, jak Terraform interpretuje tę konfigurację w porównaniu z dotychczasową infrastrukturą.
    1. Jeśli zastosujesz teraz tę konfigurację, która korzysta z for_each, adresy zasobów będą wyglądać tak:
      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 ćwiczenia z programowania jest znany Terraform jako:
      google_project.default
google_firebase_project.default
google_firebase_android_app.default
    2. Uruchom terraform plan, aby zobaczyć, jakie działania Terraform wykonałby w przypadku bieżącego stanu.

      Dane wyjściowe powinny pokazywać, że Terraform usunie projekt utworzony w pierwszej części tego ćwiczenia z programowania i utworzy 2 nowe projekty. Dzieje się tak, ponieważ Terraform nie wie, że projekt pod adresem google_project.default został przeniesiony pod nowy adres google_project.default["prod"].
    3. Aby rozwiązać ten problem, 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 polecenie terraform state mv dla google_firebase_project, google_firebase_web_app i wszystkich pozostałych bloków zasobów w pliku main.tf.
    5. Jeśli uruchomisz teraz ponownie polecenie terraform plan, nie powinno to pokazywać, że Terraform usunie projekt utworzony w pierwszej części tego ćwiczenia z programowania.
  4. Uruchom terraform apply, aby udostępnić nowy „etap przejściowy” projekt Firebase i wszystkie jego zasoby oraz włączyć usługi.
  5. Upewnij się, że wszystkie elementy zostały udostępnione i włączone zgodnie z oczekiwaniami. W tym celu sprawdź to wcześniej w konsoli Firebase.

12. Krok dodatkowy: wdróż aplikacje przejściowe i produkcyjne

  1. W bazie kodu aplikacji zmień firebase-config.js, tak aby zamiast tego korzystał z konfiguracji Firebase z projektu przejściowego.

    Aby przypomnieć sobie, jak utworzyć konfigurację Firebase i dodać ją do aplikacji, zapoznaj się z wcześniejszym krokiem tego ćwiczenia z programowania: Dodawanie konfiguracji Firebase do aplikacji.
  2. W katalogu głównym web uruchom podane niżej polecenie, aby wdrożyć aplikację w przejściowym projekcie Firebase.
    firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
  3. Otwórz w przeglądarce aplikację przejściową, korzystając z adresu URL podanego w danych wyjściowych firebase deploy. Spróbuj się zalogować, wysyłać wiadomości i przesyłać obrazy.

    Gdy wdrażasz aplikację w projekcie Firebase, korzysta ona z prawdziwych zasobów Firebase, a nie z emulowanych. Podczas korzystania z aplikacji przejściowej dane i obrazy powinny pojawiać się w projekcie testowym w konsoli Firebase.
  4. Po przetestowaniu aplikacji na etapie przejściowym zmień firebase-config.js z powrotem na używanie konfiguracji Firebase projektu produkcyjnego (pierwszego projektu utworzonego w ramach tego ćwiczenia).
  5. W katalogu głównym web uruchom podane niżej polecenie, aby wdrożyć aplikację w produkcyjnym projekcie Firebase.
    firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
  6. Otwórz produkcyjną aplikację w przeglądarce, korzystając z adresu URL podanego w danych wyjściowych firebase deploy. Spróbuj się zalogować, wysłać wiadomości i przesłać obrazy.

    Dane i obrazy powinny pojawić się w Twoim projekcie produkcyjnym w konsoli Firebase.
  7. Gdy skończysz korzystać z tych 2 aplikacji w ramach tego ćwiczenia z programowania, możesz zatrzymać ich obsługę przez Firebase. Uruchom to polecenie dla każdego ze swoich projektów:
    firebase hosting:disable --project=<STAGING_PROJECT_ID>

    firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>

13. Gratulacje!

Udało Ci się skonfigurować Terraform do skonfigurowania aplikacji internetowej do obsługi czatu w czasie rzeczywistym. Stosujesz też sprawdzone metody dotyczące środowisk programistycznych, tworząc oddzielne projekty Firebase na potrzeby testowania i produkcji.

Omówione zagadnienia

  • Zarządzanie zasobami w chmurze za pomocą interfejsu wiersza poleceń Terraform
  • Używanie Terraform do konfigurowania usług Firebase (uwierzytelniania, Firestore, Cloud Storage i reguł zabezpieczeń)
  • Lokalne uruchamianie i testowanie aplikacji internetowej przy użyciu Pakietu emulatorów lokalnych Firebase.
  • Importowanie Firebase do aplikacji internetowej
  • Replikowanie konfiguracji w wielu środowiskach za pomocą Terraform

Więcej informacji o Firebase i Terraform znajdziesz w naszej dokumentacji. Znajdziesz tu listę wszystkich usług Firebase obsługujących Terraform, przykładowe konfiguracje Terraform do typowych przypadków użycia oraz pomocne rozwiązania w rozwiązywaniu problemów i najczęstsze pytania.