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

1. Wprowadzenie

Cele

Za pomocą Terraform możesz konfigurować projekt Firebase i nim zarządzać, w tym programowo konfigurować infrastrukturę i usługi Firebase.

W tym samouczku najpierw opisujemy, jak utworzyć plik konfiguracyjny Terraform, aby utworzyć nowy projekt Firebase, a następnie jak skonfigurować aplikacje i usługi Firebase, których chcesz używać w tym projekcie. Omówimy też podstawy wiersza poleceń Terraform, takie jak wyświetlanie podglądu zmian, które mają zostać wprowadzone, a następnie ich wdrażanie.

Jeśli chcesz dowiedzieć się, jak konfigurować projekty i usługi Firebase oraz nimi zarządzać za pomocą Terraform, ten kurs jest dla Ciebie.

Czego się nauczysz

  • Jak utworzyć plik konfiguracyjny Terraform (*.tf)
  • Jak używać poleceń interfejsu wiersza poleceń Terraform do zarządzania infrastrukturą
  • Jak zmodyfikować konfigurację, aby zaktualizować zasoby i usługi
  • Jak zastosować konfigurację w prawdziwej aplikacji internetowej (o nazwie Friendly Chat)
  • Definiowanie równoległych (i zsynchronizowanych) konfiguracji w różnych środowiskach (produkcyjnym, przejściowym itp.)

Czego potrzebujesz

Aby ukończyć to ćwiczenie, musisz mieć podstawową znajomość Terraform i jego terminologii, w tym spełniać te wymagania wstępne:

W tym laboratorium znajdziesz prawdziwą przykładową aplikację, dzięki której możesz testować i wypróbowywać elementy udostępniane przez Terraform. Aby to zrobić, potrzebujesz:

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

2. Pobieranie kodu początkowego

W tym ćwiczeniu w Codelabs możesz przetestować, co udostępniasz za pomocą Terraform, w prawdziwej aplikacji internetowej. Zalecamy wykonanie tego ćwiczenia, aby poznać wszystkie kroki potrzebne do korzystania z zasobów udostępnionych przez Terraform.

Sklonuj repozytorium GitHub z poziomu wiersza poleceń:

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

Jeśli nie masz zainstalowanego narzędzia git, możesz pobrać repozytorium jako plik ZIP.

3. Tworzenie konfiguracji Terraform

Konfiguracja Terraform

  1. W kodzie pobranej przykładowej aplikacji przejdź do katalogu głównego web.
  2. W katalogu głównym utwórz plik konfiguracji 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, jak operacje z Terraform będą sprawdzane pod kątem limitu. W przypadku większości zasobów należy używać user_project_override = true, co oznacza sprawdzanie limitu w odniesieniu do własnego projektu Firebase. Aby jednak skonfigurować nowy projekt tak, aby mógł akceptować sprawdzanie limitów, musisz najpierw użyć user_project_override=false. Składnia Terraform alias pozwala odróżnić te 2 konfiguracje dostawcy w dalszych krokach tego samouczka.

Inicjowanie Terraform w katalogu

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

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

terraform init

4. Tworzenie projektu Firebase za pomocą Terraform

Pamiętaj, że każdy projekt Firebase jest w rzeczywistości projektem Google Cloud, w którym włączone są usługi Firebase.

Dodawanie blokad do projektu Google Cloud i interfejsów API

  1. Najpierw udostępnij bazowy projekt Google Cloud.

    Do pliku konfiguracyjnego main.tf dodaj ten 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. Wartość project_id jednoznacznie identyfikuje Twój projekt w Google, więc upewnij się, że podajesz 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 interfejsy API: Service Usage API i Firebase Management API.

    Włączenie tych interfejsów API jest zwykle obsługiwane w tle, gdy używasz konsoli Firebase do tworzenia projektu Firebase, ale Terraform musi otrzymać wyraźne polecenie, aby to zrobić.

    Do pliku konfiguracyjnego main.tf (bezpośrednio pod blokiem, który tworzy nowy projekt w 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
}
    Po włączeniu interfejsu Service Usage API Twój nowy projekt będzie mógł akceptować sprawdzanie limitów. Dlatego w przypadku wszystkich kolejnych operacji związanych z udostępnianiem zasobów i włączaniem usług używaj dostawcy z user_project_override (alias nie jest potrzebny).

Dodawanie bloku w celu włączenia usług Firebase

Ostatnią rzeczą, którą musisz zrobić, aby „utworzyć projekt Firebase”, jest włączenie w nim usług Firebase.

