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ść.
Node.js
const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
{ minInstances: minInstancesConfig },
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Python
from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam
MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")
# To use configured parameters inside the config for a function, provide them
# directly. To use them at runtime, call .value() on them.
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
return https_fn.Response(f'{WELCOME_MESSAGE.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.
Node.js
const { GoogleGenerativeAI } = require('@google/generative-ai');
const { defineSecret } = require('firebase-functions/params');
const { onInit } = require('firebase-functions/v2/core');
const apiKey = defineSecret('GOOGLE_API_KEY');
let genAI;
onInit(() => {
genAI = new GoogleGenerativeAI(apiKey.value());
})
Python
from firebase_functions.core import init
from firebase_functions.params import StringParam, PROJECT_ID
import firebase_admin
import vertexai
location = StringParam("LOCATION")
x = "hello"
@init
def initialize():
# Note: to write back to a global, you'll need to use the "global" keyword
# to avoid creating a new local with the same name.
global x
x = "world"
firebase_admin.initialize_app()
vertexai.init(PROJECT_ID.value, location.value)
Jeśli używasz parametrów typu Secret
, pamiętaj, że są one dostępne tylko w procesie funkcji powiązanych z obiektem tajnym. Jeśli obiekt tajny jest powiązany tylko w niektórych funkcjach, przed jego użyciem sprawdź, czy obiekt secret.value()
nie jest sfałszowany.
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:
Node.js
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: params.select(["odd", "even"])});
const memory = defineInt("MEMORY", {
description: "How much memory do you need?",
input: params.select({ "micro": 256, "chonky": 2048 }),
});
const extensions = defineList("EXTENSIONS", {
description: "Which file types should be processed?",
input: params.multiSelect(["jpg", "tiff", "png", "webp"]),
});
const storageBucket = defineString('BUCKET', {
description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets",
input: params.PICK_STORAGE_BUCKET,
});
Python
from firebase_functions.params import (
StringParam,
ListParam,
TextInput,
SelectInput,
SelectOptions,
ResourceInput,
ResourceType,
)
MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
WELCOME_MESSAGE = StringParam(
"WELCOME_MESSAGE",
default="Hello World",
description="The greeting that is returned to the caller of this function",
)
ONLY_PHONE_NUMBERS = StringParam(
"PHONE_NUMBER",
input=TextInput(
validation_regex="\d{3}-\d{3}-\d{4}",
validation_error_message="Please enter a phone number in the format XXX-YYY-XXX",
),
)
SELECT_OPTION = StringParam(
"PARITY",
input=SelectInput([SelectOptions(value="odd"), SelectOptions(value="even")]),
)
STORAGE_BUCKET = StringParam(
"BUCKET",
input=ResourceInput(type=ResourceType.STORAGE_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
- Lista (Node.js)
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:
Node.js
const { onRequest } = require('firebase-functions/v2/https');
const { defineInt } = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');
export const helloWorld = onRequest(
{ minInstances: minInstancesConfig },
(req, res) => {
//…
Python
from firebase_functions import https_fn
from firebase_functions.params import IntParam
MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
...
Poza tym w przypadku porównywania z parametrem, aby dowiedzieć się, którą opcję wybrać, musisz użyć wbudowanych porównywaczy, zamiast sprawdzać wartość:
Node.js
const { onRequest } = require('firebase-functions/v2/https');
const environment = params.defineString(‘ENVIRONMENT’, {default: 'dev'});
// use built-in comparators
const minInstancesConfig = environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = onRequest(
{ minInstances: minInstancesConfig },
(req, res) => {
//…
Python
from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam
ENVIRONMENT = StringParam("ENVIRONMENT", default="dev")
MIN_INSTANCES = ENVIRONMENT.equals("PRODUCTION").then(10, 0)
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
...
Parametry i wyrażenia parametrów, które są używane tylko w czasie działania, są dostępne za pomocą funkcji value
:
Node.js
const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Python
from firebase_functions import https_fn
from firebase_functions.params import StringParam
WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")
@https_fn.on_request()
def hello_world(req):
return https_fn.Response(f'{WELCOME_MESSAGE.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
:
Node.js
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).
Python
PROJECT_ID
– projekt Cloud, w którym działa funkcja.DATABASE_URL
– adres URL instancji Bazy danych czasu rzeczywistego powiązanej z funkcją (jeśli jest włączona w projekcie Firebase).STORAGE_BUCKET
– 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:
Node.js
const { onRequest } = require('firebase-functions/v2/https');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');
export const postToDiscord = onRequest(
{ secrets: [discordApiKey] },
(req, res) => {
const apiKey = discordApiKey.value();
//…
Python
from firebase_functions import https_fn
from firebase_functions.params import SecretParam
DISCORD_API_KEY = SecretParam('DISCORD_API_KEY')
@https_fn.on_request(secrets=[DISCORD_API_KEY])
def post_to_discord(req):
api_key = DISCORD_API_KEY.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ć przez interfejs process.env
(w projektach opartych na Node.js) lub os.environ
(w projektach opartych na Pythonie).
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 ma do nich dostęp:
Node.js
// Responds with "Hello Earth and Humans"
exports.hello = onRequest((request, response) => {
response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});
Python
import os
@https_fn.on_request()
def hello(req):
return https_fn.Response(
f"Hello {os.environ.get('PLANET')} and {os.environ.get('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
:Node.js
const { onRequest } = require('firebase-functions/v2/https'); exports.processPayment = onRequest( { secrets: ["SECRET_NAME"] }, (req, res) => { const myBillingService = initializeBillingService( // reference the secret value process.env.SECRET_NAME ); // Process the payment } );
Python
import os from firebase_functions import https_fn @https_fn.on_request(secrets=["SECRET_NAME"]) def process_payment(req): myBillingService = initialize_billing(key=os.environ.get('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ść:Node.js
exports.anotherEndpoint = 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 });
Python
@https_fn.on_request() def another_endpoint(req): return https_fn.Response(f"The secret API key is {os.environ.get("SECRET_NAME")}") # Responds with "The secret API key is None" because the `secrets` 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 korzystające z metody functions.config
będą teraz musiały używać parametru process.env
, jak pokazano w zmiennych środowiskowych.