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
- Terminal/konsola
- wybrany edytor IDE/tekst, taki jak WebStorm, Atom, Sublime lub VS Code;
- wybrana przeglądarka, np. Chrome;
- Interfejs wiersza poleceń Google Cloud (gcloud CLI) – zainstaluj ten interfejs wiersza poleceń i zaloguj się za pomocą konta użytkownika lub konta usługi.
Aby wykonać te ćwiczenia, musisz opanować Terraform i jego terminologię, w tym te wymagania wstępne:
- Zainstaluj Terraform i zapoznaj się z Terraform, korzystając z ich oficjalnych samouczków
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
- W bazie kodu pobranej przykładowej aplikacji przejdź do głównego katalogu katalogu
web
. - 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
- Najpierw udostępnij bazowy projekt Google Cloud.
Do pliku konfiguracyjnegomain.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" } }
- 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 konfiguracyjnegomain.tf
(tuż pod blokiem, który tworzy nowy projekt Cloud) dodaj ten blok zasobów:
main.tf 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... # 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 }
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ę
- 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
- W terminalu Terraform wyświetla plan działań, które wykona.
Jeśli wszystko wygląda zgodnie z oczekiwaniami, zatwierdź działania, wpisującyes
.
main.tfTerraform 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.
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ę
- 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
). 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ą plikuterraform apply
.tf
i wprowadzi znalezione zmiany. - 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:
- W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
- Kliknij Uwierzytelnianie, Rozpocznij i wybierz kartę Metoda logowania (lub kliknij tutaj, aby przejść bezpośrednio do tej usługi).
- Kliknij Dodaj nowego dostawcę i w sekcji Dodatkowi dostawcy wybierz Google.
- Kliknij przełącznik Włącz.
- Ustaw nazwę aplikacji, która będzie widoczna publicznie, na przykład na
FriendlyChat
(nie musi być globalnie niepowtarzalna). - W menu wybierz Adres e-mail zespołu pomocy projektu, a potem kliknij Zapisz.
- Google powinien być widoczny jako włączony dostawca logowania.
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
- 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.
- Aby włączyć płatności w projekcie za pomocą Terraform, dodaj atrybut
billing_account
do istniejącego zasobugoogle_project
w plikumain.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
- 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, ] }
- Aby włączyć logowanie się przez Google, musisz mieć klienta OAuth. Przejdź do interfejsów API i konsoli Google Cloud, aby przeprowadzić tę konfigurację.
- Ponieważ po raz pierwszy tworzysz identyfikator klienta dla tego projektu, musisz skonfigurować ekran zgody OAuth.
- Otwórz stronę ekranu akceptacji OAuth i wybierz utworzony przed chwilą projekt.
- Ustaw Typ użytkownika na Zewnętrzne, a następnie kliknij Utwórz.
- 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.
- Ustaw publiczną nazwę aplikacji na przykład na
- 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.
- Skonfiguruj klienta OAuth na stronie Dane logowania, wykonując te czynności:
- Kliknij Utwórz dane logowania i wybierz Identyfikator klienta OAuth.
- Z menu Typ aplikacji wybierz Aplikacja internetowa.
- W polu Nazwa wpisz nazwę aplikacji, na przykład
FriendlyChat
(nie musi być globalnie unikalna). - 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 wmain.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 wmain.tf
.
- W sekcji Autoryzowane źródła JavaScript kliknij Dodaj identyfikator URI i wpisz
- Kliknij Zapisz.
- 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ę
- 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>"
Pamiętaj, że uruchomienieterraform apply
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. - 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
- W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
- Kliknij Authentication (Uwierzytelnianie), a następnie wybierz kartę Sign-inMethod (Metoda logowania) (lub kliknij tutaj, aby przejść bezpośrednio do tej usługi).
- Google powinien być widoczny jako włączony dostawca logowania.
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.
- 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 ] }
- 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ć środowiskaus-east1
(Karolina Południowa) lub najbliższego regionu (zobacz lokalizacje Cloud Firestore). - 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 plikufirestore.rules
, które można znaleźć w katalogu głównym kataloguweb
. - 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.
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 ] } }
- Utwórz zestaw reguł zabezpieczeń Firebase na podstawie lokalnego pliku
- Uruchom
terraform apply
, aby udostępnić bazę danych Firestore i wdrożyć jej reguły zabezpieczeń. - Sprawdź, czy baza danych jest udostępniona i czy jej reguły zabezpieczeń zostały wdrożone:
- W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
- Przejdź do sekcji Baza danych Firestore i kliknij kartę Reguły.
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.
- 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ą zasobugoogle_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 }
- 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 plikustorage.rules
, które można znaleźć w katalogu głównym kataloguweb
. - 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.
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 ] } }
- Uruchom
terraform apply
, aby udostępnić domyślny zasobnik Cloud Storage i wdrożyć jego reguły zabezpieczeń. - Sprawdź, czy zasobnik został udostępniony i czy zostały wdrożone jego reguły zabezpieczeń:
- W konsoli Firebase w panelu po lewej stronie znajdź sekcję Kompilacja.
- Przejdź do sekcji Miejsce na dane i kliknij kartę Reguły.
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.
- 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>
- 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ń.
- Otwórz nowe okno terminala.
- Upewnij się, że jesteś w katalogu głównym
web
. - Uruchom
npm install
, aby pobrać pakiet SDK Firebase. - Uruchom
npm update
, aby zaktualizować zależności. - 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
- W konsoli Firebase otwórz Ustawienia projektu.
- Przewiń w dół do karty Twoje aplikacje, a potem wybierz aplikację internetową.
- W panelu fragmentu kodu pakietu SDK Firebase kliknij Konfiguracja, a potem skopiuj fragment kodu konfiguracji.
- 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ń.
- W pliku
main.tf
znajdź blok zasobówgoogle_firebase_web_app
(blok, który zarejestrował aplikację internetową w projekcie). - 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", "") } } ...
- Blok
data
ioutput
nie są przeznaczone do modyfikowania infrastruktury, więc wystarczy uruchomić podane niżej polecenia.- Aby wczytać konfigurację Firebase aplikacji internetowej do stanu Terraform w katalogu, uruchom to polecenie:
terraform refresh
- Aby wyświetlić wartości konfiguracji Firebase, uruchom to polecenie:
Poniżej znajdziesz przykładowe dane wyjściowe konfiguracji. Wydrukowane dane wyjściowe będą zawierać wartości projektu i aplikacji.terraform output –json
{ "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" } } }
- Aby wczytać konfigurację Firebase aplikacji internetowej do stanu Terraform w katalogu, uruchom to polecenie:
- Skopiuj wartości z mapy
value
. - 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ą.
- Odśwież przeglądarkę, w której działa aplikacja.
- 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.
- W katalogu głównym katalogu
web
utwórz nowy plik konfiguracyjny Terraform o nazwiemain_staging.tf
. - Skopiuj wszystkie bloki zasobów z pliku
main.tf
(oprócz blokówterraform
iprovider
), a następnie wklej je do plikumain_staging.tf
. - 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"
naresource "google_project" "staging"
. - Materiały referencyjne: zaktualizuj każdy z nich. Na przykład zmień
google_firebase_project.default.project
nagoogle_firebase_project.staging.project
.
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:- Skopiuj konfigurację z narzędzia
main_staging-copypaste.tf
, a następnie wklej ją do plikumain_staging.tf
. - W pliku
main_staging.tf
wykonaj te czynności:- W
google_project
bloku zasobów zaktualizuj atrybutyname
, atrybutproject-id
i (jeśli konfigurujesz uwierzytelnianie za pomocą Terraform) własne wartości dla atrybutubilling_account
. - W bloku zasobów
google_firebase_web_app
zaktualizuj atrybutdisplay_name
o własną wartość. - W blokach zasobów
google_firestore_database
igoogle_app_engine_application
zaktualizuj atrybutylocation_id
własną wartością.
- W
# 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" }
- Etykiety zasobów: aby uniknąć konfliktu, użyj nowej nazwy. Możesz na przykład zmienić nazwę
- Uruchom
terraform apply
, aby udostępnić nowy „etap przejściowy” projekt Firebase i wszystkie jego zasoby oraz włączyć usługi. - 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.
- Otwórz plik
main.tf
. - Do każdego bloku zasobów, który chcesz zreplikować, dodaj metaargument
for_each
w następujący sposób:
main.tf Pełną konfigurację pliku# 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.
main.tf
, który używa metaargumentufor_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:- Skopiuj konfigurację z narzędzia
main-foreach.tf
, a następnie wklej ją do plikumain.tf
. - W pliku
main.tf
wykonaj te czynności:- W
google_project
bloku zasobów zaktualizuj atrybutyname
, atrybutproject-id
i (jeśli konfigurujesz uwierzytelnianie za pomocą Terraform) własne wartości dla atrybutubilling_account
. - W bloku zasobów
google_firebase_web_app
zaktualizuj atrybutdisplay_name
o własną wartość. - W blokach zasobów
google_firestore_database
igoogle_app_engine_application
zaktualizuj atrybutylocation_id
własną wartością.
- W
- Skopiuj konfigurację z narzędzia
- 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ą.
- Jeśli zastosujesz teraz tę konfigurację, która korzysta z
for_each
, adresy zasobów będą wyglądać tak: Jednak istniejący projekt utworzony w pierwszej części tego ćwiczenia z programowania jest znany Terraform jako: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"]
google_project.default google_firebase_project.default google_firebase_android_app.default
- 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 adresemgoogle_project.default
został przeniesiony pod nowy adresgoogle_project.default["prod"]
. - Aby rozwiązać ten problem, uruchom polecenie
terraform state mv
:terraform state mv "google_project.default" "google_project.default[\"prod\"]"
- Podobnie, aby naprawić wszystkie inne bloki zasobów, uruchom polecenie
terraform state mv
dlagoogle_firebase_project
,google_firebase_web_app
i wszystkich pozostałych bloków zasobów w plikumain.tf
. - 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.
- Jeśli zastosujesz teraz tę konfigurację, która korzysta z
- Uruchom
terraform apply
, aby udostępnić nowy „etap przejściowy” projekt Firebase i wszystkie jego zasoby oraz włączyć usługi. - 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
- 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. - 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>
- 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. - 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). - 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>
- 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. - 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.