W pliku konfiguracyjnym main.tf dodaj ten blok zasobów.

Jak wspomnieliśmy powyżej, ten blok zasobów korzysta z dostawcy bez 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 nakazuje Terraformowi poczekać na włączenie bazowych interfejsów API. Bez tego klauzula Terraform nie będzie znać 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, w którym znajduje się plik main.tf (powinien to być katalog web):
    terraform apply
  2. W terminalu Terraform wyświetli 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 stosowania, możesz użyć polecenia terraform plan.

Sprawdź zmiany

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

terraform show

Oto przykład tego, co powinno zostać wydrukowane. 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"
}

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

Projekt Terraform FriendlyChat Codelab wybrany w konsoli Firebase

5. Rejestrowanie aplikacji Firebase za pomocą Terraform

Aby korzystać z Firebase, musisz zarejestrować w projekcie Firebase każdą wersję platformową aplikacji. W tym ćwiczeniu z programowania użyjesz prawdziwej aplikacji do testowania i interakcji z zasobami, które udostępnisz za pomocą Terraform. Ta aplikacja jest aplikacją internetową, więc musisz poinformować Terraform, aby zarejestrował aplikację internetową Firebase w nowo utworzonym projekcie Firebase.

Dodawanie bloku do rejestrowania aplikacji internetowej

Aby zarejestrować aplikację internetową w projekcie Firebase, dodaj do pliku main.tf ten blok zasobów.

Musisz podać własną 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 to polecenie w katalogu głównym, w którym znajduje się plik main.tf (powinien to być katalog 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 jego obecny stan z zawartością pliku .tf i wprowadzi wszelkie wykryte zmiany.
  2. Sprawdź wydrukowany plan działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij Enter, aby zatwierdzić działania.

Sprawdź zmiany

Stan nowo utworzonego zasobu możesz sprawdzić, uruchamiając to polecenie:

terraform show

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

6. Konfigurowanie Uwierzytelniania Firebase

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

W tym laboratorium kodu udostępniamy 2 różne opcje konfiguracji uwierzytelniania Firebase:

  • Opcja 1 (zalecana): skonfiguruj uwierzytelnianie Firebase w konsoli. Nie wymaga to GCIP.
    • Skorzystanie z tej opcji oznacza, że nie musisz powiązywać nowego projektu z kontem rozliczeniowym Cloud.
  • Opcja 2: skonfiguruj uwierzytelnianie Firebase za pomocą Terraform przy użyciu interfejsów API Google Cloud Identity Platform (GCIP).
    • Jeśli wybierzesz tę opcję, musisz powiązać nowy projekt z kontem rozliczeniowym Cloud, ponieważ GCIP wymaga, aby projekt korzystał z abonamentu Blaze.

Opcja 1. Konfigurowanie uwierzytelniania za pomocą konsoli Firebase

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

Aby skonfigurować uwierzytelnianie Firebase i logowanie za pomocą Google:

  1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
  2. Kliknij Uwierzytelnianie, a następnie Rozpocznij i kartę Metoda logowania (możesz też kliknąć tutaj, aby przejść bezpośrednio do tej karty).
  3. Kliknij Dodaj nowego dostawcę, a w sekcji Dodatkowi dostawcy wybierz Google.
  4. Włącz przełącznik Włącz.
  5. Ustaw publiczną nazwę aplikacji na przykład na FriendlyChat (nie musi być unikalna na całym świecie).
  6. Wybierz Adres e-mail pomocy dotyczącej projektu z menu, a następnie kliknij Zapisz.Konfigurowanie uwierzytelniania Firebase w konsoli Firebase
  7. Google powinno być widoczne jako włączony dostawca logowania.Strona Uwierzytelnianie w konsoli Firebase: logowanie przez Google włączone

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

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 abonament Blaze, musisz powiązać z nim konto Cloud Billing.

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

  1. Jeśli nie masz jeszcze konta rozliczeniowego w Cloud, pierwszym krokiem jest utworzenie nowego konta w konsoli Google Cloud. Zanotuj identyfikator konta rozliczeniowego. Identyfikator konta rozliczeniowego znajdziesz na stronie Płatności w sekcji Identyfikator konta rozliczeniowego powiązanej z Twoim projektem.Włączanie konta płatniczego 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 logowania się przez Google za pomocą Terraform

  1. Aby udostępnić uwierzytelnianie Firebase za pomocą GCIP, dodaj do pliku main.tf te 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. Włączenie Logowania przez Google wymaga posiadania klienta OAuth. Aby to zrobić, otwórz sekcję Interfejsy API i usługi w konsoli Google Cloud.
  3. To pierwszy raz, gdy tworzysz identyfikator klienta w tym projekcie, więc musisz skonfigurować ekran zgody OAuth.
    1. Otwórz stronę Ekran zgody OAuth, a potem wybierz utworzony projekt.
    2. Ustaw Typ użytkownika na Zewnętrzny, 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ć unikalna na całym świecie).
      • W menu wybierz Adres e-mail pomocy dla użytkowników.
      • Wpisz adres e-mail w sekcji Dane kontaktowe dewelopera.
    4. Na kolejnych ekranach wykonaj te czynności:
      • Na stronie Zakresy zaakceptuj wartości domyślne i kliknij Zapisz i kontynuuj.
      • Na stronie Użytkownicy testowi zaakceptuj wartości domyślne, a potem kliknij Zapisz i kontynuuj.
      • Sprawdź podsumowanie i kliknij Wróć 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. W menu Typ aplikacji wybierz Aplikacja internetowa.
    3. W polu Nazwa wpisz nazwę aplikacji, np. FriendlyChat (nie musi być globalnie niepowtarzalna).
    4. Zezwól adresowi URL aplikacji na korzystanie z tego klienta OAuth, ustawiając te wartości:
      • W sekcji Autoryzowane źródła JavaScript kliknij Dodaj 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 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 i tajnego klucza klienta OAuth2 na stronie Dane logowania w konsoli Google Cloud
  5. Aby włączyć logowanie przez Google za pomocą identyfikatora klienta OAuth i tajnego klucza klienta, dodaj 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 konfiguracją, uruchom te polecenia w katalogu głównym, w którym znajduje się plik main.tf (powinien to być katalog web):
    export TF_VAR_oauth_client_secret="<YOUR_OAUTH_CLIENT_SECRET>"

    terraform apply
    Pamiętaj, że uruchomienie polecenia terraform apply nie spowoduje ponownego utworzenia nowego projektu Google Cloud. Terraform wykryje, że projekt o podanym identyfikatorze już istnieje, i porówna bieżący stan projektu z tym, co znajduje się w pliku .tf. Następnie wprowadzi wszystkie znalezione zmiany.
  2. Sprawdź wydrukowany plan działań. Jeśli wszystko wygląda zgodnie z oczekiwaniami, wpisz yes i naciśnij Enter, aby zatwierdzić działania.

