Często będziesz potrzebować dodatkowej konfiguracji funkcji, np. kluczy API innych firm lub ustawień, które można dostosować. SDK Firebase dla Cloud Functions oferuje wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych w projekcie.
Do wyboru masz te opcje:
- Konfiguracja parametryczna (zalecana w większości scenariuszy). Zapewnia to środowisko o wysokim stopniu wpisania konfigurację z parametrami weryfikowanymi podczas wdrażania, która zapobiega błędom i upraszcza debugowanie.
- Konfiguracja zmiennych środowiskowych na podstawie plików. W ramach tej metody ręcznie tworzysz dotenv do wczytania zmiennych środowiskowych.
W większości przypadków zalecana jest konfiguracja z parametrami. To podejście udostępnia wartości konfiguracji zarówno w czasie działania, jak i podczas wdrażania; wdrożenie jest zablokowane, chyba że wszystkie parametry mają prawidłową wartość. Z drugiej strony konfiguracja za pomocą zmiennych środowiskowych nie jest dostępna w momencie wdrażania.
Konfiguracja z parametrami
Cloud Functions for Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracji w kodzie. Wartości tych parametrów są dostępne zarówno podczas wdrażania funkcji, podczas konfigurowania opcji wdrażania i czasu wykonywania, jak i podczas wykonywania. Oznacza to, że interfejs wiersza poleceń zablokuje wdrożenie chyba że wszystkie parametry mają prawidłową wartość.
Aby zdefiniować parametry w kodzie, postępuj zgodnie z tym wzorcem:
const functions = require('firebase-functions/v1');
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 konfiguracji ze skonfigurowanymi parametrami
Interfejs wiersza poleceń Firebase najpierw próbuje wczytać wartości z lokalnych plików .env. Jeśli nie ma ich w tych plikach i nie ma ustawionej zmiennej default, podczas wdrażania pojawi się prośba o podanie wartości, które zostaną automatycznie zapisane 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 tworzenia warto dodać wygenerowany plik .env.<project_ID> do kontroli wersji.
Używanie parametrów w zakresie globalnym
Podczas wdrażania kod funkcji jest wczytywany i sprawdzany, zanim parametry będą miały rzeczywiste wartości. Oznacza to, że pobieranie wartości parametrów w ramach globalnego zakresu powoduje niepowodzenie wdrożenia. W przypadku, gdy chcesz użyć parametru do zainicjowania wartości globalnej, użyj wywołania zwrotnego inicjowania.onInit() Ta funkcja wywoływana jest przed uruchomieniem funkcji w produkcji, ale nie jest wywoływana w czasie wdrażania, więc jest bezpiecznym miejscem do uzyskiwania wartości parametrów.
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 konfigurować za pomocą obiektu Options, który określa sposób wyświetlania przez CLI promptów z prośbą o wartości. W tym przykładzie ustawiono opcje weryfikacji formatu numeru telefonu, aby zapewnić prostą opcję 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 zapewnia silne typowanie wartości parametrów i obsługuje również obiekty tajne z usługi Cloud Secret Manager. Obsługiwane typy to:
- 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 momencie wdrożenia, jak i w trakcie, gdy funkcja . Ze względu na te podwójne środowiska należy zachować dodatkową ostrożność, gdy porównywać wartości parametrów i używać ich do ustawiania opcji środowiska wykonawczego dla funkcji.
Aby przekazać parametr funkcji jako opcję czasu wykonywania, prześlij go bezpośrednio:
const functions = require('firebase-functions/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
//…
Ponadto, jeśli musisz porównać z parametrem, aby wiedzieć, co musisz użyć wbudowanych komparatorów zamiast sprawdzając wartość:
const functions = require('firebase-functions/v1');
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 używane tylko w czasie działania mogą być
za pomocą funkcji value:
const functions = require('firebase-functions/v1');
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 SDK Cloud Functions oferuje 3 zdefiniowane wstępnie parametry dostępne w podpakiecie firebase-functions/params:
projectID– projekt Cloud, w którym działa funkcja.databaseURL– adres URL wystąpienia Bazy danych czasu rzeczywistego powiązanego z funkcją (jeśli jest włączone w projekcie Firebase).storageBucket– zasobnik Cloud Storage powiązany z funkcją (jeśli jest włączony w projekcie Firebase).
Te parametry działają tak samo jak zdefiniowane przez użytkownika parametry łańcucha znaków, z tym wyjątkiem, że ich wartości są zawsze znane interfejsowi wierszowemu Firebase, więc nie trzeba ich podawać podczas wdrażania ani zapisywać w plikach .env.
Parametry obiektu tajnego
Parametry typu Secret, zdefiniowane za pomocą defineSecret(), reprezentują ciąg znaków
parametry z wartością zapisaną w usłudze Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać w nim nową wartość, jeśli jest ona nieobecna, parametry obiektów tajnych sprawdzają ich istnienie w usłudze Cloud Secret Manager i proszą o wartość nowego obiektu tajnego podczas wdrażania.
Parametry obiektu tajnego 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/v1');
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 tajnych danych są ukryte do momentu wykonania funkcji, więc nie możesz ich używać podczas konfigurowania funkcji.
Zmienne środowiskowe
Cloud Functions for Firebase obsługuje
Dotenv
służący do wczytywania zmiennych środowiskowych określonych w pliku .env do
w środowisku wykonawczym aplikacji. Po wdrożeniu zmienne środowiskowe można odczytać 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
.envw katalogufunctions/:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.jsOtwórz plik
.envdo edycji i dodaj odpowiednie klucze. Przykład:PLANET=Earth AUDIENCE=HumansWdróż funkcje i sprawdź, czy wczytano zmienne środowiskowe:
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ą
process.env
składnia:
// 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 zbiorów zmiennych środowiskowych
Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla Firebase
projektów (takich jak etap przejściowy czy produkcyjny), utwórz
.env.<project or
alias> i zapisz
zmiennych środowiskowych dla konkretnego projektu. Zmienne środowiskowe z plików .env i plików .env (jeśli istnieją) związanych z poszczególnymi projektami zostaną uwzględnione we wszystkich funkcjach.
Na przykład projekt może zawierać te 3 pliki z nieco innymi wartościami na potrzeby wersji deweloperskiej i produkcyjnej:
.env
|
.env.dev
|
.env.prod
|
| PLANET=Ziemia
AUDIENCE=ludzie |
AUDIENCE=Dev Humans | AUDIENCE=Produkcy ludzie |
Biorąc pod uwagę wartości w tych osobnych plikach, zbiór zmiennych środowiskowych wdrożenia wraz z funkcjami będą 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. W plikach .env nie używaj tych kluczy:
- 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 tej listy:
- CLOUD_RUNTIME_CONFIG
- ENTRY_POINT
- PROJEKT_GCP
- GCLOUD_PROJECT
- GOOGLE_CLOUD_PROJECT
- TYP_FUNKCJI_TRIGGER_TYP
- FUNCTION_NAME
- FUNCTION_MEMORY_MB
- FUNCTION_TIMEOUT_SEC
- FUNCTION_IDENTITY
- FUNCTION_REGION
- FUNCTION_TARGET
- FUNCTION_SIGNATURE_TYPE
- K_SERVICE
- K_REVISION
- PORT
- K_CONFIGURATION
Przechowywanie poufnych informacji o konfiguracji i uzyskiwanie do nich dostępu
Zmienne środowiskowe przechowywane w plikach .env można używać do konfigurowania funkcji, ale nie są one bezpiecznym sposobem przechowywania poufnych informacji, takich jak dane logowania do bazy danych czy klucze interfejsu API. Jest to szczególnie ważne, jeśli pliki .env są sprawdzane w kontroli źródłowej.
Aby ułatwić przechowywanie poufnych informacji konfiguracyjnych, Cloud Functions for Firebase integruje się z usługą Google Cloud Secret Manager. Ta zaszyfrowana usługa przechowuje wartości konfiguracji w bezpieczny sposób, a jednocześnie umożliwia łatwy dostęp z funkcji w razie potrzeby.
Tworzenie obiektu tajnego i korzystanie z niego
Aby utworzyć obiekt tajny, użyj interfejsu wiersza poleceń Firebase.
Aby utworzyć obiekt tajny i z niego korzystać:
W katalogu głównym katalogu projektu lokalnego uruchom to polecenie:
firebase functions:secrets:set SECRET_NAME
Wpisz wartość w polu SECRET_NAME.
W interfejsie wiersza poleceń wyświetla się komunikat o udanym zakończeniu i ostrzeżenie, że musisz wdrożyć funkcje, aby zmiany zaczęły 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 });Wdróż Cloud Functions:
firebase deploy --only functions
Będzie można z niej korzystać tak samo jak do wszystkich innych zmiennych środowiskowych.
Jeśli natomiast inna funkcja, która nie określa obiektu tajnego w elementzie runWith, próbuje uzyskać do niego dostęp, otrzymuje wartość nieokreśloną:
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 wartości obiektu tajnego. Tylko funkcje, które w parametrze runWith zawierają obiekt tajny, będą miały dostęp do tego obiektu jako zmiennej środowiskowej. Dzięki temu upewnisz się,
wartości obiektów tajnych są dostępne tylko wtedy, gdy są potrzebne. Zmniejsza to ryzyko
przypadkowe ujawnienie tajemnicy.
Zarządzanie obiektami tajnymi
Aby zarządzać obiektami tajnymi, użyj interfejsu wiersza poleceń Firebase. Podczas zarządzania obiektami tajnymi w ten sposób pamiętaj, że niektóre zmiany w CLI wymagają modyfikacji lub ponownego wdrożenia powiązanych funkcji. Więcej szczegółów:
- Za każdym razem, gdy ustawisz nową wartość obiektu tajnego, musisz ponownie wdrożyć wszystkie funkcje, które odwołują się aby wydobyć z niej najnowszą wartość.
- Jeśli usuniesz obiekt tajny, upewnij się, że żadna z wdrożonych funkcji nie odwołuje się do tego obiektu. Funkcje korzystające z wartości obiektu tajnego, która została nie zostanie jednak usunięta bez powiadomienia.
Oto podsumowanie poleceń interfejsu wiersza poleceń Firebase do zarządzania 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ć wersję opcjonalną
do zarządzania konkretną wersją. Przykład:
functions:secrets:access SECRET_NAME[@VERSION]
Aby uzyskać więcej informacji o tych operacjach, przekaż -h z poleceniem do
wyświetl pomoc interfejsu wiersza poleceń.
Jak są rozliczane obiekty tajne
Secret Manager zezwala na 6 aktywnych obiektów tajnych wersje bezpłatnie. Oznacza to, że w projekcie Firebase możesz mieć 6 tajemnic miesięcznie bez dodatkowych opłat.
Domyślnie narzędzie wiersza poleceń Firebase automatycznie usuwa nieużywane wersje obiektów tajnych, gdy jest to właściwe, np. gdy wdrażasz funkcje z nową wersją obiektu tajnego. Możesz też aktywnie usuwać nieużywane sekrety za pomocą funkcji functions:secrets:destroy i functions:secrets:prune.
Secret Manager umożliwia 10 000 nierozliczonych operacji dostępu miesięcznego w
obiektu tajnego. Identyfikatory funkcji odczytują tylko tajne informacje określone w parametrze runWith za każdym razem, gdy są uruchamiane na zimno. Jeśli masz wiele instancji funkcji
czyta wiele obiektów tajnych, wówczas projekt może przekroczyć ten limit,
zapłacisz 0,03 USD za 10 000 operacji dostępu.
Więcej informacji: Secret Manager Ceny.
Obsługa emulatora
Konfiguracja środowiska za pomocą dotenv jest przeznaczona do interakcji z lokalnym Cloud Functions emulatorem.
Jeśli używasz lokalnego emulatora Cloud Functions, możesz zastąpić środowisko
dla swojego projektu, konfigurując plik .env.local. Zawartość
Reguła .env.local ma pierwszeństwo przed .env oraz plikiem .env konkretnego projektu.
Projekt może na przykład zawierać te trzy pliki zawierające nieco różne wartości w przypadku programowania i testów lokalnych:
.env
|
.env.dev
|
.env.local
|
| PLANET=Ziemia
AUDIENCE=ludzie |
AUDIENCE=Programiści | AUDIENCE=Local Humans |
Gdy zostanie uruchomiony w kontekście lokalnym, emulator wczytuje zmienne środowiskowe w ten sposób:
$ firebase emulators:start
i emulators: Starting emulators: functions
# Starts emulator with following environment variables:
# PLANET=Earth
# AUDIENCE=Local Humans
Tajne informacje i dane logowania w emulatorze Cloud Functions
Emulator Cloud Functions obsługuje używanie obiektów tajnych do przechowywania informacji konfiguracyjnych o charakterze poufnym i dostępu do nich. Domyślnie emulator będzie próbować uzyskać dostęp do tajnych danych produkcyjnych za pomocą domyślnych danych logowania aplikacji. W niektórych sytuacjach, np. w środowiskach CI, emulowany system może nie mieć dostępu do wartości tajnych ze względu na ograniczenia uprawnień.
Podobnie jak emulator Cloud Functions obsługuje zmienne środowiskowe, możesz:
aby zastąpić wartości obiektów tajnych, konfigurując plik .secret.local. Dzięki temu
możesz łatwo przetestować funkcje 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ść dotychczasową konfigurację jako zmienne środowiskowe (w formacie dotenv).
Interfejs wiersza poleceń Firebase udostępnia polecenie eksportowania, które generuje konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc katalogu (w przykładzie poniżej: local, dev i prod) w plikach .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
W niektórych przypadkach pojawi się prośba o wpisanie prefiksu, aby zmienić nazwę wyeksportowanych kluczy zmiennych środowiskowych. Dzieje się tak, ponieważ nie wszystkie konfiguracje zostać automatycznie przekształcone, ponieważ mogą być nieprawidłowe lub zarezerwowany klucz 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 niektóre wartości są poufne i nie powinny zostać ujawnione, usuń je z plików .env i przechowuj bezpiecznie w plikach Secret Manager.
Musisz też zaktualizować kod funkcji. Wszystkie funkcje używające funkcji
functions.config będzie teraz musiał(a) używać zamiast tego identyfikatora process.env, jak pokazano na
Przejdź na 2 generację.
Konfiguracja środowiska
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 umieścić w przestrzeni nazw za pomocą kropek, aby grupować powiązane
konfiguracji. Pamiętaj, że w kluczach akceptowane są tylko małe litery. Duże litery są niedozwolone.
Aby na przykład zapisać identyfikator klienta i klucz interfejsu API dla „Some Service” – 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 w projekcie,
może używać elementu firebase functions:config:get. Zwrócony wynik JSON będzie w stylu
to:
{
"someservice": {
"key":"THE API KEY",
"id":"THE CLIENT ID"
}
}
Ta funkcja opiera się na: Interfejs Google Cloud Runtime Configuration API.
Użyj functions.config, aby uzyskać dostęp do konfiguracji środowiska w funkcji
Niektóre ustawienia są automatycznie udostępniane w rezerwowanym zakresie nazw firebase. Konfiguracja środowiska została udostępniona w aplikacji
za pomocą functions.config().
Aby użyć powyższej konfiguracji, Twój kod może wyglądać tak:
const functions = require('firebase-functions/v1');
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}
});
});
Inicjalizacja modułu za pomocą konfiguracji środowiska
Niektóre moduły węzła są gotowe do użycia bez konfiguracji. Inne moduły wymagają dodatkowej konfiguracji, aby można je było prawidłowo zainicjować. Zalecamy zapisanie tej konfiguracji w zmiennych konfiguracji środowiskowych zamiast umieszczać na stałe w kodzie. Dzięki temu Twój kod będzie bardziej przenośny, co pozwoli Ci udostępnić kod źródłowy aplikacji lub łatwo przełączać się między wersjami produkcyjną i testową.
Aby na przykład użyć modułu Slack Node SDK, kod powinien wyglądać tak:
const functions = require('firebase-functions/v1');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);
Przed wdrożeniem ustaw zmienną konfiguracji środowiska slack.url:
firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX
Dodatkowe polecenia dla środowiska
firebase functions:config:unset key1 key2usuwa określone klucze z konfiguracjifirebase functions:config:clone --from <fromProject>klonuje środowisko innego projektu do aktywnego projektu.
Zmienne środowiskowe wypełniane automatycznie
Zmienne środowiskowe są automatycznie uzupełniane w czasie działania i w funkcjach emulowanych lokalnie. Obejmują one: tych, które wypełniono przez Google Cloud, oraz zmienną środowiskową Firebase:
process.env.FIREBASE_CONFIG: zawiera te informacje o konfiguracji projektu Firebase:
{
databaseURL: 'https://databaseName.firebaseio.com',
storageBucket: 'projectId.appspot.com',
projectId: 'projectId'
}
Ta konfiguracja jest stosowana automatycznie, gdy inicjujesz pakiet SDK Firebase Admin bez argumentów. Jeśli funkcje są pisane w JavaScript, zainicjuj je w ten sposób:
const admin = require('firebase-admin');
admin.initializeApp();
Jeśli funkcje są pisane w TypeScript, inicjuj je w ten sposób:
import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();
Jeśli chcesz zainicjować pakiet Admin SDK za pomocą domyślnej konfiguracji projektu, używając danych logowania konta usługi, możesz załadować te dane 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);