Często będziesz potrzebować dodatkowej konfiguracji swoich funkcji, takiej jak klucze API innych firm lub konfigurowalne ustawienia. Pakiet Firebase SDK for Cloud Functions oferuje wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych dla Twojego projektu.
Możesz wybrać jedną z trzech opcji:
- Konfiguracja sparametryzowana (zalecana w przypadku większości scenariuszy). Zapewnia to silnie wpisaną konfigurację środowiska z parametrami, które są sprawdzane podczas wdrażania, co zapobiega błędom i upraszcza debugowanie.
- Oparta na plikach konfiguracja zmiennych środowiskowych . Dzięki temu podejściu ręcznie tworzysz plik dotenv do ładowania zmiennych środowiskowych.
- Konfiguracja środowiska wykonawczego za pomocą interfejsu wiersza polecenia Firebase i
functions.config(tylko Cloud Functions (1. generacji)).
W większości przypadków użycia zalecana jest konfiguracja sparametryzowana. Takie podejście sprawia, że wartości konfiguracyjne są dostępne zarówno w czasie wykonywania, jak iw czasie wdrażania, a wdrażanie jest blokowane, chyba że wszystkie parametry mają prawidłową wartość. I odwrotnie, konfiguracja ze zmiennymi środowiskowymi nie jest dostępna w czasie wdrażania.
Konfiguracja sparametryzowana
Cloud Functions dla Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracyjnych w bazie kodu. Wartość tych parametrów jest dostępna zarówno podczas wdrażania funkcji, podczas ustawiania opcji wdrażania i środowiska wykonawczego, jak i podczas wykonywania. Oznacza to, że interfejs CLI zablokuje wdrożenie, chyba że wszystkie parametry mają prawidłową wartość.
Aby zdefiniować parametry w swoim kodzie, postępuj zgodnie z tym modelem:
const functions = require('firebase-functions');
const { defineInt, defineString } = require('firebase-functions/params');
// Define some parameters
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
const welcomeMessage = defineString('WELCOME_MESSAGE');
// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Podczas wdrażania funkcji ze sparametryzowanymi zmiennymi konfiguracyjnymi interfejs CLI Firebase najpierw próbuje załadować ich wartości z lokalnych plików .env. Jeśli nie ma ich w tych plikach i nie jest ustawiona default , interfejs CLI wyświetli monit o podanie wartości podczas wdrażania, a następnie automatycznie zapisze ich wartości w pliku .env o nazwie .env.<project_ID> w katalogu functions/ /:
$ firebase deploy
i functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i functions: Loaded environment variables from .env.projectId
W zależności od przepływu pracy programistycznej przydatne może być dodanie wygenerowanego pliku .env.<project_ID> do kontroli wersji.
Skonfiguruj zachowanie CLI
Parametry można skonfigurować za pomocą obiektu Options , który kontroluje sposób, w jaki interfejs CLI będzie monitował o wartości. Poniższy przykład ustawia opcje sprawdzania poprawności formatu numeru telefonu, udostępniania opcji prostego wyboru i automatycznego wypełniania opcji wyboru z projektu Firebase:
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});
const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});
const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})
const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})
Typy parametrów
Konfiguracja sparametryzowana zapewnia silne wpisywanie wartości parametrów, a także obsługuje klucze tajne z usługi Cloud Secret Manager. Obsługiwane typy to:
- Sekret
- Strunowy
- logiczne
- Liczba całkowita
- Platforma
Wartości parametrów i wyrażenia
Firebase ocenia parametry zarówno w czasie wdrażania, jak i podczas wykonywania funkcji. Ze względu na te podwójne środowiska należy zachować szczególną ostrożność podczas porównywania wartości parametrów i używania ich do ustawiania opcji środowiska wykonawczego dla funkcji.
Aby przekazać parametr do swojej funkcji jako opcję środowiska uruchomieniowego, przekaż go bezpośrednio:
const functions = require('firebase-functions');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
//…
Dodatkowo, jeśli musisz porównać z parametrem, aby wiedzieć, którą opcję wybrać, będziesz musiał użyć wbudowanych komparatorów zamiast sprawdzania wartości:
const functions = require('firebase-functions');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});
// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
//…
Dostęp do parametrów i wyrażeń parametrów, które są używane tylko w czasie wykonywania, można uzyskać za pomocą ich funkcji value :
const functions = require('firebase-functions');
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE');
// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.https.onRequest(
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Wbudowane parametry
Pakiet Cloud Functions SDK oferuje trzy wstępnie zdefiniowane parametry, dostępne z podpakietu firebase-functions/params :
-
projectId— projekt Cloud, w którym działa funkcja. -
databaseUrl— adres URL instancji bazy danych czasu rzeczywistego powiązanej z funkcją (jeśli jest włączona w projekcie Firebase). -
storageBucket— zasobnik Cloud Storage powiązany z funkcją (jeśli jest włączona w projekcie Firebase).
Działają one pod każdym względem jak parametry łańcuchowe zdefiniowane przez użytkownika, z tą różnicą, że ponieważ ich wartości są zawsze znane interfejsowi Firebase CLI, ich wartości nigdy nie będą wyświetlane podczas wdrażania ani zapisywane w plikach .env .
Tajne parametry
Parametry typu Secret , zdefiniowane za pomocą defineSecret() , reprezentują parametry łańcuchowe, które mają wartość przechowywaną w Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać nową wartość w pliku, jeśli go brakuje, tajne parametry sprawdzają, czy istnieją w Cloud Secret Manager i interaktywnie pytają o wartość nowego tajnego klucza podczas wdrażania.
Sekretne parametry zdefiniowane w ten sposób muszą być powiązane z poszczególnymi funkcjami, które powinny mieć do nich dostęp:
const functions = require('firebase-functions');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');
export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
(req, res) => {
const apiKey = discordApiKey.value();
//…
Ponieważ wartości sekretów są ukryte do czasu wykonania funkcji, nie możesz ich używać podczas konfigurowania swojej funkcji.
Zmienne środowiska
Cloud Functions for Firebase obsługuje format pliku dotenv do ładowania zmiennych środowiskowych określonych w pliku .env do środowiska wykonawczego aplikacji. Po wdrożeniu zmienne środowiskowe można odczytać za pośrednictwem interfejsu process.env .
Aby skonfigurować środowisko w ten sposób, utwórz plik .env w swoim projekcie, dodaj żądane zmienne i wdróż:
Utwórz plik
.envw swoim katalogufunctions/:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.jsOtwórz plik
.envdo edycji i dodaj żądane klucze. Na przykład:PLANET=Earth AUDIENCE=HumansWdróż funkcje i sprawdź, czy zmienne środowiskowe zostały załadowane:
firebase deploy --only functions # ... # i functions: Loaded environment variables from .env. # ...
Po wdrożeniu niestandardowych zmiennych środowiskowych kod funkcji może uzyskiwać do nich dostęp za pomocą składni process.env :
// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});
Wdrażanie wielu zestawów zmiennych środowiskowych
Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla swoich projektów Firebase (takich jak pomostowa a produkcyjna), utwórz plik .env. <project or alias > i zapisz tam zmienne środowiskowe specyficzne dla projektu. Zmienne środowiskowe z .env i plików .env specyficznych dla projektu (jeśli istnieją) zostaną uwzględnione we wszystkich wdrożonych funkcjach.
Na przykład projekt może zawierać te trzy pliki zawierające nieco inne wartości dla rozwoju i produkcji:
.env | .env.dev | .env.prod |
| PLANETA=Ziemia PUBLICZNOŚĆ=Ludzie | PUBLICZNOŚĆ=Dev Ludzie | PUBLICZNOŚĆ = Produkuj ludzi |
Biorąc pod uwagę wartości w tych oddzielnych plikach, zestaw zmiennych środowiskowych wdrożonych z twoimi funkcjami będzie się różnić w zależności od projektu docelowego:
$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
# PLANET=Earth
# AUDIENCE=Dev Humans
$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
# PLANET=Earth
# AUDIENCE=Prod Humans
Zarezerwowane zmienne środowiskowe
Niektóre klucze zmiennych środowiskowych są zarezerwowane do użytku wewnętrznego. Nie używaj żadnego z tych kluczy w plikach .env :
- Wszystkie klucze zaczynające się od X_GOOGLE_
- Wszystkie klucze zaczynające się od EXT_
- Wszystkie klucze zaczynające się od FIREBASE_
- Dowolny klucz z poniższej listy:
- CLOUD_RUNTIME_CONFIG
- PUNKT WEJŚCIA
- GCP_PROJEKT
- GCLOUD_PROJECT
- GOOGLE_CLOUD_PROJECT
- FUNCTION_TRIGGER_TYPE
- NAZWA_FUNKCJI
- FUNCTION_MEMORY_MB
- FUNCTION_TIMEOUT_SEC
- FUNCTION_IDENTITY
- FUNCTION_REGION
- FUNCTION_TARGET
- FUNCTION_SIGNATURE_TYPE
- K_SERWIS
- K_REVISION
- PORT
- K_KONFIGURACJA
Przechowuj i uzyskuj dostęp do poufnych informacji konfiguracyjnych
Zmiennych środowiskowych przechowywanych w plikach .env można używać do konfigurowania funkcji, ale nie należy ich traktować jako bezpiecznego sposobu przechowywania poufnych informacji, takich jak poświadczenia bazy danych lub klucze API. Jest to szczególnie ważne, jeśli sprawdzasz pliki .env w kontroli źródła.
Aby pomóc Ci przechowywać poufne informacje konfiguracyjne, Cloud Functions for Firebase integruje się z Google Cloud Secret Manager . Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracyjne, jednocześnie umożliwiając łatwy dostęp z funkcji użytkownika w razie potrzeby.
Utwórz i użyj sekretu
Aby utworzyć klucz tajny, użyj interfejsu wiersza polecenia Firebase.
Aby utworzyć i użyć wpisu tajnego:
W katalogu głównym lokalnego katalogu projektu uruchom następującą komendę:
firebase functions:secrets:set SECRET_NAME
Wprowadź wartość SECRET_NAME .
Interfejs wiersza polecenia wyświetla komunikat o powodzeniu i ostrzega, że należy wdrożyć funkcje, aby zmiana zaczęła obowiązywać.
Przed wdrożeniem upewnij się, że kod funkcji umożliwia dostęp funkcji do klucza tajnego za pomocą parametru
runWith:exports.processPayment = functions // Make the secret available to this function .runWith({ secrets: ["SECRET_NAME"] }) .onCall((data, context) => { const myBillingService = initializeBillingService( // reference the secret value process.env.SECRET_NAME ); // Process the payment });Wdróż funkcje chmury:
firebase deploy --only functions
Teraz będziesz mieć do niej dostęp jak do każdej innej zmiennej środowiskowej. I odwrotnie, jeśli inna funkcja, która nie określa klucza tajnego w runWith , próbuje uzyskać dostęp do klucza tajnego, otrzymuje niezdefiniowaną wartość:
exports.anotherEndpoint = functions.https.onRequest((request, response) => {
response.send(`The secret API key is ${process.env.SECRET_NAME}`);
// responds with "The secret API key is undefined" because the `runWith` parameter is missing
});
Po wdrożeniu funkcja będzie miała dostęp do tajnej wartości. Tylko funkcje, które konkretnie zawierają klucz tajny w swoim parametrze runWith , będą miały dostęp do tego klucza tajnego jako zmiennej środowiskowej. Pomaga to upewnić się, że tajne wartości są dostępne tylko tam, gdzie są potrzebne, zmniejszając ryzyko przypadkowego wycieku tajnego.
Zarządzanie tajemnicami
Użyj Firebase CLI do zarządzania swoimi sekretami. Podczas zarządzania kluczami tajnymi w ten sposób należy pamiętać, że niektóre zmiany interfejsu CLI wymagają modyfikacji i/lub ponownego wdrożenia powiązanych funkcji. Konkretnie:
- Za każdym razem, gdy ustawisz nową wartość dla klucza tajnego, musisz ponownie wdrożyć wszystkie funkcje, które odwołują się do tego klucza tajnego, aby pobrały najnowszą wartość.
- Jeśli usuniesz klucz tajny, upewnij się, że żadna z wdrożonych funkcji nie odwołuje się do tego klucza tajnego. Funkcje używające tajnej wartości, która została usunięta, zakończą się niepowodzeniem w trybie cichym.
Oto podsumowanie poleceń Firebase CLI do zarządzania kluczami tajnymi:
# Change the value of an existing secret firebase functions:secrets:set SECRET_NAME # View the value of a secret functions:secrets:access SECRET_NAME # Destroy a secret functions:secrets:destroy SECRET_NAME # View all secret versions and their state functions:secrets:get SECRET_NAME # Automatically clean up all secrets that aren't referenced by any of your functions functions:secrets:prune
W przypadku poleceń access i destroy można podać opcjonalny parametr wersji, aby zarządzać określoną wersją. Na przykład:
functions:secrets:access SECRET_NAME[@VERSION]
Aby uzyskać więcej informacji o tych operacjach, przekaż -h z poleceniem, aby wyświetlić pomoc interfejsu CLI.
Sposób rozliczania tajemnic
Secret Manager pozwala na 6 aktywnych tajnych wersji bez żadnych kosztów. Oznacza to, że możesz mieć 6 sekretów miesięcznie w projekcie Firebase bez żadnych kosztów.
Domyślnie Firebase CLI próbuje automatycznie zniszczyć nieużywane tajne wersje tam, gdzie to konieczne, na przykład podczas wdrażania funkcji z nową wersją tajnego klucza. Możesz także aktywnie czyścić nieużywane wpisy tajne za pomocą functions:secrets:destroy i functions:secrets:prune .
Secret Manager umożliwia 10 000 nierozliczonych miesięcznych operacji dostępu do klucza tajnego. Instancje funkcji odczytują tylko klucze tajne określone w ich parametrze runWith przy każdym zimnym starcie. Jeśli masz wiele wystąpień funkcji odczytujących wiele wpisów tajnych, Twój projekt może przekroczyć ten limit, w którym to momencie zostanie naliczona opłata w wysokości 0,03 USD za 10 000 operacji dostępu.
Aby uzyskać więcej informacji, zobacz Cennik Secret Manager .
Obsługa emulatorów
Konfiguracja środowiska za pomocą dotenv jest przeznaczona do współpracy z lokalnym emulatorem Cloud Functions .
Korzystając z lokalnego emulatora Cloud Functions, możesz zastąpić zmienne środowiskowe dla swojego projektu, konfigurując plik .env.local . Zawartość .env.local ma pierwszeństwo przed .env i specyficznym dla projektu plikiem .env .
Na przykład projekt może zawierać te trzy pliki zawierające nieco inne wartości dla programowania i testowania lokalnego:
.env | .env.dev | .env.local |
| PLANETA=Ziemia PUBLICZNOŚĆ=Ludzie | PUBLICZNOŚĆ=Dev Ludzie | PUBLICZNOŚĆ=Lokalni ludzie |
Po uruchomieniu w kontekście lokalnym emulator ładuje zmienne środowiskowe, jak pokazano:
$ firebase emulators:start
i emulators: Starting emulators: functions
# Starts emulator with following environment variables:
# PLANET=Earth
# AUDIENCE=Local Humans
Wpisy tajne i poświadczenia w emulatorze Cloud Functions
Emulator Cloud Functions obsługuje używanie wpisów tajnych do przechowywania i uzyskiwania dostępu do poufnych informacji konfiguracyjnych . Domyślnie emulator będzie próbował uzyskać dostęp do sekretów produkcyjnych przy użyciu domyślnych poświadczeń aplikacji . W niektórych sytuacjach, takich jak środowiska CI, emulator może nie uzyskać dostępu do tajnych wartości z powodu ograniczeń uprawnień.
Podobnie jak w przypadku obsługi emulatora Cloud Functions dla zmiennych środowiskowych, możesz zastąpić tajne wartości, konfigurując plik .secret.local . Ułatwia to lokalne testowanie funkcji, zwłaszcza jeśli nie masz dostępu do tajnej wartości.
Migracja z konfiguracji środowiska
Jeśli korzystasz z konfiguracji środowiska z functions.config , możesz migrować istniejącą konfigurację jako zmienne środowiskowe (w formacie dotenv ). Firebase CLI udostępnia polecenie eksportu, które wyświetla konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc Twojego katalogu (w poniższym przykładzie local , dev i prod ) jako pliki .env .
Aby przeprowadzić migrację, wyeksportuj istniejące konfiguracje środowiska za pomocą komendy firebase functions:config:export :
firebase functions:config:export
i Importing configs from projects: [project-0, project-1]
⚠ The following configs keys could not be exported as environment variables:
⚠ project-0 (dev):
1foo.a => 1FOO\_A (Key 1FOO\_A must start with an uppercase ASCII letter or underscore, and then consist of uppercase ASCII letters, digits, and underscores.)
Enter a PREFIX to rename invalid environment variable keys: CONFIG\_
✔ Wrote functions/.env.prod
✔ Wrote functions/.env.dev
✔ Wrote functions/.env.local
✔ Wrote functions/.env
Pamiętaj, że w niektórych przypadkach zostaniesz poproszony o wprowadzenie prefiksu, aby zmienić nazwę eksportowanych kluczy zmiennych środowiskowych. Dzieje się tak dlatego, że nie wszystkie konfiguracje mogą być automatycznie przekształcane, ponieważ mogą być nieprawidłowe lub mogą być zarezerwowanym kluczem zmiennej środowiskowej .
Zalecamy uważne przejrzenie zawartości wygenerowanych plików .env przed wdrożeniem funkcji lub sprawdzeniem plików .env w kontroli źródła. Jeśli jakieś wartości są wrażliwe i nie powinny zostać ujawnione, usuń je z plików .env i zamiast tego przechowuj je bezpiecznie w Secret Manager .
Musisz także zaktualizować kod funkcji. Wszystkie funkcje korzystające functions.config będą teraz musiały zamiast tego używać process.env , jak pokazano w temacie Uaktualnienie do 2. generacji .
Konfiguracja środowiska
Zanim obsługa zmiennych środowiskowych została wydana w firebase-functions v3.18.0 , zalecanym podejściem do konfiguracji środowiska było użycie functions.config() . To podejście jest nadal obsługiwane, ale zalecamy, aby wszystkie nowe projekty używały zmiennych środowiskowych, ponieważ są one prostsze w użyciu i poprawiają przenośność kodu.
Ustaw konfigurację środowiska za pomocą interfejsu CLI
Aby przechowywać dane środowiska, możesz użyć komendy firebase functions:config:set w Firebase CLI . Każdy klucz może być podzielony na przestrzenie nazw za pomocą kropek w celu zgrupowania powiązanych konfiguracji razem. Należy pamiętać, że w kluczach akceptowane są tylko małe litery ; wielkie litery są niedozwolone.
Na przykład, aby zapisać identyfikator klienta i klucz API dla „Niektórych usług”, możesz uruchomić:
firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"
Pobierz bieżącą konfigurację środowiska
Aby sprawdzić, co jest aktualnie przechowywane w konfiguracji środowiska dla twojego projektu, możesz użyć firebase functions:config:get . Wygeneruje JSON coś takiego:
{
"someservice": {
"key":"THE API KEY",
"id":"THE CLIENT ID"
}
}
Ta funkcja jest oparta na interfejsie Google Cloud Runtime Configuration API .
Użyj functions.config aby uzyskać dostęp do konfiguracji środowiska w funkcji
Niektóre konfiguracje są automatycznie udostępniane w zarezerwowanej przestrzeni nazw firebase . Konfiguracja środowiska jest udostępniana wewnątrz uruchomionej funkcji za pośrednictwem functions.config() . Aby użyć powyższej konfiguracji, Twój kod może wyglądać tak:
const functions = require('firebase-functions');
const request = require('request-promise');
exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
let email = event.data.child('email').val();
return request({
url: 'https://someservice.com/api/some/call',
headers: {
'X-Client-ID': functions.config().someservice.id,
'Authorization': `Bearer ${functions.config().someservice.key}`
},
body: {email: email}
});
});
Użyj konfiguracji środowiska, aby zainicjować moduł
Niektóre moduły Node są gotowe bez żadnej konfiguracji. Inne moduły wymagają dodatkowej konfiguracji, aby poprawnie zainicjować. Zalecamy przechowywanie tej konfiguracji w zmiennych konfiguracji środowiska, zamiast jej kodowania na stałe. Dzięki temu Twój kod jest znacznie bardziej przenośny, co pozwala otworzyć źródło aplikacji lub łatwo przełączać się między wersjami produkcyjnymi i przejściowymi.
Na przykład, aby użyć modułu Slack Node SDK , możesz napisać to:
const functions = require('firebase-functions');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);
Przed wdrożeniem ustaw zmienną konfiguracyjną środowiska slack.url :
firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX
Dodatkowe polecenia środowiska
-
firebase functions:config:unset key1 key2usuwa określone klucze z konfiguracji -
firebase functions:config:clone --from <fromProject>klonuje środowisko innego projektu do aktualnie aktywnego projektu.
Automatycznie wypełniane zmienne środowiskowe
Istnieją zmienne środowiskowe, które są wypełniane automatycznie w czasie wykonywania funkcji iw funkcjach emulowanych lokalnie. Należą do nich te wypełnione przez Google Cloud , a także zmienna środowiskowa specyficzna dla Firebase:
process.env.FIREBASE_CONFIG : zawiera następujące informacje o konfiguracji projektu Firebase:
{
databaseURL: 'https://databaseName.firebaseio.com',
storageBucket: 'projectId.appspot.com',
projectId: 'projectId'
}
Ta konfiguracja jest stosowana automatycznie, gdy inicjujesz pakiet Firebase Admin SDK bez argumentów. Jeśli piszesz funkcje w JavaScript, zainicjuj w ten sposób:
const admin = require('firebase-admin');
admin.initializeApp();
Jeśli piszesz funkcje w TypeScript, zainicjuj w ten sposób:
import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();
Jeśli chcesz zainicjować pakiet Admin SDK z domyślną konfiguracją projektu przy użyciu danych logowania do konta usługi, możesz załadować dane logowania z pliku i dodać je do FIREBASE_CONFIG w ten sposób:
serviceAccount = require('./serviceAccount.json');
const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);