Sprawdź zmiany

  1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
  2. Kliknij Uwierzytelnianie, a następnie kartę Metoda logowania (lub kliknij tutaj, aby przejść bezpośrednio do tej karty).
  3. Google powinno być widoczne jako włączony dostawca logowania.Strona Uwierzytelnianie w konsoli Firebase: logowanie przez Google włączone

7. Konfigurowanie bazy danych Firestore i jej reguł bezpieczeństwa

W przypadku aplikacji internetowej z tego laboratorium 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, dodaj 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.

    Podczas tworzenia aplikacji produkcyjnej warto wybrać region, który jest blisko większości użytkowników i jest wspólny z innymi usługami Firebase, takimi jak Cloud Functions. W tym samouczku możesz użyć regionu us-east1 (Karolina Południowa) lub regionu znajdującego się najbliżej Ciebie (patrz 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 w tym laboratorium zawiera zestaw bezpiecznych reguł Firestore w pliku firestore.rules, który znajdziesz w katalogu głównym web.
  4. Aby wykonać te czynności, dodaj do pliku main.tf te bloki zasobów:
    • Utwórz zbiór reguł zabezpieczeń Firebase z lokalnego pliku firestore.rules.
    • Opublikuj zestaw reguł dla instancji Firestore.
    Pamiętaj, że te bloki zasobów działają tak samo jak kliknięcie przycisku Opublikuj w konsoli Firebase lub uruchomienie polecenia 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 polecenie terraform apply, aby udostępnić bazę danych Firestore i wdrożyć jej reguły zabezpieczeń.
  6. Sprawdź, czy baza danych została udostępniona i czy wdrożono jej reguły bezpieczeństwa:
    1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
    2. Otwórz sekcję Baza danych Firestore, a następnie kliknij kartę Reguły.
    Weryfikowanie reguł Cloud Firestore za pomocą konsoli Firebase

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

W aplikacji internetowej z tego laboratorium będziesz przechowywać obrazy udostępniane przez użytkowników w zasobniku Cloud Storage.

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

    Pamiętaj, że domyślny zasobnik Cloud Storage w Twoim projekcie jest udostępniany przez Google App Engine i musi mieć taką samą lokalizację jak baza danych Firestore. Więcej informacji znajdziesz w sekcji Lokalizacje App Engine.

    Jeśli w projekcie chcesz mieć kilka zasobników, utwórz je za pomocą google_storage_bucket zasobu (nie jest to pokazane w tym laboratorium).

    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.

    Przykładowy kod w tym laboratorium zawiera zestaw bezpiecznych reguł Firestore w pliku storage.rules, który znajdziesz w katalogu głównym web.
  3. Aby wykonać te czynności, dodaj do pliku main.tf te bloki zasobów:
    • Utwórz z pliku lokalnego zbiór reguł zabezpieczeń Firebase.
    • Zwolnij zestaw reguł dla zasobnika Cloud Storage.
    Pamiętaj, że te bloki zasobów działają tak samo jak kliknięcie przycisku Opublikuj w konsoli Firebase lub uruchomienie polecenia 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 polecenie 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 wdrożono jego reguły zabezpieczeń:
    1. W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
    2. Otwórz sekcję Przechowywanie danych i kliknij kartę Reguły.
    Weryfikowanie reguł zabezpieczeń za pomocą konsoli Firebase

9. Lokalne uruchamianie aplikacji

Możesz teraz po raz pierwszy uruchomić aplikację internetową. Do lokalnego obsługiwania aplikacji użyjesz emulatora Hostingu Firebase.

  1. Otwórz nowe okno terminala i w katalogu web uruchom to polecenie interfejsu 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).

