Często wymaga dodatkowej konfiguracji swoich funkcji, na przykład kluczy interfejsu API innych firm lub ustawień, które można dostosować. Pakiet SDK Firebase dla Cloud Functions ma wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych do projektu.
Masz do wyboru 3 opcje:
- Konfiguracja z parametrami (zalecana w większości scenariuszy). Zapewnia to konfigurację środowiska o silnym typie z parametrami weryfikowanymi podczas wdrażania, co zapobiega błędom i upraszcza debugowanie.
- Oparta na plikach konfiguracja zmiennych środowiskowych. W ten sposób ręcznie utworzysz plik dotenv do wczytywania zmiennych środowiskowych.
- Konfiguracja środowiska Firebase za pomocą interfejsu wiersza poleceń Firebase i usługi
functions.config
(tylko Cloud Functions (1 generacji).
W większości przypadków zalecamy korzystanie z konfiguracji z parametrami. W ten sposób dostępne są wartości konfiguracyjne zarówno w czasie działania, jak i wdrażania, a wdrażanie jest blokowane, dopóki wszystkie parametry nie mają prawidłowej wartości. I odwrotnie, konfiguracja ze zmiennymi środowiskowymi nie jest dostępna w czasie wdrażania.
Konfiguracja z parametrami
Cloud Functions dla Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracyjnych w bazie kodu. Wartości tych parametrów są dostępne zarówno podczas wdrażania funkcji, przy ustawianiu opcji wdrażania i czasu działania, jak i w trakcie wykonywania. Oznacza to, że interfejs wiersza poleceń zablokuje wdrożenie, chyba że wszystkie parametry będą miały prawidłową wartość.
Aby zdefiniować parametry w kodzie, skorzystaj z tego modelu:
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 zmiennymi konfiguracyjnymi z parametrami interfejs wiersza poleceń Firebase najpierw próbuje wczytać ich wartości z lokalnych plików .env. Jeśli nie ma ich w tych plikach i nie ustawiono interfejsu default
, interfejs wiersza poleceń poprosi o ich podanie 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 procesu programowania warto do kontroli wersji dodać wygenerowany plik .env.<project_ID>
.
Używanie parametrów w zakresie globalnym
Podczas wdrażania kod funkcji jest wczytywany i sprawdzany, zanim parametry pojawią się w rzeczywistych wartościach. Oznacza to, że pobieranie wartości parametrów w zakresie globalnym kończy się niepowodzeniem wdrożenia. W przypadkach, gdy do inicjowania wartości globalnej chcesz użyć parametru, użyj wywołania zwrotnego onInit()
. To wywołanie zwrotne jest wykonywane przed uruchomieniem funkcji w środowisku produkcyjnym, ale nie jest wywoływane podczas wdrażania, więc jest to bezpieczne miejsce dostępu do wartości parametru.
const { GoogleGenerativeAI } = require('@google/generative-ai');
const { defineSecret } = require('firebase-functions/params');
const { onInit } = require('firebase-functions/v1');
const apiKey = defineSecret('GOOGLE_API_KEY');
let genAI;
onInit(() => {
genAI = new GoogleGenerativeAI(apiKey.value());
})
Skonfiguruj działanie interfejsu wiersza poleceń
Parametry można skonfigurować za pomocą obiektu Options
, który określa, w jaki sposób interfejs wiersza poleceń będzie prosić o wartości. Poniższy przykład pokazuje opcje weryfikacji formatu numeru telefonu, proste opcje wyboru i automatyczne wypełnianie 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 z parametrami umożliwia silne wpisywanie wartości parametrów i obsługuje też obiekty tajne z usługi Cloud Secret Manager. Obsługiwane typy:
- Obiekt tajny
- Ciąg znaków
- Wartość logiczna
- Liczba całkowita
- Liczba zmiennoprzecinkowa
Wartości i wyrażenia parametrów
Firebase ocenia parametry zarówno w czasie wdrażania, jak i w trakcie wykonywania funkcji. Ze względu na te podwójne środowiska należy zachować szczególną ostrożność przy porównywaniu wartości parametrów i używaniu ich do ustawiania opcji środowiska wykonawczego dla swoich funkcji.
Aby przekazać parametr do funkcji jako opcję środowiska wykonawczego, 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) => {
//…
Poza tym w przypadku porównywania z parametrem, aby dowiedzieć się, którą opcję wybrać, musisz użyć wbudowanych porównywaczy, zamiast sprawdzać wartość:
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) => {
//…
Parametry i wyrażenia parametrów, które są używane tylko w czasie działania, są dostępne za pomocą 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.`);
}
);
Parametry wbudowane
Pakiet SDK Cloud Functions udostępnia 3 wstępnie zdefiniowane parametry dostępne w podpakiecie 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łączony w projekcie Firebase).
Funkcjonują one pod każdym względem jak parametry ciągu zdefiniowane przez użytkownika, z tym wyjątkiem, że ich wartości są zawsze znane w interfejsie wiersza poleceń Firebase, więc nie będą wyświetlane pytanie o ich wdrożenie ani nie będą zapisywane w plikach .env
.
Parametry obiektu tajnego
Parametry typu Secret
, zdefiniowane za pomocą defineSecret()
, reprezentują parametry ciągu znaków, które mają wartość przechowywaną w usłudze Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env
i w razie jego braku zapisywać w nim nową wartość, sprawdzając, czy istnieje on w usłudze Cloud Secret Manager, i interaktywnie pytać o wartość nowego obiektu tajnego podczas wdrażania.
Zdefiniowane w ten sposób parametry obiektów tajnych 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();
//…
Wartości obiektów tajnych są ukryte do czasu wykonania funkcji, więc nie można ich używać podczas konfigurowania funkcji.
Zmienne środowiskowe
Cloud Functions dla Firebase obsługuje format pliku dotenv służący do wczytywania zmiennych środowiskowych określonych w pliku .env
w środowisku wykonawczym aplikacji. Po wdrożeniu zmienne środowiskowe można odczytywać za pomocą interfejsu process.env
.
Aby skonfigurować środowisko w ten sposób, utwórz w projekcie plik .env
, dodaj odpowiednie zmienne i wdróż:
Utwórz plik
.env
w katalogufunctions/
:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.js
Otwórz plik
.env
do edycji i dodaj odpowiednie klawisze. Przykład:PLANET=Earth AUDIENCE=Humans
Wdróż funkcje i sprawdź, czy zmienne środowiskowe zostały wczytane:
firebase deploy --only functions # ... # i functions: Loaded environment variables from .env. # ...
Po wdrożeniu niestandardowych zmiennych środowiskowych kod funkcji może uzyskać 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 projektów Firebase (np. wersji przejściowej i produkcyjnej), utwórz plik .env.<project or
alias>
i wpisz w nim zmienne środowiskowe właściwe dla Twojego projektu. Zmienne środowiskowe z .env
i plików .env
właściwych dla projektu (jeśli istnieją) zostaną uwzględnione we wszystkich wdrożonych funkcjach.
Na przykład projekt może zawierać 3 pliki, które zawierają nieco inne wartości na potrzeby programowania i produkcji:
.env
|
.env.dev
|
.env.prod
|
PLANET=Ziemia
AUDIENCE=Ludzie |
AUDIENCE=Programiści | AUDIENCE=Produkowani ludzie |
Biorąc pod uwagę wartości w tych osobnych plikach, zestaw zmiennych środowiskowych wdrożonych dla funkcji 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 w plikach .env
żadnego z tych kluczy:
- Wszystkie klucze zaczynające się od X_GOOGLE_
- Wszystkie klucze zaczynają się od EXT_
- Wszystkie klucze zaczynają się od FIREBASE_
- Dowolny klucz z tej listy:
- CLOUD_RUNTIME_CONFIG
- PUNKT_WEJŚCIA
- GCP_PROJECT
- GCLOUD_PROJECT
- GOOGLE_CLOUD_PROJECT
- TYP FUNKCJI
- Funkcja FUNCTION_NAME
- FUNCTION_MEMORY_MB
- FUNCTION_TIMEOUT_SEC
- IDENTITY_FUNKCJI
- FUNCTION_REGION
- FUNCTION_TARGET
- TYP FUNCTION_SIGNATURE_TYPE
- K_SERVICE
- K_REVISION
- PORT
- K_KONFIGURACJA
Przechowywanie poufnych informacji konfiguracji i uzyskiwanie do nich dostępu
Zmienne środowiskowe przechowywane w plikach .env
mogą być używane do konfigurowania funkcji, ale nie należy traktować ich jako bezpiecznego sposobu przechowywania informacji poufnych, takich jak dane logowania do bazy danych lub klucze interfejsu API. Jest to szczególnie ważne, jeśli sprawdzasz pliki .env
pod kątem kontroli źródła.
Aby ułatwić przechowywanie poufnych informacji o konfiguracji, usługa Cloud Functions dla Firebase integruje się z usługą Google Cloud Secret Manager. Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracji, zapewniając w razie potrzeby łatwy dostęp do funkcji.
Tworzenie i używanie obiektu tajnego
Aby utworzyć obiekt tajny, użyj interfejsu wiersza poleceń Firebase.
Aby utworzyć obiekt tajny i użyć go:
W katalogu głównym projektu lokalnego uruchom to polecenie:
firebase functions:secrets:set SECRET_NAME
Wpisz wartość w polu SECRET_NAME.
Interfejs wiersza poleceń powtarza komunikat o powodzeniu i ostrzega, że musisz wdrożyć funkcje, aby zmiana zaczęła obowiązywać.
Przed wdrożeniem upewnij się, że kod funkcji zezwala funkcji na dostęp do obiektu 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 });
Wdrażanie funkcji w Cloud Functions:
firebase deploy --only functions
Teraz będziesz mieć do niego dostęp tak samo jak do każdej innej zmiennej środowiskowej.
Jeśli inna funkcja, która nie określa obiektu tajnego w runWith
, próbuje uzyskać dostęp do obiektu tajnego, otrzyma 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 uzyska dostęp do wartości obiektu tajnego. Tylko funkcje, które zawierają obiekt tajny w parametrze runWith
, będą miały do niego dostęp jako zmienną środowiskową. Dzięki temu będziesz mieć pewność, że wartości obiektów tajnych będą dostępne tylko tam, gdzie są potrzebne. Zmniejsza to ryzyko przypadkowego wycieku obiektu tajnego.
Zarządzanie obiektami tajnymi
Aby zarządzać obiektami tajnymi, użyj interfejsu wiersza poleceń Firebase. Pamiętaj, że podczas zarządzania obiektami tajnymi w ten sposób pamiętaj, że niektóre zmiany w interfejsie wiersza poleceń wymagają zmodyfikowania lub ponownego wdrożenia powiązanych funkcji. W szczególności:
- Gdy ustawisz nową wartość obiektu tajnego, musisz ponownie wdrożyć wszystkie funkcje, które się do niego odwołują, aby mogły pobrać najnowszą wartość.
- Jeśli usuniesz obiekt tajny, dopilnuj, aby żadna z wdrożonych funkcji nie się do niego odwoływała. Funkcje korzystające z usuniętej wartości obiektu tajnego będą dyskretnie kończyć się niepowodzeniem.
Oto podsumowanie poleceń interfejsu wiersza poleceń Firebase związanych z zarządzaniem obiektami 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żesz podać opcjonalny parametr version, który służy do zarządzania konkretną wersją. Przykład:
functions:secrets:access SECRET_NAME[@VERSION]
Aby uzyskać więcej informacji o tych operacjach, przekaż -h
za pomocą polecenia wyświetlającego pomoc interfejsu wiersza poleceń.
Jak naliczane są opłaty za obiekty tajne
Usługa Secret Manager zezwala na 6 aktywnych wersji obiektów tajnych bez opłat. Oznacza to, że możesz mieć bezpłatnie 6 obiektów tajnych miesięcznie w projekcie Firebase.
Domyślnie interfejs wiersza poleceń Firebase próbuje automatycznie niszczyć nieużywane wersje obiektu tajnego, gdy jest to konieczne, na przykład podczas wdrażania funkcji przy użyciu nowej wersji obiektu tajnego. Możesz też aktywnie usuwać nieużywane obiekty tajne za pomocą functions:secrets:destroy
i functions:secrets:prune
.
Usługa Secret Manager zezwala na 10 000 nierozliczonych miesięcznych operacji dostępu na obiekcie tajnym. Przy każdym uruchomieniu „na zimno” instancje funkcji odczytują tylko obiekty tajne określone w parametrze runWith
. Jeśli wiele instancji funkcji odczytuje wiele obiektów tajnych, projekt może przekroczyć ten limit.Wtedy zapłacisz 0,03 USD za 10 000 operacji dostępu.
Więcej informacji znajdziesz w cenniku usługi Secret Manager.
Obsługa emulatorów
Konfiguracja środowiska z dotenv została zaprojektowana tak, aby współdziałała z lokalnym emulatorem Cloud Functions.
Jeśli korzystasz z lokalnego emulatora Cloud Functions, możesz zastąpić zmienne środowiskowe w swoim projekcie, konfigurując plik .env.local
. Zawartość komponentu .env.local
ma pierwszeństwo przed plikiem .env
i plikiem .env
powiązanym z projektem.
Na przykład projekt może zawierać 3 pliki, które zawierają nieco inne wartości na potrzeby testów deweloperskich i lokalnych:
.env
|
.env.dev
|
.env.local
|
PLANET=Ziemia
AUDIENCE=Ludzie |
AUDIENCE=Programiści | AUDIENCE=Lokalni ludzie |
Po uruchomieniu w kontekście lokalnym emulator wczytuje zmienne środowiskowe w następujący sposób:
$ firebase emulators:start
i emulators: Starting emulators: functions
# Starts emulator with following environment variables:
# PLANET=Earth
# AUDIENCE=Local Humans
Obiekty tajne i dane logowania w emulatorze Cloud Functions
Emulator Cloud Functions umożliwia korzystanie z obiektów tajnych do przechowywania poufnych informacji o konfiguracji i uzyskiwania do nich dostępu. Domyślnie emulator próbuje uzyskać dostęp do obiektów tajnych w środowisku produkcyjnym za pomocą domyślnych danych logowania aplikacji. W niektórych sytuacjach, takich jak środowiska CI, emulator może nie uzyskać dostępu do wartości obiektów tajnych z powodu ograniczeń uprawnień.
Podobnie jak w przypadku emulatora Cloud Functions obsługującego zmienne środowiskowe, możesz zastępować wartości obiektów tajnych, konfigurując plik .secret.local
. Ułatwia to testowanie funkcji lokalnie, zwłaszcza jeśli nie masz dostępu do wartości obiektu tajnego.
Migracja z konfiguracji środowiska
Jeśli używasz konfiguracji środowiska z functions.config
, możesz przenieść istniejącą konfigurację jako zmienne środowiskowe (w formacie dotenv).
Interfejs wiersza poleceń Firebase udostępnia polecenie eksportu, które zwraca konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc
katalogu (w przykładzie poniżej: local
, dev
i prod
) jako pliki .env
.
Aby przeprowadzić migrację, wyeksportuj istniejące konfiguracje środowiska za pomocą polecenia 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 może pojawić się prośba o wpisanie prefiksu, aby zmienić nazwy wyeksportowanych kluczy zmiennych środowiskowych. Dzieje się tak, ponieważ nie wszystkie konfiguracje mogą być przekształcane automatycznie, ponieważ mogą być nieprawidłowe lub mogą być zastrzeżonym kluczem zmiennej środowiskowej.
Zalecamy uważne sprawdzenie 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ą poufne i nie powinny zostać ujawnione, usuń je z plików .env
i zapisz w bezpiecznym miejscu w usłudze Secret Manager.
Musisz też zaktualizować kod funkcji. Wszystkie funkcje, które korzystają z metody functions.config
, będą teraz musiały używać parametru process.env
, jak pokazano w sekcji Przechodzenie na 2 generację.
Konfiguracja środowiska
Przed wprowadzeniem obsługi zmiennych środowiskowych w usłudze 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 we wszystkich nowych projektach używać zmiennych środowiskowych, ponieważ są one łatwiejsze w użyciu i zwiększają możliwości przenoszenia kodu.
Ustaw konfigurację środowiska za pomocą interfejsu wiersza poleceń
Aby przechowywać dane środowiska, możesz użyć polecenia firebase functions:config:set
w interfejsie wiersza poleceń Firebase.
Każdy klucz można określić za pomocą kropek, aby pogrupować powiązane konfiguracje. Pamiętaj, że w kluczach akceptowane są tylko małe litery. Wielkie litery są niedozwolone.
Aby na przykład zapisać identyfikator klienta i klucz interfejsu API dla usługi „Some Service”, możesz uruchomić polecenie:
firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"
Pobierz bieżącą konfigurację środowiska
Aby sprawdzić, co jest obecnie przechowywane w konfiguracji środowiska Twojego projektu, możesz użyć firebase functions:config:get
. Zapisze kod JSON podobny do tego:
{
"someservice": {
"key":"THE API KEY",
"id":"THE CLIENT ID"
}
}
Ta funkcja działa w oparciu o interfejs Google Cloud Runtime Configuration API.
Użyj polecenia functions.config
, aby uzyskać dostęp do konfiguracji środowiska w funkcji
Niektóre konfiguracje są udostępniane automatycznie w zarezerwowanej przestrzeni nazw firebase
. Konfiguracja środowiska jest dostępna w ramach uruchomionej funkcji przez functions.config()
.
W przypadku powyższej konfiguracji 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}
});
});
Zainicjuj moduł w konfiguracji środowiska
Niektóre moduły węzłów są gotowe bez konieczności konfiguracji. Inne moduły wymagają dodatkowej konfiguracji, aby się prawidłowo zainicjowały. Zalecamy przechowywanie tej konfiguracji w zmiennych środowiskowych zamiast kodowania jej na stałe. Dzięki temu kod jest znacznie bardziej przenośny, co pozwala udostępniać aplikację na licencji open source lub łatwo przełączać się między wersją produkcyjną a testową.
Aby na przykład skorzystać z modułu Slack Node SDK, możesz napisać ten tekst:
const functions = require('firebase-functions');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);
Przed wdrożeniem ustaw zmienną konfiguracji środowiskowej slack.url
:
firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX
Dodatkowe polecenia dotyczące środowiska
firebase functions:config:unset key1 key2
usuwa określone klucze z konfiguracjifirebase functions:config:clone --from <fromProject>
klonuje środowisko innego projektu do obecnie aktywnego projektu.
Automatycznie wypełnione zmienne środowiskowe
Istnieją zmienne środowiskowe, które są automatycznie wypełniane w środowisku wykonawczym funkcji i w funkcjach emulowanych lokalnie. Obejmują one parametry wypełniane przez Google Cloud, a także zmienną środowiskową Firebase:
process.env.FIREBASE_CONFIG
: dostarcza 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 zainicjujesz pakiet Firebase Admin SDK bez argumentów. Jeśli stosujesz funkcje w języku JavaScript, inicjuj je w ten sposób:
const admin = require('firebase-admin');
admin.initializeApp();
Jeśli wpisujesz funkcje w języku TypeScript, inicjuj je w ten sposób:
import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();
Jeśli musisz zainicjować pakiet Admin SDK przy użyciu domyślnej konfiguracji projektu przy użyciu danych logowania do konta usługi, możesz wczytać 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);