Konfigurowanie środowiska


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óż:

  1. Utwórz plik .env w katalogu functions/:

    # Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

  2. Otwórz plik .env do edycji i dodaj odpowiednie klawisze. Na przykład:

    PLANET=Earth
AUDIENCE=Humans

  3. 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
  • ENTRY_POINT
  • GCP_PROJECT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • 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 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:

  1. W katalogu głównym projektu lokalnego uruchom to polecenie:

    firebase functions:secrets:set SECRET_NAME

  2. 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ć.

  3. 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
  });

  4. 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. Oto najważniejsze kwestie:

  • 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ą. Na 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 versions 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 konfiguracji
  • firebase 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);