Powinien pojawić się interfejs aplikacji FriendlyChat, który (jeszcze!) nie działa. Aplikacja nie jest jeszcze połączona z Firebase, ale po wykonaniu kolejnych kroków tego samouczka zostanie połączona.

Pamiętaj, że za każdym razem, gdy wprowadzisz zmiany w aplikacji internetowej (tak jak w kolejnych krokach tego samouczka), musisz odświeżyć przeglądarkę, aby zaktualizować lokalny adres URL.

10. Instalowanie, konfigurowanie i inicjowanie Firebase

Aby aplikacja działała z Firebase, musi mieć pakiet SDK Firebase i konfigurację Firebase dla projektu Firebase.

Przykładowy kod do tego szkolenia to działająca aplikacja ze wszystkimi zależnościami i wymaganymi funkcjami do korzystania z różnych usług Firebase. Jeśli chcesz zobaczyć, co zostało już zrobione, zajrzyj do katalogów web/package.json i web/src/index.js.

Chociaż przykładowy kod jest w większości gotowy, musisz jeszcze wykonać kilka czynności, aby uruchomić aplikację, m.in. zainstalować pakiet SDK Firebase, rozpocząć kompilację, dodać konfigurację Firebase do aplikacji i w końcu zainicjować Firebase.

Zainstaluj pakiet SDK Firebase i rozpocznij kompilację webpack

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

  1. Otwórz nowe okno terminala.
  2. Sprawdź, czy 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ć webpack.

Przez resztę tego laboratorium webpack będzie stale ponownie kompilować kod źródłowy.

Dodawanie konfiguracji Firebase do aplikacji

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

W tym laboratorium masz 2 opcje uzyskania konfiguracji Firebase:

  • Opcja 1: pobierz konfigurację Firebase z konsoli Firebase.
  • Opcja 2. Uzyskanie konfiguracji Firebase za pomocą Terraform.

Opcja 1. Pobierz 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 Config (Konfiguracja), a następnie skopiuj fragment kodu konfiguracji.
  4. Wklej konfigurację do pliku web/src/firebase-config.js w aplikacji, jak pokazano poniżej:

    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. Pobierz konfigurację za pomocą Terraform i dodaj ją do bazy kodu

Możesz też uzyskać konfigurację Firebase za pomocą Terraform jako wartość wyjściową w interfejsie wiersza poleceń.

  1. W pliku main.tf znajdź blok zasobów google_firebase_web_app (blok, który zarejestrował aplikację internetową w Twoim projekcie).
  2. Bezpośrednio po tym bloku 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. Bloki data i output nie są przeznaczone do modyfikowania infrastruktury w żaden sposób, więc wystarczy, że uruchomisz te polecenia.
    1. Aby wczytać konfigurację Firebase aplikacji internetowej do stanu Terraform w katalogu, uruchom to polecenie:
      terraform refresh
    2. Aby wydrukować wartości konfiguracji Firebase, uruchom to polecenie:
      terraform output –json
      Poniżej znajdziesz przykładowe dane wyjściowe konfiguracji. Wydruk będzie 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 (konfigurację) do pliku web/src/firebase-config.js aplikacji w ten 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",
};

...

Inicjowanie Firebase w aplikacji

Aby zainicjować Firebase, dodaj do pliku web/src/index.js aplikacji ten kod:

index.js

...

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

Wypróbuj aplikację

Po skonfigurowaniu wszystkich ustawień Firebase możesz wypróbować działającą aplikację internetową.

  1. Odśwież przeglądarkę, w której działa aplikacja.
  2. Od tego momentu logowanie się za pomocą Google powinno być możliwe, a Ty będziesz mieć możliwość publikowania wiadomości na czacie. Jeśli masz pliki z obrazami, możesz je przesłać.

11. Replikowanie konfiguracji w różnych środowiskach

Terraform doskonale sprawdza się w zarządzaniu wieloma podobnie skonfigurowanymi infrastrukturami (np. konfigurowaniem testowego projektu Firebase, który jest podobny do projektu produkcyjnego).

W tym laboratorium kodowania utworzysz drugi projekt Firebase, który będzie środowiskiem przejściowym.

Aby skopiować istniejącą konfigurację i utworzyć ten projekt testowy, masz 2 możliwości:

  • Opcja 1: utwórz kopię konfiguracji Terraform.
    Ta opcja zapewnia największą elastyczność w zakresie różnic między replikowanym a źródłowym projektem.
  • Opcja 2: wielokrotne używanie konfiguracji za pomocą funkcji for_each.
     Ta opcja zapewnia większą możliwość ponownego wykorzystania kodu, jeśli projekty nie powinny się znacząco różnić i chcesz propagować 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 sklonowanym projektem a projektem źródłowym, np. w przypadku aplikacji o różnych wyświetlanych nazwach i wdrażanych etapami.

  1. W katalogu głównym web utwórz nowy plik konfiguracji 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 w projekcie testowym:
    • Etykiety zasobów: użyj nowej nazwy, aby uniknąć konfliktu. Na przykład zmień nazwę resource "google_project" "default" na resource "google_project" "staging".
    • Odwołania do zasobów: zaktualizuj każde 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 laboratorium 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 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 bloku zasobów google_project zaktualizuj atrybuty name, project-id i (jeśli uwierzytelnianie zostało skonfigurowane za pomocą Terraform) billing_account, podając własne wartości.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name, podając własną wartość.
      • W blokach zasobów google_firestore_database i google_app_engine_application zaktualizuj atrybuty location_id, podając własną wartość.
    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 projekt Firebase „staging” i wszystkie jego zasoby oraz włączyć jego usługi.
  5. Sprawdź, czy wszystko zostało skonfigurowane i włączone zgodnie z oczekiwaniami, tak jak wcześniej w konsoli Firebase.

Opcja 2. Wielokrotne używanie konfiguracji za pomocą for_each

Ta opcja zapewnia większą możliwość ponownego wykorzystania kodu, jeśli projekty nie powinny się znacząco różnić i chcesz propagować zmiany we wszystkich projektach jednocześnie. Korzysta z metaargumentu for_each w języku Terraform.

  1. Otwórz plik main.tf.
  2. Do każdego bloku zasobów, który chcesz powielić, dodaj metaargument for_each w ten 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 laboratorium programowania:

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

    Jeśli chcesz użyć tej konfiguracji, wykonaj te czynności:
    1. Skopiuj konfigurację z main-foreach.tf, a następnie wklej ją do pliku main.tf.
    2. W pliku main.tf wykonaj te czynności:
      • W bloku zasobów google_project zaktualizuj atrybuty name, project-id i (jeśli uwierzytelnianie zostało skonfigurowane za pomocą Terraform) billing_account, podając własne wartości.
      • W bloku zasobów google_firebase_web_app zaktualizuj atrybut display_name, podając własną wartość.
      • W blokach zasobów google_firestore_database i google_app_engine_application zaktualizuj atrybuty location_id, podając własną wartość.
  3. Zamiast od razu stosować tę konfigurację, warto zrozumieć i naprawić kilka kwestii związanych z tym, jak Terraform interpretuje tę konfigurację w porównaniu z dotychczasową infrastrukturą.
    1. Jeśli zastosujesz 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 laboratorium kodowania jest znany Terraformowi jako:
      google_project.default
google_firebase_project.default
google_firebase_android_app.default
    2. Uruchom polecenie terraform plan, aby sprawdzić, jakie działania wykona Terraform w bieżącym stanie.

      Dane wyjściowe powinny wskazywać, że Terraform usunie projekt utworzony w pierwszej części tego samouczka i utworzy 2 nowe projekty. Wynika to z tego, że Terraform nie wie, że projekt pod adresem google_project.default został przeniesiony pod 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 polecenie terraform state mv dla bloków google_firebase_project, google_firebase_web_app i wszystkich innych bloków zasobów w pliku main.tf.
    5. Jeśli teraz ponownie uruchomisz polecenie terraform plan, nie powinno ono wskazywać, że Terraform usunie projekt utworzony w pierwszej części tego laboratorium.
  4. Uruchom terraform apply, aby udostępnić nowy projekt Firebase „staging” i wszystkie jego zasoby oraz włączyć jego usługi.
  5. Sprawdź, czy wszystko zostało skonfigurowane i włączone zgodnie z oczekiwaniami, tak jak wcześniej w konsoli Firebase.

12. Krok dodatkowy: wdróż aplikacje w środowisku testowym i produkcyjnym

  1. W kodzie aplikacji zmień firebase-config.js, aby zamiast tego używać konfiguracji Firebase z projektu testowego.

    Aby przypomnieć sobie, jak uzyskać konfigurację Firebase i dodać ją do aplikacji, zapoznaj się z wcześniejszym krokiem tego kursu: Dodawanie konfiguracji Firebase do aplikacji.
  2. W katalogu głównym web uruchom to polecenie, aby wdrożyć aplikację w przejściowym projekcie Firebase.
    firebase deploy --only hosting --project=<STAGING_PROJECT_ID>
  3. Otwórz aplikację testową w przeglądarce, korzystając z adresu URL wyświetlanego w wyniku działania polecenia firebase deploy. Spróbuj się zalogować, wysłać wiadomości i przesłać obrazy.

    Gdy wdrażasz aplikację w projekcie Firebase, korzysta ona z prawdziwych zasobów Firebase, a nie z zasobów emulowanych. Podczas korzystania z aplikacji w wersji testowej w projekcie testowym w konsoli Firebase powinny pojawiać się dane i obrazy.
  4. Po przetestowaniu aplikacji w środowisku testowym zmień firebase-config.js z powrotem na konfigurację Firebase projektu produkcyjnego (pierwszego projektu utworzonego w tym laboratorium).
  5. W katalogu głównym web uruchom to polecenie, aby wdrożyć aplikację w produkcyjnym projekcie Firebase.
    firebase deploy --only hosting --project=<PRODUCTION_PROJECT_ID>
  6. Otwórz aplikację produkcyjną w przeglądarce, korzystając z adresu URL wydrukowanego w wyniku działania polecenia firebase deploy. Spróbuj się zalogować, wysłać wiadomości i przesłać obrazy.

    Dane i obrazy powinny pojawić się w projekcie produkcyjnym w konsoli Firebase.
  7. Gdy skończysz korzystać z obu aplikacji w tym laboratorium, możesz zatrzymać ich obsługę przez Firebase. Uruchom to polecenie w przypadku każdego projektu:
    firebase hosting:disable --project=<STAGING_PROJECT_ID>

    firebase hosting:disable --project=<PRODUCTION_PROJECT_ID>

13. Gratulacje!

Udało Ci się skonfigurować aplikację internetową do czatu w czasie rzeczywistym za pomocą Terraform. Zastosowano też sprawdzone metody dotyczące środowisk deweloperskich, tworząc osobne projekty Firebase na potrzeby testowania i produkcji.

Omówione zagadnienia

  • Zarządzanie zasobami w chmurze za pomocą interfejsu wiersza poleceń Terraform
  • Konfigurowanie usług Firebase (Uwierzytelnianie, Firestore, Cloud Storage i reguły zabezpieczeń) za pomocą Terraform
  • Uruchamianie i testowanie aplikacji internetowej lokalnie za pomocą 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 tam listę wszystkich usług Firebase obsługujących Terraform, przykładowe konfiguracje Terraform dla typowych przypadków użycia oraz przydatne wskazówki dotyczące rozwiązywania problemów i odpowiedzi na najczęstsze pytania.